一篇文章带你了解Java基础-多态

Java基础知识(多态)

多态

多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

多态的定义和存在的必要条件

多态的定义：

多态是指同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作。

就举动物类的例子吧，cat和dog都是属于动物这一类，而动物呢，都有一个共同的行为就是吃吧，而不同的动物所吃的食物都大不相同吧！

猫呢，它喜欢吃鱼！

而对于狗呢，它就比较喜欢啃骨头！

所以多态就是对于吃这一行为来说，每种动物对吃这一行为所表现的行为都不尽相同。

多态存在的三个必要条件

1.继承或者实现

在多态中必须存在有继承或者实现关系的子类和父类。

2.方法的重写

子类对父类中某些方法进行重新定义（重写），在调用这些方法时就会调用子类的方法。

3.基类引用指向派生类对象，即父类引用指向子类对象

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

多态的格式：

父类类型 变量名 = new 子类类型();
变量名.方法名();

多态格式可以充分体现了同一个接口，使用不同的实例而执行不同操作。

接下来我们具体来进行案例体会体会吧！

多态的案例

多态我们首先要知道的一点：

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。如果子类没有重写该方法，就会调用父类的该方法。

总结起来就是：编译看左边，运行看右边。

首先我们先定义一个父类动物类，动物有吃的行为！

接着定义一个猫类和狗类去继承动物类，重写里面的吃行为！

具体代码如下：

定义动物父类：

package com.nz.pojo;
/**
 * 先定义一个父类 --> 动物类
 * 动物都有一个吃的行为属性
 */
public class Animal {
    public void eat() {
        System.out.println("动物它们都会吃东西！！！");
    }
}

定义猫咪子类：

package com.nz.pojo;
/**
 * 定义猫类继承动物类，
 * 随之重写里面的吃行为，因为猫也有吃的行为，但是猫喜欢吃罐头
 */
public class Cat extends Animal{
    public void eat() {
        System.out.println("小喵咪都喜欢吃鱼罐头！");
    }
}

定义小狗子类：

package com.nz.pojo;
/**
 * 定义狗类继承动物类，
 * 随之重写里面的吃行为，因为狗也有吃的行为，但是狗喜欢啃骨头
 */
public class Dog extends Animal{
    public void eat() {
        System.out.println("小狗狗都爱啃骨头！");
    }
}

定义测试类，测试多态的形式：

package com.nz;
import com.nz.pojo.Animal;
import com.nz.pojo.Cat;
import com.nz.pojo.Dog;
/**
 * 测试多态的形式
 */
public class Demo {
    public static void main(String[] args) {
        // 多态形式，创建猫类对象
        Animal animal = new Cat();
        // 调用的是Cat的 eat
        animal.eat();
        // 多态形式，创建狗类对象
        Animal animal2 = new Dog();
        // 调用的是Dog的eat
        animal2.eat();
    }
}

得到的结果：

小喵咪都喜欢吃鱼罐头！
小狗狗都爱啃骨头！

类的大致结构：

可以看出我们可以使用多态的属性得到不同的动物的一个吃的行为属性！

多态的好处

提高了代码的拓展性，使用父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用。

具体我们来看看吧：

继续使用上述的动物类、猫类、狗类吧。

定义测试类：

package com.nz;
import com.nz.pojo.Animal;
import com.nz.pojo.Cat;
import com.nz.pojo.Dog;
/**
 * 测试多态的好处
 */
public class Demo2 {
    public static void main(String[] args) {
        // 创建猫和狗对象
        Cat cat = new Cat();
        Dog dog = new Dog();
        // 调用catEat
        catEat(cat);
        // 调用dogEat
        dogEat(dog);
		/*
        多态的好处:
            以上各个动物的吃的方法, 我们都可以使用animalEat(Animal a)方法来代替。
            并且执行效果都一样, 所以我们可以使用animalEat直接替代了不同动物的吃方法。
        */
        animalEat(cat);
        animalEat(dog);
    }
    /*
        定义几个不同吃的方法，看看具体调用后的结果是什么吧！
     */
    public static void catEat (Cat cat){
        cat.eat();
    }
    public static void dogEat (Dog dog){
        dog.eat();
    }
    public static void animalEat (Animal animal){
        animal.eat();
    }
}

