抽象类，多态，类型转换

1.抽象类

当一个类的方法过于抽象，无法确定如何实现时，声明这个类后，方法体为空。这样的方法称为抽象方法，用abstract修饰。当一个类有抽象方法时，该类必须被声明为抽象类。

public abstract class 类名{
}

1.1抽象类的特性

（1）抽象类不能实例化

（2）如果一个方法过于抽象无法被实现，需要将该方法声明为抽象方法，形式如下。

public abstract void 方法名();

(3)子类继承抽象类，子类继承到的抽象方法，一定要根据相应情况重写(override),除非该子类也是抽象类。

1.2重写和实现

方法重写(override)：当子类继承父类的方法不能满足自身的需要时，子类重写父类的重名方法。

实现(implement)：当子类继承抽象类时，子类必须重写父类的抽象方法，子类对抽象父类的抽象方法的重写称之为实现，实现其实是一种特殊的方法重写。

2.多态

 程序中的多态：同一引用类型，使用不同的实例而执行结果不同称为多态。

同：同一个类型，一般指父类。

不同：不同的子类实例/同一方法执行的结果的类型不同

2.1实现多态的步骤

【1】编写父类

【2】编写子类，子类要重写/实现父类的方法

【3】运行时，父类类型   引用  子类对象(Pet pet = new Dog())

2.2 多态的实现形式

【1】父类类型 引用 子类对象

// 多态
// 同一引用类型
Pet pet = null;
// 父类引用 引用 子类对象
pet = new Dog("二狗",100,0,"土狗");
// 呈现多态
pet.eat();

【2】父类作为方法的参数列表实现多态

public void feed(Pet pet) {
        System.out.println(this.getName() + "正在喂" + pet.getName());
        pet.eat();
    }

【3】父类作为返回值实现多态

    public Pet adoptPet(int type) {
        Pet pet = null;
        if(1 == type) {
            pet = new Dog();
        }else if(2 == type) {
            pet = new Penguin();
        }else if(3 == type){
            pet = new Cat();
        }
        return pet;
    }

3 类型转换(引用数据类型)

多态中，类型转换有两种，自动类型转换和强制类型转换

1.自动类型转换，也称为向上类型转换。子类可以自动转换为父类

Pet pet = null;
pet = new Dog();

2.强制类型转换，也称为向下类型转换。父类可以通过强制类型转换为子类

子类类型 引用 = (子类)父类对象

3.1 instanceof关键字

obj instanceOf 类/接口 判断obj是否是类/接口的实例

public class TestInstanceOf {
    public static void main(String[] args) {
        Dog dog = new Dog();
        System.out.println(dog instanceof Dog); //true
        System.out.println(dog instanceof Pet); //true
        System.out.println(dog instanceof Object); //true
    }
}

当父类要调用子类特有的方法时，一定要用强制类型转换，通过instanceof鉴别具体类型

public void play(Pet pet) {
        if(pet instanceof Dog) {
            Dog dog = (Dog) pet;
            dog.catchFlyDisc();
        }else if(pet instanceof Penguin) {
            Penguin penguin = (Penguin) pet;
            penguin.swimming();
        }
    }