22.【多态】

最新推荐文章于 2024-02-04 16:01:51 发布

LiuszZZ

最新推荐文章于 2024-02-04 16:01:51 发布

阅读量137

点赞数

分类专栏： # Dark horse 文章标签： java

原文链接：http://www.itheima.com/

版权

Dark horse 专栏收录该内容

89 篇文章 0 订阅

订阅专栏

概念

多态是继封装、继承之后，面向对象的第三大特性。

生活中，比如跑的动作，小狗、小猫、大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出不同的形态。多态，描述的就是这样的状态。

多态：是指同一行为，具有多个不同的表现形式。

在这里插入图片描述

多态的前提

继承或者实现【二选一】
方法的重写【意义体现：不重写，无意义】
父类引用指向子类对象【格式体现】

多态的体现

代码当中体现多态性，其实就是一句话，父类引用指向子类对象。

格式

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

父类名称 对象名 = new 子类名称();
   
接口名称 对象名 = new 实现类名称();

代码如下:

Fu fu = new Zi();

使用

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；

如果有，执行的是子类重写后方法，若没重写，执行父类方法。

代码如下:

public class Fu {

    public void method() {
        System.out.println("父类方法");
    }

    public void methodFu() {
        System.out.println("父类特有方法");
    }
}

public class Zi extends Fu{

    @Override
    public void method() {
        System.out.println("子类重写了父类方法");
    }
}

定义测试类：

public class Demo01Multi {

    public static void main(String[] args) {
        // 使用多态的写法
        // 左侧父类的引用，指向了右侧子类的对象
        Fu obj = new Zi();  // new Zi(); new谁运行谁

        obj.method();  // 运行看右边
        obj.methodFu();  // 没有向上找(子类就是一个父类，如：猫就是动物)
    }
}

结果：

子类重写了父类方法
父类特有方法

多态的优点

实际开发过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利，

多态的好处：可以使程序编写的更简单，并具有良好的扩展。

在这里插入图片描述

定义父类：

public abstract class Animal {
	public abstract void eat();
}

定义子类；

class Cat extends Animal {    
    
    @Override
	public void eat() {
		System.out.println("吃鱼");
	}
}

class Dog extends Animal {   
    
    @Override
	public void eat() {
		System.out.println("吃骨头");
	}
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 多态形式，创建对象
        Cat c = new Cat();
        Dog d = new Dog();

        // 调用showCatEat
        showCatEat(c);
        // 调用showDogEat
        showDogEat(d);
        System.out.println("===========");

		/*
			以上两个方法，均可以被showAnimalEat(Animal a)方法所替代
		*/
        showAnimalEat(c);
        showAnimalEat(d);
    }

    private static void showCatEat(Cat c) {
        c.eat();
    }

    private static void showDogEat(Dog d) {
        d.eat();
    }

    private static void showAnimalEat(Animal a) {
        a.eat();
    }

}

结果：

吃鱼
吃骨头
===========
吃鱼
吃骨头

引用类型转换

多态的转型分为向上转型与向下转型两种：

向上转型

向上转型：多态的本身是子类类型向父类类型向上转化的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型 变量名 = new 子类对象;
如：Animal a = new Cat();

向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转换为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名;
如：Cat c = (Cat) a;

注意

向下转型的前提是父类对象指向的是子类对象

也就是说，在向下转型之前，它得先向上转型
向下转型只能转型为本类对象

猫是不能变成狗的

在这里插入图片描述

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点”小麻烦”。所以，想要调用子类特有的方法，必须做向下转型。

注意

向上转型一定是安全的，但是也有一个弊端。对象一旦向上转型为父类，那么久无法调用子类原本特有的内容。

解决方案：用对象的向下转型【还原】。
格式：

含义：将父类对象，【还原】成为本来的子类对象。

子类名称 对象名 = (子类名称) 父类对象;

代码演示：

Animal

public abstract class Animal {

    public abstract void eat();

}

public class Cat extends Animal {

    public void eat() {
        System.out.println("猫吃鱼");
    }

    public void catchMouse() {
        System.out.println("猫捉老鼠");
    }

}

public class Dog extends Animal {

    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void watchHouse() {
        System.out.println("狗看家");
    }

}

定义测试类：


public class Demo01Main {

    public static void main(String[] args) {
		// 向上转型
        Animal animal = new Cat();  
        animal.eat();  

//		animal.catchMouse();  // 错误写法！(不是所有动物都会抓老鼠)

        // 向下转型，进行“还原”动作(本来就是，才能转型)
        Cat cat = (Cat) animal;

        cat.catchMouse();  

        /*
            下面是错误的向下转型
            本来new的时候是猫，现在非要当成成狗
            错误写法，编译不会报错
            但运行会发生类转换异常:java.lang.ClassCastException
         */
        Dog dog = (Dog) animal;
    }
}

结果：

猫吃鱼
猫捉老鼠
Exception in thread "main" java.lang.ClassCastException: cn.luis.demo6.Cat cannot be cast to cn.luis.demo6.Dog
	at cn.luis.demo6.Demo01Main.main(Demo01Main.java:31)

转型的异常

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

public class Demo01Main {

    public static void main(String[] args) {
		// 向上转型
        Animal animal = new Cat();  
        animal.eat();   

        /*
            下面是错误的向下转型
            本来new的时候是猫，现在非要当成成狗
            错误写法，编译不会报错
            但运行会发生类转换异常:java.lang.ClassCastException
         */
        // 向下转型
        Dog dog = (Dog) animal;
    }
}

这段代码可以通过编译，但是运行时，却报出了ClasscastException，类型转换异常！

这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。

`instanceof`

为了避免ClassCastException的发生，Java提供了instanceof关键字，给引用变量做类型的校验

格式如下：

  变量名 instanceof 数据类型(类名称)

演示：

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

  animal instanceof Dog

所以，转换前，我们最好先做一个判断，代码如下：

public class Demo03InstanceofPro {

    public static void main(String[] args) {
       Animal animal = new Dog();
        giveMeAPet(animal);  // 给女朋友一只狗狗
//      giveMeAPet(new Dog());  // 【两种写法一样】
    }

    // 给女朋友宠物的方法
    public static void giveMeAPet(Animal animal) {
        // 如果希望调用子类特有方法，需要向下转型
        // 判断一下父类引用animal本来是不是Cat
        if(animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.eat();
            cat.catchMouse();
        }

        if(animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.eat();
            dog.watchHouse();
        }
    }
}

结果：

狗吃骨头
狗看家

END

LiuszZZ

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
22.【多态】

概念多态是继封装、继承之后，面向对象的第三大特性。生活中，比如跑的动作，小狗、小猫、大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出不同的形态。多态，描述的就是这样的状态。多态：是指同一行为，具有多个不同的表现形式。多态的前提继承或者实现【二选一】方法的重写【意义体现：不重写，无意义】父类引用指向子...
复制链接

扫一扫