【Java_08】继承、super与this、抽象类

① 多个类中有相同的属性和行为，将这些单独抽取到一个单独的类中，然后再继承这个类即可，无需再定义这些属性和行为。
② 继承就是子类继承父类的非私有的属性和方法。
③ 好处
    * 提高了代码的复用性
    * 继承是多态的前提

① 格式
    public class 父类 { ··· }
    public class 子类 extends 父类 { ··· }
② 成员变量
    * 不重名没有影响，使用谁就是谁。
    * 重名则 new 谁就是谁的 ( 开发中一般不会重名 )，此时如果要使用父类的非私有成员变量与需要使用 super.父类成员变量名。
③ 成员方法
    * 不重名没有影响，使用那个方法就是那个方法。
    * 重名则为子类重写（覆盖）父类方法，声明不变，重新实现。
④ 构造方法
    * 构造方法名与类名一致，所以不能被继承。
    * 构造方法是用来初始化成员变量的，所以子类初始化的过程中，父类必须先于子类初始化。即调用构造方法时，一定先调用父类的构造方法。
    * 子类的空参构造中会默认写有 super()，表示调用父类的构造方法，父类的成员变量初始化之后才可以给子类使用。
⑤ 示例
    //父类，手机类
    public class Phone {
        //成员变量
        private String brand;

        private String price;
 
        //构造方法
        public Phone() {
        }
 
        public Phone(String brand, String price) {
            this.brand = brand;
            this.price = price;
        }
 
        //成员方法
        public void call() {
            System.out.println("? 打电话！");
        }
 
        public void send() {
            System.out.println("? 发短信！");
        }
 
        public void show() {
            System.out.println(brand + "牌手机，售价" + price);
        }
    }
 
    //子类，华为手机
    public class HonorPhone extends Phone{
        //构造方法
        public HonorPhone() {
            //默认有 super();
        }
 
        public HonorPhone(String brand, String price) {
            super("Lenovo P30 pro","9999");
        }
 
        //重写父类方法
        @Override
        public void call() {
            super.call();   //调用父类原有 call() 方法
 
            System.out.println("new? 显示姓名! ");
 
            System.out.println("new? 显示图片! ");
        }
 
        //子类特有方法
        public void inter() {
            System.out.println("new? 上网!");
        }
    }
 
    //测试类
    public class test {
        public static void main(String[] args) {
            //new 对象
            HonorPhone hp = new HonorPhone();
 
            //调用父类方法
            hp.send();
            hp.call();
            //调用子类重写方法
            hp.show();
            //调用子类特有方法
            hp.inter();
        }
    }

① 子类覆盖父类方法是，必须保证子类方法权限大于父类。
② 子类覆盖父类方法要保证，权限、返回值、方法名、参数列表一模一样。
③ 类的继承只支持单继承，不支持多继承
④ 所有类的父类都是 Object

① super 
    代表父类
② this  
    代表当前类

① super
    * 在子类中调用父类成员变量
        super.成员变量。
    * 在子类用调用父类成员方法
        super.成员方法名()。
    * 在子类构造方法中调用父类构造方法
        super( 参数列表 );
② this
    * 调用本类成员变量
        this.成员变量
    * 调用本类成员方法
        this.成员方法()；
    * 在构造方法中调用本类构造方法
        this.类名( 参数列表 );
③ 示例
    //父类，手机类
    public class Phone {
        //成员变量
        private String brand;

        //构造方法
        public Phone() {
        }
 
        public Phone(String brand, String price) {
            this.brand = brand;
        }
 
        //成员方法
        public void call() {
            System.out.println( brand + "? 打电话！");
        }
 
    }
 
    //子类，联想手机类
    public class LenovoPhone extends Phone{
        //子类空参构造调用父类有参构造
        public LenovoPhone() {
            super("Lenovo Z90");
        }
    }
 
    //子类，华为手机列类
    public class HonorPhone extends Phone{
        //本类空参构造调用本类有参构造
        public HonorPhone() {
            this("Lenovo P30 pro","9999");
        }
 
        //子类有参构造调用父类有参构造
        public HonorPhone(String brand, String price) {
            super(brand, price);
        }
    }

① 抽象方法
    * 使用 abstract 修饰的没有方法体的方法称为抽象方法。
② 抽象类
    * 包含抽象方法的类称为抽象类。

① 格式
    * 修饰符 class abstract 类名 {
        修饰符 abstract 返回值类型 方法名(); 
      }
        例：public class abstract AbrtractDemo{
                public atstract void method();
           }
② 注意
    * 抽象类不能创建对象。
    * 抽象类中可以有构造方法，是提供给子类创建对象时初始化父类成员变量使用。
    * 子类需重写父类所有的抽象方法，除非子类也是抽象类。
    * 抽象方法一定要在抽象类中，抽象类不一定要有抽象方法。
    * 最终必须有子类是实现父类所有的抽象方法。
③ 示例
    //父类，抽象类
    public abstract class Fu {
        public abstract void num();
    }

    //子类，实现父类
    public class Zi extends Fu{
        public void num() {
            System.out.println("子类");
        }
 
    }