Java多态的总结以及相关的练习

ヾ草木萤火(≧▽≦*)o

已于 2023-05-25 14:58:57 修改

阅读量809

点赞数

分类专栏： Java随笔文章标签： java jvm 开发语言

于 2023-05-22 19:52:25 首次发布

本文链接：https://blog.youkuaiyun.com/qq_59335499/article/details/130813133

版权

Java随笔专栏收录该内容

17 篇文章

订阅专栏

01. 多态的概述
什么是多态?

一个对象，在不同的时刻有着不同的形态，

举个例子：

设定一个抽象的people为父类，Teacher，worker，student都继承people，即为people的子类。

people（人类）在学校里为身份为student（学生）或者Teacher（教师），在工地上身份可以

是worker（工人），而学生、教师、工人等这些人归根结底都是人类，即学生、教师、工人不同的状态可以理解为people的多态，而每个不同的子类所特有的成员方法就是多态的表现。这就是多态。

02. 多态的格式与使用
多态的前提是?

   总结:
       1.多态使用的前提
           必须是有继承或者是接口实现类才有多态
           必须有重写方法[不一定]
           父类指向子类对象的引用
           父对象名 = new Zi();

       2.多态的格式?
           普通类的多态
   父类对象名 = new 子类();
   抽象类的多态
   抽象类对象名 = new 抽象类的子类();
   接口类的多态
       接口名对象名 = new 接口实现类对象();

03. 多态中成员方法的使用特点

多态中成员方法的访问提点?

总结:

=左边是谁，用的就是谁。如果子类重写了父类中的方法，在执行的时候，执行的是子类的

口诀:
编译看左边【父类/接口】，运行看右边【子类/实现类】

04. 使用多态的好处和弊端
无论右边new的是那个子类对象, 左边都不会发生变化

   总结:
       * 使用多态有什么好处?
           提高代码的扩展性，左边的类型始终都不变，变的是具体创建子类对象
       * 使用多态有什么弊端?
           使用不了子类特有的成员

05. 对象的向上转型

什么是多态的向上转型?

例：

Animal animal=new Dog（）；

父类（动物类）指向子类（狗类）

可以理解为狗是动物，我们以动物来代称狗

总结:

格式：
父类类型对象名 = new 子类();

安全问题:
没有安全问题，放心大胆使用！！！！

06. 对象的向下转型
为什么要向下转型?

//抽象的动物类
public abstract class Animal {
    public abstract void eat();

}
//继承动物类的狗类

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

    }
//狗特有的行为
 public void LookHome() {
        System.out.println("~~狗特有的行为：看家~~");

    }




}

//继承动物类的猫类
public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("~~猫吃鱼~~");

    }
//猫特有的行为
 public void catche() {
        System.out.println("~~猫特有的行为：捉老鼠~~");

    }

}

//以下是测试类编写
public class Test {
//该方法用来输出相关动物的行为
    public static void showAction(Animal animal){
        if (animal instanceof Cat){//instanceof判断当前动物类是否可以作为子类cat
            Cat c=(Cat)animal; //向下转型
            c.eat();
            c.catche();
        }else if (animal instanceof Dog)
        {
            Dog d=(Dog) animal; //向下转型
            d.eat();
            d.LookHome();
        }
    }
    public static void main(String[] args) {
       //向上转型
       Animal  animal01=new Dog（）；
       Animal  animal02=new Cat（）；
       //向下转型
       //Dog dog=（Dog）animal01；
       //Cat cat=（Cat）animal02；
       showAction(animal01);
       showAction(animal02);

    }



}

向下转型其实就是强制转换。

可以理解为狗是动物，我们用动物来代称狗或者猫，猫和狗都有自己特有的行为，我们在调用动物时的行为方法时，不同的动物会有不同的行为，例如猫会捉鼠，狗会看家等。。。。。。。具体可以结合练习题理解

总结:

       1.什么情况下需要用到向下转型?
           只有用到了子类特有的行为时，才向下转型

       2.向下转型的格式
           基本数据类型强制类型转换: 目标数据类型变量名 = (目标数据类型)需要转换的数据
           引用数据类型强制类型转换: 子类类名对象名 = (子类类名)父类对象名;
     注意事项: 要想使用多态的向下转型，必须前提有多态的向上转型

07. 用instanceof关键字进行类型判断
instanceof 关键字的作用是什么?

instanceof 关键字用来判断当前类的类型是否可以作为子类使用。


//格式:
父类对象名  instanceof 子类类型（类名）
        判断父类对象，是否能当作某一个子类型来使用


// 使用格式 :
 
if (父类对象名 instanceof 子类类型) {
            多态的向下转型
        }

关于多态的练习题：

1.手机

根据需求完成代码:
(1)定义一个手机类
a.行为:打电话,发短信
(2)定义一个接口IPlay
a.行为:玩游戏

(3)定义一个旧手机类继承手机类
a.行为:继承父类的行为

