多态

理解

对于同一件事情，不同的人用不同的做法，例如吃饭，有的人吃大米，有的人吃面条。多态是对于具体的某个对象的方法而言的。不同的对象在相同的事情上表现出不同可做法。
多态只与父类的方法有关，与父类的成员变量无关
父类的引用指向子类的对象，用父类的引用调用子类重写的方法，此时多态就出现了。

条件

多态的前提是继承，方法重写，父类引用指向子类对象。

作用

1.在定义方法时，用父类做方法的形参，实参可以是任意子类的对象的引用。（多态使用最多的场合）
2.创建对象时任意子类的对象可以赋值个其父类的引用。
3.符合开闭原则。（对修改是关闭，对拓展是开放的。）

public class Programmer {
    //要继承的方法
    public void writeCode(){
        System.out.println("程序员喜欢敲代码");
    }

    //要重写的方法
    public void eat(){
        System.out.println("干饭时间");
    }
}

public class Chinese extends Programmer{
    @Override
    public void eat() {
        System.out.println("I like eating dumpling ");
    }


    //子类特有的方法

    public void playBasketball(){
        System.out.println("I can play BasketBall");
    }
}

public class English extends Programmer{
    @Override
    public void eat() {
        System.out.println("I like eating hamburger");
    }

    public void playFootball(){
        System.out.println("I like playFootBall");
    }

}

public class Test {
    public void beginEat(Programmer pro){
        pro.eat();
    }

    public static void main(String[] args) {
        Test t=new Test();
        Chinese ch=new Chinese();
        t.beginEat(ch);

//        Programmer pro2=new Programmer();
//        pro2=new English();
//        t.beginEat(pro2);
//      编译时对象   运行时对象
        Programmer pro=new English();
        t.beginEat(pro);
    }
}

注意点

Programmer pro=new English();

多态情况下，父类的引用无法调用子类特有的方法的。
可以调用子类继承的方法和，子类重写的方法。

向上转型（upcasting）

多态的实现，其实就是一种向上转型。
基本数据类型的向上转型。

//基本数据类型的向上转型
        int a=20;
        double  b=a;
        System.out.println(b);

引用类型的向上转型

 //引用数据类型的转换
        Programmer pro=new English();
        //继承的方法
        pro.eat();
        //重写的方法是调用的是子类的方法方法
        pro.writeCode();

向下转型

基本数据类型的向下转型

 //基本数据类的向下转型（强制转换）
        double n=3.14;
        int m=(int)n;

引用类型的向下转型

if(pro instanceof English){
            English en=(English)pro;
            en.playFootball();
        }else if(pro instanceof Chinese){
            Chinese ch=(Chinese) pro;
            ch.playBasketball();
        }

举例理解：

//先向上转型
Programmer pro=new English();
//此时，pro只能向下转型为English，而不能转为Chinese,pro本来是English的，不能变成Chinese的。

先向上转型，后又进行向下转型与直接进行向下转型的区别
先向上转型Programmer pro=new English();，后向下转型English en=(English)pro;，向下转型时只能转型为向上转型时的对象English。
而直接向下转型可以转型为任意的子类对象

Programmer pro1=new Programmer();
        English en=(English)pro1;
        Chinese ch=(Chinese)pro1;

只要进行了向下转型之后就可以调用子类特有方法。

所以一般可以先判断，再转型。
2.对instanceof的理解
instanceof是判断一个引用是否指向了一个类的实例对象。
看代码：

//对instanceof的理解
        System.out.println(pro instanceof Object);
        System.out.println(pro instanceof Programmer);
        System.out.println(pro instanceof English);
        System.out.println(pro instanceof Chinese);

结果：

简单工厂模式

简单工厂模式也是多态的一种应用，方法的返回值类型为父类，可以返回该父类的任意子类。
1.方法的返回值类型为父类。
2.static方法，可以有类名直接调用。
3.参数列表内为一个字符串参数，工厂根据字符串进行生产。

public class SimpleFactory {
    public static void main(String[] args) {
        Programmer pro=School.getProgrammer("Chinese");
        pro.eat();
    }
}

class School{
    public static Programmer getProgrammer(String type){
        Programmer pro=new Programmer();
        if("Chinese".equals(type)){ //不要写成type.equals("Chinese")
             pro=new Chinese();
        }else if("English".equals(type)){
            pro=new English();
        }
        return pro;
    }