继承，抽象

目录

 格式

 在子类的【成员方法】中访问变量规则

访问父子类同名的成员方法【使用子类对象调用方法时】

总结 this super 

重写 

 构造方法特点

 抽象方法，抽象类

多重抽象类

---

 格式

定义父类的格式：（一个普通的类定义）
public class 父类名称 {
    // ...
}

定义子类的格式：
public class 子类名称 extends 父类名称 {
    // ...
}

 

 

---

在父子类的继承关系当中，如果【成员变量】重名，则创建子类对象时，访问有两种方式：

 
1.直接【通过子类对象访问】成员变量： 等号左边是谁，就优先用谁，【没有则向上找】。

2.间接【通过成员方法访问】成员变量： 该【方法属于】谁【属于哪个类（父类或子类）】，就优先用谁，没有则向上找。 

 在子类的【成员方法】中访问变量规则

局部变量：         直接写成员变量名
本类的成员变量：    this.成员变量名
父类的成员变量：    super.成员变量名

public class Fu {

    int num = 10;

}

public class Zi extends Fu {

    int num = 20;

    public void method() {
        int num = 30;
        System.out.println(num); // 30，局部变量
        System.out.println(this.num); // 20，本类的成员变量
        //通过zi调用的成员方法，zi就是this
        //在主函数中等价于使用zi.num值为20

        System.out.println(super.num); // 10，父类的成员变量
        System.out.println(this);

    }

}

访问父子类同名的成员方法【使用子类对象调用方法时】

创建的对象是谁，就优先用谁，如果没有则向上找。
Zi zi = new Zi();右边new的是Zi，创建的是子类对象，优先用子类方法

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

总结 this super 

super关键字的用法有三种：
1. 在子类的成员方法中，访问父类的成员变量。Super.num
2. 在子类的成员方法中，访问父类的成员方法。Super.method();
3. 在子类的构造方法中，访问父类的构造方法。Super（）；

This：
1. 在本类的成员方法中，访问本类的成员变量。This.num
2. 在本类的成员方法中，访问本类的另一个成员方法。This.method()
3. 在本类的构造方法中，访问本类的另一个构造方法。This(123)

重写 

重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样。

重写（Override）：方法的名称一样，参数列表【也一样】。覆盖、覆写。
重载（Overload）：方法的名称一样，参数列表【不一样】。

方法的覆盖重写特点：【创建】的是【子类对象】，则优先用子类方法。
                    【创建】的是【父类对象】，则使用父类方法

方法覆盖重写的注意事项：

1. 必须保证父子类之间方法的名称相同，参数列表也相同。
@Override：写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2. 子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

3. 子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空。

---

 构造方法特点

继承关系中，父子类构造方法的访问特点：

1. 子类构造方法当中有一个默认隐含的“super()”调用，所以【一定是先调用的父类构造】（父类构造方法必会被调用），后执行的子类构造。
2. 子类构造可以通过super关键字来调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。【只能用一个，且必须是子类构造方法的第一句】
总结：
子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。

public class Fu {

    public Fu() {
        System.out.println("父类无参构造");
    }
    public Fu(int num) {
        System.out.println("父类有参构造！");
    }
}

public class Zi extends Fu {

    public Zi() {
        //super(); // 在调用父类无参构造方法  如果没主动书写，则默认有一个

        //super(20); // 主动调用父类重载的构造方法
        //↑子类构造通过super调用父类重载构造


        System.out.println("子类构造方法！");

    }

    public void method() {
        // super(); // 错误写法！只有子类构造方法，才能调用父类构造方法。
    }

}

---

super关键字的用法有三种：
1. 在子类的成员方法中，访问父类的成员变量。
2. 在子类的成员方法中，访问父类的成员方法。
3. 在子类的构造方法中，访问父类的构造方法。

this关键字用法三种：

1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问本类的另一个构造方法。
在第三种用法当中要注意：
A. this(...)调用也必须是构造方法的第一个语句，唯一一个。
B. super和this两种构造调用，不能同时使用。用了super不能用this，不在赠送。相反~~~

 抽象方法，抽象类

/*
抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束。
抽象类：抽象方法所在的类，必须是抽象类才行。在class之前写上abstract即可。

如何使用抽象类和抽象方法：
1. 不能直接创建new抽象类对象。
2. 必须用一个子类来继承抽象父类。
3. 子类必须覆盖重写抽象父类当中所有的抽象方法。否则也是一个抽象类
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4. 创建子类对象进行使用。

一个抽象类不一定含有抽象方法，
只要保证抽象方法所在的类是抽象类，即可。

这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用途。

抽象类也是一个类，也存在构造方法 。如图：↓

 */
public abstract class Animal {
    public Animal() {
        System.out.println("121");
    }

    // 这是一个抽象方法，代表吃东西，但是具体吃什么（大括号的内容）不确定。
    public abstract void eat();

    // 这是普通的成员方法
   public void normalMethod() {
    }

}

抽象类中也可以有普通的成员方法

抽象类中也可以有静态方法

多重抽象类

public abstract class Animal {

    public abstract void eat();

    public abstract void sleep();
    public static void meh(){
        System.out.println("233");
    }
}

// 子类也是一个抽象类
public abstract class Dog extends Animal {

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    // public abstract void sleep();

    //此类还有一个继承了Animal类下的一个abstract sleep的抽象类，并未对其实体化

    //此类实质是除了一个已经重写实体化了一个eat类之外还有一个抽象类sleep，本质也属于一个抽象类
}