继承day01

1/*
    继承: 向上抽取共性,把相同的内容定义在父类中
        public class 子类 extends 父类 {
            //成员变量 +成员方法 +构造方法
        }
        2.子类可以使用父类中除了private修饰的和构造方法以外的内容
 */
public class Demo01Extends {
    public static void main(String[] args) {
        //创建子类Teacher类的对象
        Teacher t = new Teacher();
        //给成员变量赋值
        t.name = "响哥";
        t.salary/birthday = 66666; 
        t.show();  //
    }
}

2

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

        this.变量名: 代表当前类的成员变量 this.num

        super.变量名: 父类的成员变量 super.num

*/

继承中成员方法的访问特点
       1.子类自己有: 优先使用子类自己的
       2.子类没有: 向上找父类
       3.重名的方法(方法重写): 优先使用子类自己的

方法重写
    1.概念:
        子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），
        会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。
        必要条件:方法名和参数列表必须相同
        可选条件:返回值类型可以不一致(后面讲)
    2.最简单的方法重写形式:
        子类方法声明(定义方法的第一行)和父类方法声明一模一样
    [email protected]注解:用来检测子类方法,是否是对父类方法的覆盖重写
    4.与方法重载区分开:
        方法重载作用: 是节约命名空间
        方法重载要求: 方法名称相同,参数列表不同(类型不同,数量不同,多个不同类型的顺序不同)
    5.方法重写快捷键:
        ctrl + o --> 选择要重写的方法 --> ok

直接调用父类的成员方法: super.成员方法名称(参数列表...)

//@Override
public void show(int num) {
    System.out.println("Zi03...show...num..." + num);
}

@Override //不报错: 是对父类方法的重写,因为方法名称相同,参数列表也相同
public void show() {
    System.out.println("Zi03...show...");
}

//在Zi03类中出现了两个show方法,不报错
//原因: 名称相同,参数列表不同,构成了重载关系

public class NewPhone extends OldPhone {
    @Override
    public void show() {
        //System.out.println("110来电...");
        //显示电话号码,其实父类的show方法已经实现该功能,
        //子类不用自己重新实现了,直接调用父类的功能
        super.show();
        System.out.println("显示归属地: 东莞...");
        System.out.println("显示头像: ");
    }
}

//满参构造
public Zi05(int num) {
    /*
        如果没有自己写super调用父类构造,
        隐藏提供super()调用父类的空参构造
     */
    //但是建议: 子空参 调用 父类空参
    //但是建议: 子满参 调用 父类满参
    super(num);
    System.out.println("子满参...");
    //super(num);//错误: 调用父类构造必须写在第一行
}

//创建子类对象: 空参构造
Zi05 zi = new Zi05();
//创建子类对象: 满参构造
Zi05 zi2 = new Zi05(100);

/*
    继承中构造方法的访问特点
        1.构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的
        2.子类继承父类,是为了使用父类的内容,
            所以子类创建对象调用构造方法时,
            必须先调用父类的构造方法,
            完成父类成员的初始化动作,
            子类才可以使用父类的成员,
            super()表示调用父类的空参构造
        3.子类的构造方法中如果没有手动给出super调用父类构造,
                编译器默认提供一个super()调用父类的空参构造
        4.super调用父类构造,只能写在第一句
        5.构造方法可以重载,所以:
                super(...):调用父类带参数的构造方法
//创建子类对象: 空参构造
        Zi05 zi = new Zi05();
        //创建子类对象: 满参构造
        Zi05 zi2 = new Zi05(100);
    super的用法:
        1.super.成员变量名: 代表父类的成员变量
        2.super.成员方法(参数列表...): 代表调用父类的成员方法
        3.super(参数列表...): 代表调用父类的构造方法

    this的用法:
        1.this.成员变量名: 代表本类自己的成员变量(自己没有找父类)
        2.this.成员方法(参数列表...): 代表本类自己的成员方法(自己没有找父类)
        3.this(参数列表...): 代表调用本类自己的其它构造方法 ---后面讲
*/

public class Fu05 {
    private int num;
    //空参构造
    public Fu05(){
        System.out.println("父空参...");
    }

