Java三大特征：封装，继承和多态
成员变量：静态成员变量(static)和实例成员变

访问方法：类名.静态成员变量；对象.实例成员变量；对象.静态成员变量；（第三个不推荐）

套话：静态的都可以访问，实例的只能实例的访问

继承中子类不能继承父类的构造方法,eg:父类：public People(int age){this.age=age},子类就不能继承这个
@Override注释的用法

子类重写方法的修饰符要比父类的更大或一样，EG：父类：protected,子类：public;
子类重写方法的返回值类型要比父类小或一样，RG:父类：public object run(){},子类:public Integer run(){};
继承后的全部（有参和无参）构造器一定会先访问父类的无参构造器，再执行子类自己的构造器；
子类的构造器第一行都有一个super();调用父类的无参数构造

成员变量和方法学习时候的代码：

public class class1 {
private String name;
private int age;
private boolean sex;//实例成员变量，属于类的对象，需要添加对象进行访问
public static String schoolname="何平安la";//静态成员变量，属于类本身，可用类名直接访问
public class1(){
}
public class1(String name, int age, boolean sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
public static void speakname(){
System.out.println("呜哈哈哈"+schoolname);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public boolean isSex() {
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
public void speak(){
System.out.println("name:"+this.name+",age:"+age+",sex:"+this.sex);
}
public static void main(String[] args) {
class1 zbj =new class1();
zbj.setName("猪八戒");
System.out.println(zbj.schoolname);
class1.speakname();//类名.静态方法
speakname();//同一个类中访问静态方法可以不写类名
zbj.speak();//对象.实例方法
zbj.speakname();//对象.静态方法（不推荐）
}
}

继承学习时候的代码：

public class c2 {
public static void main(String[] args){
c2 c =new c2();
People p1= new People();
Student s1=new Student();
s1.study();
}
static class People {
public People(){
System.out.println("人");
}
public String name;
public static void swim(){
System.out.println("游泳");
}
public void eat(){
System.out.println("吃饭");
}
public void run(){
System.out.println("跑步");
}
}
static class Student extends People{
public Student(){
// super(); 此处写不写都一样
System.out.println("学生");
}
public void study(){
System.out.println("学习");
eat();//调用子类的eat
super.eat();//调用父类的eat
//super可以在实例方法中调用子类中被重写的方法
}
@Override//加上注解后可以检查父类的方法是否写错，注释特点可读性好，安全，优雅~
public void eat(){
System.out.println("学生吃的多");//方法重写
}
// @Override
//此处方法名与父类的不一样，报错提示
public void run1(){
System.out.println("学生跑步");
}
public int id;
// @Override
public static void swim(){
}//静态方法不能被重写,因为静态方法只能用于自己的类，不能重写,单独写一样的方法相当于写了个新的静态方法，而不是重写
}

}