(4)定义一个新手机继承手机类实现IPlay接口
a.行为:继承父类的行为,重写玩游戏方法

(5)定义一个测试类
a.在测试类中定义一个用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象
在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法。

接口：

public interface IPlay {
    public void playGame();
}

定义抽象的手机类：

public class Phone {

    public  void call(){
        System.out.println("~~打电话~~");
    }
    public void sendEml(){
        System.out.println("~~发短信~~");
    }
}

旧手机和新手机继承手机类，都拥有打电话和发短信的功能，而新手机可以玩游戏所以实现接口IPlay

//旧手机继承手机类
public class OldPhone extends Phone {

}

//新手机继承手机类，并实现玩游戏的接口
public class NewPhone extends Phone implements IPlay{
    @Override
    public void playGame() {
        System.out.println("~~~玩游戏~~~");
    }
}

测试：

package homework2;

public class test {
    public static void main(String[] args) {

        NewPhone n=new NewPhone();
        OldPhone o=new OldPhone();
        usePhone(o);
        usePhone(n);
    }

    public static void usePhone(Phone p) {
        p.call();
        p.sendEml();
    if (p instanceof NewPhone)
       {
           NewPhone n=(NewPhone)p;
           n.playGame();
       }
    }
}

2.进行描述笔记本类，实现笔记本使用USB鼠标(Mouse)、USB键盘(Keyboard)
(1) a.USB接口:
开启功能
关闭功能
b.笔记本类:
开机功能
关机功能
c.笔记本中定义使用USB设备的功能接口作为方法的参数和返回值
要求:既能使用鼠标也能使用键盘,使用USB功能内部调用开启和关闭功能
(3)鼠标类(Mouse):
要符合USB接口
(4)键盘类(KeyBoard):
要符合USB接口
(5)测试类:
创建电脑对象,依次调用开机方法,使用USB设备, 关机方法
(6)打印效果如下:
开机
连接鼠标的USB
断开鼠标的USB
连接键盘的USB
断开键盘的USB
关机

//usb接口

public interface USB {
    public void open();
    public void close();

}

鼠标和键盘实现USB接口：

//鼠标类实现usb接口
public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("鼠标usb接口打开");
    }

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


//键盘类实现usb接口
public class KeyBoard implements USB{
    @Override
    public void open() {
        System.out.println("键盘usb接口打开");
    }

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

电脑类实现相关方法：

public class Computer {
    public void ComputerOpen(){
        System.out.println("~~电脑启动~~");
    }
    public void ComputerClose(){
        System.out.println("~~电脑关机~~");
    }
    public void useUSB(USB u){
            // 判断是否是鼠标
            if (u instanceof Mouse) {
                // 鼠标点击
                Mouse m = (Mouse) u;
                m.open();
            }
            if (u instanceof KeyBoard) {
                KeyBoard k = (KeyBoard) u;
                k.open();
            }
        }
    public void CloseUSB(USB u){
        if (u instanceof Mouse) {
            Mouse m = (Mouse) u;
            m.close();
        }
        if (u instanceof KeyBoard) {
            KeyBoard k = (KeyBoard) u;
            k.close();
        }
    }


}

通过测试类调用测试多态

public class test {
    public static void main(String[] args) {

        Computer computer=new Computer();
        KeyBoard k=new KeyBoard();
        Mouse m=new Mouse();
        computer.ComputerOpen();//启动电脑
        computer.useUSB(k);//启动键盘接口
        computer.useUSB(m);//启动鼠标接口
        computer.CloseUSB(k);//关闭键盘接口
        computer.CloseUSB(m);//关闭鼠标接口
        computer.ComputerClose();//关机
    }
}

3.老司机开车案例.
   1.定义一个汽车类Car.有一个抽象方法run().
   2.定义一个小客车BabyCar类继承Car类;
   3.定义一个公交车类Bus继承Car类
   4.在测试类中定义一个方法.//把Xxx修改成具体类型.
   public static void dirverCar(Xxx x){
       x.run();
   }
   调用dirverCar方法.要求任何一种类型的车都可以开起来.

抽象类：car

public class Bus extends Car{
    @Override
    public void run() {
        System.out.println("Bus启动");
    }
}

实体类：Bus和Babycar

//bus类继承car
public class Bus extends Car{
    @Override
    public void run() {
        System.out.println("Bus启动");
    }
}

//Babycar类继承car
public class Babycar extends Car{
    @Override
    public void run() {
        System.out.println("Babycar启动");

    }
}

测试类

public class test {
    public static void dirverCar(Car c){
        c.run();
/*
之所以用直接用run就能调用形参中的Car c是因为，对于如果访问父子类中的共有方法时，优先访问子类重写的方法，这是继承的特点。
*/
    }

    public static void main(String[] args) {
        Car bus=new Bus();
        Car babycar=new Babycar();
        dirverCar(bus);
        dirverCar(babycar);
    }
}