【Java】Java学习（十五）—— 多态

最新推荐文章于 2024-07-03 19:13:37 发布

伍陆壹柒

最新推荐文章于 2024-07-03 19:13:37 发布

阅读量169

点赞数 1

分类专栏： Java从零开始文章标签： java 多态

本文链接：https://blog.csdn.net/liuliuliu561/article/details/107943489

版权

Java从零开始专栏收录该内容

15 篇文章 1 订阅

订阅专栏

上一篇： Java学习（十四）—— 接口

第二十八部分多态

28.1 概述

定义： 同一行为，具有多个不同表现形式。
前提
- 继承或者实现【二选一】
- 方法的重写【意义体现：不重写，无意义】
- 父类引用指向子类对象【格式体现】

28.2 多态的格式与使用

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

定义父类

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();

        obj.method();	// 子类方法
        obj.methodFu();	// 父类特有方法
    }
}

28.3 多态中成员变量和成员方法的使用

成员变量： 编译看左边，运行还看左边。
成员方法： 编译看左边，运行看右边。

定义父类

public class Fu /*extends Object*/ {

    int num = 10;

    public void showNum() {
        System.out.println(num);
    }

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

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

}

定义子类

public class Zi extends Fu {

    int num = 20;

    int age = 16;

    @Override
    public void showNum() {
        System.out.println(num);
    }

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

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

定义测试类

public class DemoMultiField {

    public static void main(String[] args) {
        // 使用多态的写法，父类引用指向子类对象
        Fu obj = new Zi();
        System.out.println(obj.num); // 父：10
//        System.out.println(obj.age); // 错误写法！
        System.out.println("=============");

        // 子类没有覆盖重写，就是父：10
        // 子类如果覆盖重写，就是子：20
        obj.showNum();
      
      	obj.method(); // 父子都有，优先用子
        obj.methodFu(); // 子类没有，父类有，向上找到父类

        // 编译看左边，左边是Fu，Fu当中没有methodZi方法，所以编译报错。
//        obj.methodZi(); // 错误写法！
    }

}

28.4 多态的好处

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

28.5 引用类型转换

28.5.1 向上转型

定义： 多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。向上转型一定是安全的，正确的。但对象一旦向上转型为父类，那么就无法调用子类原本特有的内容。
格式： 父类类型变量名 = new 子类类型();

28.5.2 向下转型

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

定义： 父类类型向子类类型向下转换的过程，这个过程是强制的。一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
格式： 子类类型变量名 = (子类类型) 父类变量名;

28.5.3 例子

定义父类

public abstract class Animal {

    public abstract void eat();

}

定义子类

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

    // 子类特有方法
    public void catchMouse() {
        System.out.println("猫抓老鼠");
    }
}

定义子类

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

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

定义测试类

public class DemoMain {

    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;
    }

}

为了避免ClassCastException的发生，Java提供了instanceof关键字，给引用变量做类型的校验，格式如下：对象 instanceof 类名称。如果变量属于该数据类型，返回true。如果变量不属于该数据类型，返回false。

重新定义测试类

public class DemoInstanceof {

    public static void main(String[] args) {
        Animal animal = new Dog(); // 本来是一只狗
        animal.eat(); // 狗吃SHIT

        // 如果希望掉用子类特有方法，需要向下转型
        // 判断一下父类引用animal本来是不是Dog
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        // 判断一下animal本来是不是Cat
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }

        giveMeAPet(new Dog());
    }

    public static void giveMeAPet(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            dog.watchHouse();
        }
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }
    }

}

在这里插入图片描述

28.6 接口多态的综合案例

28.6.1 笔记本电脑

笔记本电脑（laptop）通常具备使用USB设备的功能。在生产时，笔记本都预留了可以插入USB设备的USB接口，但具体是什么USB设备，笔记本厂商并不关心，只要符合USB规格的设备都可以。定义USB接口，具备基本的开启功能和关闭功能。鼠标和键盘要想能在电脑上使用，那么鼠标和键盘也必须遵守USB规范，实现USB接口，否则鼠标和键盘的生产出来也无法使用。

28.6.2 分析

进行描述笔记本类，实现笔记本使用USB鼠标、USB键盘

USB接口，包含开启功能、关闭功能
笔记本类，包含运行功能、关机功能、使用USB设备功能
鼠标类，要实现USB接口，并具备点击的方法
键盘类，要实现USB接口，具备敲击的方法

28.6.3 实现

定义USB接口

public interface USB {

    public abstract void open(); // 打开设备

    public abstract void close(); // 关闭设备

}

定义鼠标类

// 鼠标就是一个USB设备
public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }

    @Override
    public void close() {
        System.out.println("关闭鼠标");
    }

    public void click() {
        System.out.println("鼠标点击");
    }
}

定义键盘类

// 键盘就是一个USB设备
public class Keyboard implements USB {
    @Override
    public void open() {
        System.out.println("打开键盘");
    }

    @Override
    public void close() {
        System.out.println("关闭键盘");
    }

    public void type() {
        System.out.println("键盘输入");
    }
}

定义笔记本类

public class Computer {

    public void powerOn() {
        System.out.println("笔记本电脑开机");
    }

    public void powerOff() {
        System.out.println("笔记本电脑关机");
    }

    // 使用USB设备的方法，使用接口作为方法的参数
    public void useDevice(USB usb) {
        usb.open(); // 打开设备
        if (usb instanceof Mouse) { // 一定要先判断
            Mouse mouse = (Mouse) usb; // 向下转型
            mouse.click();
        } else if (usb instanceof Keyboard) { // 先判断
            Keyboard keyboard = (Keyboard) usb; // 向下转型
            keyboard.type();
        }
        usb.close(); // 关闭设备
    }

}

定义测试类

public class DemoMain {

    public static void main(String[] args) {
        // 首先创建一个笔记本电脑
        Computer computer = new Computer();
        computer.powerOn();

        // 准备一个鼠标，供电脑使用
        // 首先进行向上转型
        USB usbMouse = new Mouse(); // 多态写法
        // 参数是USB类型，正好传递进去的就是USB鼠标
        computer.useDevice(usbMouse);

        // 创建一个USB键盘
        Keyboard keyboard = new Keyboard(); // 没有使用多态写法
        // 方法参数是USB类型，传递进去的是实现类对象
        computer.useDevice(keyboard); // 正确写法！也发生了向上转型
        // 使用子类对象，匿名对象，也可以
//        computer.useDevice(new Keyboard()); // 也是正确写法

        computer.powerOff();
        System.out.println("==================");

      	// 上面原理类似于下面的基本数据类型转换
        method(10.0); // 正确写法，double --> double
        method(20); // 正确写法，int --> double
        int a = 30;
        method(a); // 正确写法，int --> double
    }

    public static void method(double num) {
        System.out.println(num);
    }

}

上一篇： Java学习（十四）—— 接口

伍陆壹柒

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Java】Java学习（十五）—— 多态

上一篇： Java学习（十四）—— 接口第二十八部分多态28.1 概述定义：同一行为，具有多个不同表现形式。前提继承或者实现【二选一】方法的重写【意义体现：不重写，无意义】父类引用指向子类对象【格式体现】28.2 多态的格式与使用格式父类名称对象名 = new 子类名称();接口名称对象名 = new 实现类名称();定义父类public class Fu { public void method() { System.o.
复制链接

扫一扫