执行结果：

小喵咪都喜欢吃鱼罐头！
小狗狗都爱啃骨头！
小喵咪都喜欢吃鱼罐头！
小狗狗都爱啃骨头！

可以看出，由于多态的特性，我们的animalEat()方法传入的Animal类型参数，并且它是我们的Cat和Dog的父类类型，父类类型接收子类对象，所以我们可以将Cat对象和Dog对象，传递给animalEat()方法。

所以我们可以完全使用animalEat()方法来替代catEat()方法和dogEat()方法，达到同样的效果！以至于我们可以不必再单独写xxxEat()方法来传入指定的动物参数了，从而实现了实现类的自动切换。

所以多态的好处体现在：可以使我们的程序编写的更简单，并有良好的扩展性。

多态的弊端

从上面的多态的好处，可以看到我们可以使用父类的参数代替了某个子类的参数，从而达到程序的扩展！

但是对于某个子类有些独有的功能方法时，此时我们的多态的写法就无法访问子类独有功能了。

具体来瞧瞧？

代码如下：

重新定义下猫的子类：

package com.nz.pojo;
/**
 * 定义猫类继承动物类，
 * 随之重写里面的吃行为，因为猫也有吃的行为，但是猫喜欢吃罐头
 */
public class Cat extends Animal{
    public void eat() {
        System.out.println("小喵咪都喜欢吃鱼罐头！");
    }
    /**
     * 增加一哥猫咪特有的玩球方法（）
     */
    public void playBall() {
        System.out.println("小喵咪都喜欢小球！");
    }
}

定义测试类：

package com.nz;
import com.nz.pojo.Animal;
import com.nz.pojo.Cat;
/**
 * 测试多态的弊端！
 */
public class Demo3 {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();
        animal.playBall();//编译报错，编译看左边，Animal没有这个方法
    }
}

可以看到动物类和猫类有个共同的eat吃方法，但是呢，猫咪多了个玩球球的方法。而对于动物对象来说，它本身动物类没有玩球球的方法，所以它的编译就直接没有通过了！

那有什么方法解决呢？且看下一章节吧！

引用类型转换

1. 引用类型转换是什么，为什么需要它？

从上面的多态的弊端的案例中，我们可以看到，我们使用动物对象时无法直接访问到猫类中的玩球球方法，这也就是我们之前说的编译看左边，运行看右边。

而在我们使用多态方式调用方法时，首先检查会左边的父类中是否有该方法，如果没有，则编译错误。也就代表着，父类无法调用子类独有的方法。、

所以说，如果编译都错误，更别说运行了。这也是多态给我们带来的一点小困扰，而我们如果想要调用子类特有的方法，必须做向下转型。

2. 向上转型（自动转换）

对于向下转型，我们先来讲解下向上转型的概念吧。

向上转型：

多态本身是子类向父类向上转换（自动转换）的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。

对于父类和子类的关系来说，具体来看图说话：

父类相对与子类来说是大范围的类型，Animal是动物类，是父类。而Cat是猫咪类，是子类。

所以对于父类Animal来说，它的范围是比较大的，它包含一切动物，包括猫咪类和小狗类。

所以对于子类类型这种范围小的，我们可以直接自动转型给父类类型的变量。

使用格式：

父类类型 变量名 = new 子类类型();
如：Animal animal = new Cat();
相当于有：
Animal animal = (Animal) new Cat();

相当于自动帮我们了一个隐形的转换为动物类的一个过程，因为动物本身就包含了猫咪。

3. 向下转型（强制转换）

向上转型可以知道它是子类自动转换为父类的一个过程，所以我们现在再来看看向下转型的定义：

向下转型：

向下转型就是由父类向子类向下转换的过程，这个过程是强制的。一个需要将父类对象转为子类对象，可以使用强制类型转换的格式，这便是向下转型。

为什么这种就必须自己强制加上一个类型转换过程呢？

