java 多态

面向对象三大特性：封装、继承、多态，今天我们来讲解多态

定义:同类型的对象表现出不同的形态

        这听起来有点抽象，我们举个具体的例子：

        假设你开了一家宠物店，提供宠物寄养的服务，于是你规定可以给寄养所有的波斯猫，附近的居民都把宠物寄养在这里：

//参数是哈士奇类型，执行功能是寄养
public void foster(波斯猫 a);

        但是，这样会出现一个问题，不同居民可能会带不同的种类的猫还有的宠物过来寄养，可是你的寄养服务只提供给波斯猫，这样你就失去了很多顾客，而你的规则就是就是你编写的代码，传递类型不对就代表编译失败。于是你就改变了规则，但凡是宠物都可以放到这里寄养。由于品种太多了，于是你定义了很多方法：

//方法重载
public void foster(哈士奇 a);
public void foster(波斯猫 a);
public void foster(金毛 a);

虽然问题得到了解决，但是实在是太麻烦了，需要定义太多的规则，太过冗余。于是重新定义了规则只要是宠物过来都可以被寄养：

//参数这次是宠物,执行寄养功能
public void foster(Animal a)

foster(波斯猫的对象);
foster(金毛的对象);
foster(哈士奇的对象);
foster(藏獒的对象);

这样的话，别人不管带某种宠物过来，都可以被寄养，你不仅轻松了，而且盈利也增加了。

        这就是多态的体现，你只定义了一个方法和参数类型，但是传进来的参数却各种形态都有，这样就会很方便了。我们从这个例子总结多态的必要条件:

第一:有继承或者实现关系

第二:有父类引用指向子类对象[这里不能随便传参，参数类型是父类,传递进来的参数必须是Animal的子类才行]

第三:有方法的重写[从上面可以看出，方法必须要进行重写]

到这里，多态的定义我们就理解了。接下来讲一下向上转型和向下转型.

从上面的例子其实很好理解向上转型:

定义:多态本身就是向上转型过的过程

使用格式：父类类型 变量名=new 子类类型();

例子:

public class Demo{
    public static void main(String[] args) {
        Animal p=new Dog();//向上转型
        p.foster();//结果:小狗被寄养
    }
}
class Animal{
    public void foster(){
        System.out.println("动物寄养");
    }
}
class Dog extends Animal{
    @Override
    public void foster(){
        System.out.println("小狗被寄养");
    }
}
class Cat extends Animal{
    @Override
    public void foster(){
        System.out.println("小猫被寄养");
    }
}

Aniaml p=new Dog();//这里就是向上转型 ，父类引用指向子类对象，日常开发中，会大量使用向上转型，这样才能更好的发挥多态的特性。

以下情况默认发生向下转型:

foster(new Dog());

向下转型:

使用格式：子类类型 变量名=（子类类型） 父类类型的变量；

还是举个例子来进行理解：

        假如你的宠物店还能够提供吃饭的服务，这就比较麻烦了，吃饭前有各种习惯，比如必须听一首歌,而猫吃饭前必须先拍拍肚子等等。

你现在正如下面程序所描述的，调用都是吃饭这个方法，不管什么宠物进来都会是进行吃饭，打印的都是一句话。这就很尴尬了。

public void eat(Animal a){
    System.out.println("宠物吃饭了");
}

所以要解决这个问题，就要体现每个宠物自身的特性。

instanceof关键字:作用：用来判断某个对象是否属于某种数据类型

来看一段程序:[简单理解下]

public void eat(Animal a){
    if(a instanceof Dog){
        Dog dog=new Dog();
        dog.other1();//比如小狗要做动作1才吃饭
    }
    if(a instanceof Cat){
        Cat cat=new Cat();
        cat.other2();//比如小狗要做动作2才吃饭
    }
}

 我们可以看出，不同类型的宠物吃饭之前都要进行独有的行为，传递的类型不同，调用独有的习惯行为也不同。继承之前我们学过：

私有的方法不会被继承，虚方法会被继承，所以这里我们要进行强转操作。当然从代码可以看出每次调用都要先判断再强转，会有一点稍微的麻烦。所以java JDK14以后有一种新特性[判断强转合在一起了]:

public void eat(Animal a){
    if(a instanceof Dog){
        dog.other1();//比如小狗要做动作1才吃饭
    }
    if(a instanceof Cat){
        cat.other2();//比如小狗要做动作2才吃饭
    }
}

 多态调用的特点： 

     1.多态成员变量：编译运行看左边
         Animal a=new Cat();

         System.out.println(a.name);//a是Animal中的值，只能取到父中的值

     2.多态成员方法：编译看左边，运行看右边

        Animal a1=new Dog();

        System.out.println(a1.show());//a1的表面类型是Aniaml,实际类型是Dog,所以调用的是重写后的方法。

最后我们来做一下总结：

1.多态优势:

        方法中。使用父类类型作为参数，可以接收所有子类对象

2.多态弊端:

        不能使用子类特有功能

3. 引用数据类型转换方式:

        自动类型转换、强制类型转换

4.强制类型转换解决的问题?

        .可以转换成真正的子类，从而调用子类独有功能

        .转换类型与对象类型不一致，比如创建狗的对象，转换成猫的类型，就会报错

        .转换时用Instanceof关键字先进行判断