多态，向上下转型

实现的多态前提

必须存在继承或者实现关系

1.父类的引用类型变量指向子类的对象
public static void main(String[] args) {
        Parent parent = new Child();
        parent.test();//输出子类test内容：Child
}

class Parent{

    public void test(){
        System.out.println("Parent");
    }
}

class Child extends Parent{

    @Override
    public void test() {
        System.out.println("Child");
    }
}

2.接口的引用类型变量指向接口实现类的对象
public static void main(String[] args) {
        IParent parent = new ChildImpl();
        parent.test();//输出子类test内容：Child
}

interface IParent{
    void test();
}

class ChildImpl implements IParent{

    @Override
    public void test() {
        System.out.println("Child");
    }
}

多态情况下要注意的细节

• 子父类中存在同名的成员变量时（包括静态变量），访问的是父类的成员变量。

• 子父类中存在非静态的同名成员函数时，访问的是 子类 的成员函数。

• 子父类中存在静态的同名成员函数时，访问的是父类的成员函数。

• 多态情况下，父类的引用类型变量不能访问子类特有的成员。

总结

多态情况下，子父类中存在同名的成员时，访问的都是父类成员，只有在调用同名非静态函数时才是访问子类的实现。

多态的原理

Java编译时看左边，运行时不一定看右边。

编译看左边：Java编译器在编译时，会检查引用类型变量所属的类是否具备指定的成员，如果不具备编译器马上报错，如果具备则通过，这就是为什么重写能实现多态，且不能访问子类特有成员。

多态的应用场景

• 多态用于形参类型的时候，可以接收更多类型的数据。
• 多态用于返回值类型的时候，可以返回更多类型的数据。

public class Main {

    public static void main(String[] args) {
        animalTest(new Wolf()).eat();
    }

    //传递类型参数
    public static Animal animalTest(Animal animal) {
        if (animal instanceof Wolf) {
            return animal;
        } else if (animal instanceof Snake) {
            return animal;
        }
        return null;
    }
}

//基类
interface Animal {
    void eat();
}

//实现类
class Wolf implements Animal {

    @Override
    public void eat() {
        System.out.println("Wolf eat meat");
    }
}

class Snake implements Animal {

    @Override
    public void eat() {
        System.out.println("Snake eat frog");
    }
}

向上下转型

• 转型的前提是必须存在继承或实现.
• 向上转型即父类引用指向子类的实现，调用的是子类的方法实现。
• 向下转型即子类引用指向已存在的向上转型的父类引用。
  注意：要想向下必须先向上。

class Pater {

    public void eat() {
        System.out.println("Pater eat meat");
    }
}

class Child extends Pater {

    @Override
    public void eat() {
        System.out.println("Child eat meat");
    }

    public void proper(){
        System.out.println("Child proper method");
    }
}

public class Main {

    public static void main(String[] args) {

        //向上转型
        Pater pater = new Child();
        pater.eat();

        //向下转型，可以调用子类特有的方法
        Child child = (Child) pater;
        child.proper();
    }
}