对于父类和子类的关系来说，我们接着看图说话：

对于猫咪类的话，它在动物类中只是其中的一部分吧，而对于动物类来说，它有许多其他子类动物如狗，牛，猪等等。

所以对于动物父类想要向下转型的时候，它此时不知道指向那个子类，因为不确定呀，所以就必须自己加上强制的类型转换的一个过程。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名;
如:
Animal animal = new Cat();
Cat cat = (Cat) animal;
cat.playBall();// 此时我们就可以使用猫咪的特有方法啦

所以对于多态的弊端，无法使用子类特有的参数，我们也解决啦，可以通过向下转型的方法，从而将类型强制转换为某个子类对象后，再去调用子类的特有方法！

4. 向下转型的问题

虽然我们可以使用向下转型使得我们可以使用子类的独有方法，但是转型的过程中，一不小心就会遇到这样的问题了，来，我们来看看下面的代码：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat
        // 向下转型  
        Dog d = (Dog)a;       
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    }  
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。

5. 转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

定义狗类中额外的独有遛狗方法：

package com.nz.pojo;
/**
 * 定义狗类继承动物类，
 * 随之重写里面的吃行为，因为狗也有吃的行为，但是狗喜欢啃骨头
 */
public class Dog extends Animal{
    public void eat() {
        System.out.println("小狗狗都爱啃骨头！");
    }
    public void walk() {
        System.out.println("小狗在被我溜着！");
    }
}

定义测试类

package com.nz;
import com.nz.pojo.Animal;
import com.nz.pojo.Cat;
import com.nz.pojo.Dog;
/**
 * 测试多态的向下转型的问题
 */
public class Demo4 {
    public static void main(String[] args) {
        // 向上转型的过程
        Animal animal = new Cat();
        // 调用了猫咪的吃方法
        animal.eat();
        // 向下转型
        Dog dog = (Dog) animal;
        dog.walk(); // 调用的是 Dog 的 walk 可以通过，但是会运行报错
    }
}

得到结果：

小喵咪都喜欢吃鱼罐头！
Exception in thread "main" java.lang.ClassCastException: com.nz.pojo.Cat cannot be cast to com.nz.pojo.Dog
at com.nz.Demo4.main(Demo4.java:20)

我们可以看到，虽然我们的代码通过编译，但是终究在运行时，还是出错了，抛出了 ClassCastException 类型转换的异常。

其实我们可以知道，我们在上面的时候，创建了Cat类型对象，而在向下转型时，将其强行转换为了Dog类型，所以程序在运行时，就会抛出类型转换的异常！

那我们如何可以避免这种异常发生呢？且看下一节分析！

6. instanceof关键字

Java为我们提供一个关键字instanceof ，它可以帮助我们避免了ClassCastException 类型转换异常的发生。

那如何做呢？

格式：

变量名 instanceof 数据类型

解释：

如果变量属于该数据类型或者其子类类型，返回true。
如果变量不属于该数据类型或者其子类类型，返回false。

代码实现：

package com.nz;
import com.nz.pojo.Animal;
import com.nz.pojo.Cat;
import com.nz.pojo.Dog;
/**
 * 使用instanceof解决类型转换异常！
 */
public class Demo5 {
    public static void main(String[] args) {
        // 向上转型的过程
        Animal animal = new Cat();
        // 调用了猫咪的吃方法
        animal.eat();
        // 向下转型
        if (animal instanceof Cat){
            Cat cat = (Cat) animal;
            cat.playBall();        // 调用的是 Cat 的 playBall
        } else if (animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.walk();       // 调用的是 Dog 的 walk
        }
    }
}

结果：

小喵咪都喜欢吃鱼罐头！
小喵咪都喜欢小球！

可以发现，它可以帮助我们在做类型转换前，判断该类型是否属于该类型或者子类类型，如果是，我们就可以强转啦！

总结

相信各位看官都对Java中的特性之一多态的知识和使用有了一定了解，等待下一次更多Java基础的学习吧！

本篇文章就到这里了，希望能给你带来帮助，也希望您能够多多关注自学编程网的更多内容！

编程技巧