继承的概念: 向上抽取共性,把相同的内容定义在父类中
必须满足  xxx是yyy的一种 
格式:
	public class 父类 { } 
	public class 子类A extends 父类B { }  
 子类可以使用父类中除了private修饰的和构造方法以外的内容
 //定义子类可以特有功能
public class Teacher extends Employee {
    //特有功能: 讲课
    public void teaching() {
         System.out.println(this.num);//使用Zi02类的成员变量num: 1000
        System.out.println(super.num);//使用Fu02类的成员变量num: 100 
    } 
}
调用t.teaching();

继承中的成员变量访问特点

 
        1.不重名的成员变量   子类优先使用子类自己的，没有找父类，但是父类不能找子类
        2.重名的成员变量
    	  (1)方法内部,直接写变量名
                方法内部有: 直接使用
                方法内部没有: 向上找,本类的成员位置有直接使用
                本类的成员位置没有向上找,父类的成员位置
            (2)方法内部,直接写this.变量名
                本类的成员位置有直接使用，没有向上找父类的成员位置
            (3)方法内部,直接写super.变量名
                从父类成员位置开始向上找，有直接使用，没有继续向上找
            (4)总结:就近原则
            

继承中成员方法的访问特点

父类没有初始化子类不能用
子空参调用父空参  子满参调用父满参
方法重写  子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同）
@Override注解:用来检测子类方法,是否是对父类方法的覆盖重写
 必要条件:方法名和参数列表必须相同
 可选条件:返回值类型可以不一致(后面讲)
 与方法重载区分开: 
   方法重载作用:是节约命名空间
   方法重载要求: 方法名称相同,参数列表不同(类型不同,数量不同,多个不同类型的顺序不同)
方法重写快捷键:
   ctrl + o --> 选择要重写的方法 --> ok
   public class Fu03 {
    //成员方法
    public void methodFu() {
        System.out.println("Fu04....methodFu....");
    }
    //开车
    public void drive() {
        System.out.println("开着奥拓,冒着狼烟去东北...");
    }
    //展示信息
    public void show(String name, int age) {
        System.out.println(name + "::::" + age);
    }
}
//子类
public class Zi03 extends Fu03 {
 
            //直接调用父类的此功能就可以了
      注意:  super.成员方法名称(实际参数列表...): 表示直接调用父类的成员方法,父类没有继续向上找
        super.show();
    //重写父类的drive方法
    @Override
    public void drive() {
        System.out.println("开着玛莎拉蒂,一路高歌去东莞...");
    }
    //开车
    //@Override //该方法不是对父类方法的覆盖重写,使用@Override 会报错
    //此方法和上面的方法构成了重载
    public void drive(String car) {
        System.out.println("开着" + car + ",一路高歌去东莞...");
    }
    @Override
    public void show(String name, int age) {
        System.out.println("姓名: " + name + ", 年龄: " + age);
    }
}
public class Demo03Extends {
    public static void main(String[] args) {
        //创建子类对象
        Zi03 zi = new Zi03(); 
        //子父类中重名的方法(方法重写): 优先使用子类自己的
        zi.drive();
        zi.show("张三",18);
    }
}

方法重写的注意事项

子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
        权限:    public > protected > 默认(什么都不写) > private

     子类覆盖重写后的方法的返回值类型 <= 父类方法返回值类型 
     私有方法不能被重写(父类私有成员子类是不能继承的)  
 //父类            
public class Fu05 {
 
    //默认权限
  父  void b() {  }
   //子类重写后的方法的权限>父类方法权限
  子 @Override
    public void b() {}

   父   public void c() {  }
//错误: 子类重写后的方法的权限 < 父类方法权限
    //不允许
  子  /*void c() {  }*/
    
    父    public String e() {
        return "Hello";
    }
 子 
    //错误: 子类重写后的方法的返回值类型 > 父类方法的返回值类型 
    /*public Object e() {
        return new Object();
    }*/
    private void f() {

    }  

    //父类方法时private修饰的,子类无法继承,更无法覆盖重写
    //不加@Override是没错的,因为此时f属于子类自己的方法,和父类方法无关
    //@Override
    public void f() {

    }
}

继承中构造方法的访问特点

/*
    1.构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的
    2.子类继承父类,是为了使用父类的内容,所以子类创建对象调用构造方法时,必须先调用父类的构造方法,
        完成父类成员的初始化动作,子类才可以使用父类的成员,默认提供super()表示调用父类的空参构造 
    3.super调用父类构造,只能写在第一句
    4.构造方法可以重载,所以:
            super(...):调用父类带参数的构造方法
    //父类
public class Fu06 {
    int num;
    //父空参构造
    public Fu06(){
        System.out.println("父空参...");
    }
    //父有参构造
    public Fu06(int num) {
        System.out.println("父有参");
        this.num = num;
    }
}

//子类
public class Zi06 extends Fu06{
    //子空参构造
    public Zi06(){
        super();//调用父类空参构造,不写也有，只能调用一次，必须写在第一行,先调用父类空参构造
    }
    //子有参构造
    public Zi06(int num) { 
        super(num);
        System.out.println("子有参...");
    }
}
//测试类
public class Demo06Extends {
    public static void main(String[] args) {
        //空参构造创建对象
        Zi06 zi = new Zi06();
        System.out.println("----");
        //有参构造创建对象
        Zi06 zi2 = new Zi06(100);
        System.out.println(zi2.num);
    }
}        
*/ 
父类public class Employee {
    //(1)成员变量(必须使用private修饰): 姓名,年龄,工资
    private String name;
    private int age;
    private int salary; 
    public Employee(String name, int age, int salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    } 
    2.定义子类讲师Teacher类 继承 父类员工Employee类
        (1)根据父类生成空参/满参构造方法
        (2)定义子类特有功能: 讲课 
子类public class Teacher extends Employee {
  
  子类特有 public Teacher任意(String name, int age, int salary) {
        super(name, age, salary);//继承父类
    }
 调用Teacher t = new Teacher("响哥", 16, 66666);
    一个子类只能有一个直接父类
      1.Java只支持单继承，不支持多继承。
    2.Java支持多层继承(继承体系)。
    3.所有的类都直接或者间接继承了Object类，Object类是所有类的最终父类。 
//父类
Zi0802 extends Fu0802 extends Object {
public class Fu0801 {
} 
//子类
public class Zi0802 extends Fu0802 {
    public void 任意() {
        System.out.println("c....");
    }
}