    //满参构造
    public Fu05(int num) {
        System.out.println("父满参...");
        this.num = num;
    }

    //get和set方法
    public void setNum(int num) {
        this.num = num;// 
     super(num);      

    public int getNum() {
        return num;
    }
}

/*
    如果没有自己写super调用父类构造,
    隐藏提供super()调用父类的空参构造
 */
//但是建议: 子空参 调用 父类空参
//但是建议: 子满参 调用 父类满参

/*
    定义父类员工Employee类
        1.所有成员变量private修饰
        2.提供空参/满参构造方法
        3.提供get/set方法
        4 //特有方法: 
 */
 //创建子类Teacher类的对象: 满参构造
//        Teacher t =
//                new Teacher("响哥",18,66666,33333);
//
//                //调用成员方法
//                t.show();
//                t.teaching();
//                System.out.println("-----------");
//
//                //创建子类Manager类的对象: 空参构造
//                Manager m = new Manager();
//
//                //给成员变量赋值
//                m.setName("玲姐");
//                m.setAge(16);
//                m.setSalary(88888);
public class Employee {
    // private成员变量
    
    //成员方法: 展示信息
    //2.提供空参构造方法
    //2.提供空参构造方法
    //3.提供get/set方法
}

/*
    类的继承特点
        1.Java只支持单继承，不支持多继承。
//Java中的类可以多层继承爷父子
        2.Java支持多层继承(继承体系)。
        3.所有的类都直接或者间接继承了Object类，Object类是所有类的最终父类。
 */
//错误: 一个类只能直接继承一个父类

public abstract class Animal {
    //成员变量
      //空参构造 

    //满参构造 

    //展示信息的方法 
    //抽象方法: 吃 

    //抽象方法: 睡 

    //get和set方法 
}

public abstract class Animal {
    //抽象方法: 吃
    public abstract void eat();

    //抽象方法: 睡
    public abstract void sleep();
}

/*
    抽象父类和之前普通类的定义的区别?
        1.不能直接创建对象
        2.内部可以定义抽象方法
 */

/*
    抽象: 
        2.抽象类中抽象方法存在的意义:强制要求子类必须具备的能力
        3.抽象类的定义格式:
            public abstract class 类名 {
                ...
            }
        4.抽象方法的定义格式:

//错误: 不能直接创建抽象类的对象
//Animal a = new Animal();
//创建Cat类的对象
Cat cat = new Cat();
//子类对象调用成员方法
cat.eat();
cat.sleep();

            修饰符 abstract 返回值类型 方法名称(参数列表...);
            注意:
                (1)和以前定义方法一样,但是去掉{},添加abstract关键字
                (2)返回值类型和参数列表根据需求确定 
 (3)含有抽象方法的类,必须定义为抽象类,但是抽象类中不一定含有抽象方法
        5.抽象类的使用
            (1)不能直接创建抽象类的对象
            (2)定义子类,继承抽象父类
            (3)子类中覆盖重写抽象父类中的所有抽象方法
                        去掉abstract关键字,添加{}
                        快捷键: ctrl + i
            (4)创建子类对象
            (5)子类对象调用方法
*/

//-----------------------------------------------------------------------------------

//---------------------------------------------------------------------------------

//---------------------------------------------------------------------------------

/*
    抽象类的注意事项:
 (3)含有抽象方法的类,必须定义为抽象类,但是抽象类中不一定含有抽象方法
 4.抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类
 3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类 看: MyAbstractClass
        1.抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象
        2.抽象类中，必须有构造方法，是供子类创建对象时，初始化父类成员使用的
       
  

//-----------------------------------------------------------------------------------

//---------------------------------------------------------------------------------

//---------------------------------------------------------------------------------

     

*/
 

//错误: 不能直接创建抽象类的对象
//Animal a = new Animal();
//创建Cat类的对象: 空参构造
Cat cat = new Cat(); 
//调用set方法给成员变量赋值
cat.setName("小花");
cat.setWeight(10);

    问题:
        Animal中有两个抽象方法eat和sleep,但是对应当前子类而言,
        只覆盖重写了一个抽象方法eat,相当于子类自己有个抽象方法sleep
        当前子类必须定义为抽象类
 public abstract void sleep();