继承与多态

定义子类

---

关键字extends表明正在构造的新类派生于一个已存在的类，这个已经存在的类被称为超类，基类，或父类；新类称为子类、派生类或孩子类。

例如：People类的子类Student类

package Demo02;
 
public class People {
    private String name;
    private int age;
​
    public People() {
    }
​
    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }
​
    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;
    }
}
class Student extends People{
    private String name;
    private String address;
​
    public Student(String name, String address) {
        this.name = name;
        this.address = address;
    }
​
    @Override
    public String getName() {
        return name;
    }
​
    @Override
    public void setName(String name) {
        this.name = name;
    }
​
    public String getAddress() {
        return address;
    }
​
    public void setAddress(String address) {
        this.address = address;
    }
​
    public Student() {
    }
}
​

注意：私有字段不能够被继承，但是可以通过特有的方法来修改字段。

---

super 和 this关键字

super关键字的三种用法：

1. 在子类的成员方法中，可以访问父类的成员变量（super.变量）

2. 在子类的成员方法中，可以访问父类的成员方法（super.方法）

3. 在子类的构造方法中，可以访问父类的 构造方法。

注意：super不是一个对象的引用，不能将值super赋给另一个对象变量，它只是一个只是编译器调用超类方法的特殊关键字。

this关键字的三种用法：

1. 在本类的成员方法中，访问本类的成员变量。

2. 在本类的成员方法中，访问本类的另一个成员方法。

3. 在本类的构造方法中，访问本类的另一个构造方法。

使用第3种方法时需要注意：

A.this（）调用也必须是构造方法的第一个语句，唯一一个。

B.this和super两种构造调用不能同时调用。

---

子类构造器

---

如果子类没有显式的调用父类的构造器，将自动的调用父类的无参构造器，如果超类没有无参构造器，并且在子类的构造器中又没有显示的调用父类中的其他构造器，java编译器就会报告一个错误.

package Demo02;
​
import java.time.Period;
​
public class People {
    private String name;
    private int age;
    
    public People(String name,int age){
        this.name = name;
        this.age = age;
    }
//    public People(){}
}
​
class Student extends People{
    String address;
    
    //此时会报错，因为子类构造器会自动调用父类中的无参构造器，因为父类中没有无参构造器，所以报错
//    public Student(String address){
//        this.address = address;
//    }
    
    //此时就不会报错
    public Student(String name,int age,String address){
        super(name,age);
        this.address = address;
    }
}

多态

---

父类引用指向子类对象。

成员方法：编译看左边，运行看右边

成员变量：编译看左边，运行看左边

成员方法的访问方式：看new的是谁，就优先用哪个类中的方法，没有则向上找。

例如

Fu

public void method1(){------}

public void methodFu(){------}

Zi extends Fu

public void method1(){------}

public void methodZi(){------}

main()

Fu obj = new Zi();

obj.method1()// 编译看左，即父类有这个method1方法，但运行时看右边，也就是子类，所以运行的是子类中的method1方法（如果子类中没有该方法则向上找）

obj.methodFu()//父类中有该方法，运行看的子类中的方法，但子类中没有这个方法，，所以会向上找，运行的是父类中的methodOf（）

obj.methodZi()//编译看左边，但是父类中没有这个方法，所以会报错。

总结：父子类都有相同的方法时，用的是子类中的。子有，父没有，调用时就会报错。，父类有，则会调用父类中的。

---

对象转型

Animaleat();

//抽象

cat

eat();//抽象

对象 instanceof 类型，返回 boolean 结果，也就是判断前面的对象能不能当做类后面的实例。当需要向下转型的时候，可以先判断再转换。

• 向上转型

对象的向上转型，就是父类引用指向类对象，其实就是多态写法。

弊端：对象一旦向上转型为父类，那么就无法调用子类原本内容。

格式：父类名称 对象名 = new 子类名称（）；

含义：右侧创建一个子类对象，把他当做父类来看待使用。

例如：

Animal animal = new Cat();

创建了一只猫，当做动物看待。

注意事项：向上转型一定是安全的，因为是从小范围转向了大范围。

类似于：

double num = 100;//int --> double 是自动类型转换。

• 向下转型

对象的向下转型，其实是一个【还原】的动作。

格式：子类名称 对象名 = （子类名称） 父类对象。

含义：将父类对象，【还原】成为本来的子类对象。

例如：

Animal animal = new Cat();//本来是猫，向上转型成为了动物。

Cat cat = (Cat) animal;//本来是猫，被当作动物了，还原成为本来的猫。

注意事项：

1. 必须保证对象本来创建的时候，就是猫，才能向下转型成为猫。

2. 如果对象创建的时候本来不是猫，却非要向下转型成为猫，系统就会报错[ClassCastException]。