多态和引用数据类型

下雨摸鱼休息

已于 2024-01-01 23:04:51 修改

阅读量399

点赞数 9

文章标签： java 开发语言

于 2023-12-30 22:04:47 首次发布

本文链接：https://blog.csdn.net/2301_78496658/article/details/135309989

版权

一、什么是多态

同类型的对象，表现出的不同形式

二、多态的表现形式

父类类型对象名称 = 子类对象；

三、多态的前提

1、需要有继承/实现关系（实现与接口有关，现在还没学到o(TヘTo)）

2、需要有父类引用指向子类对象

eg.Fu f = new zi()；

3、需要有方法重写

四、多态的好处

使用父类类型作为参数，可以接收所有子类对象，体现多态的扩展性与便利（是真节省代码啊，省力！）

五、多态调用成员的特点

1、变量调用：

编译看左边，运行也看左边

（编译看左边：javac编译代码时，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有，编译失败

运行也看左边：Java运行代码的时候，实际获取的就左边父类中成员变量的值）

2、方法调用：

编译看左边，运行看右边

（编译看左边：javac编译代码时，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有，编译失败

运行看右边：Java在运行代码的时候，实际上运行的是子类中的方法）

六、优势

1、在多态形势下,右边对象可以实现解耦合，便于扩展和维护

eg.

Person p = new Student();
p.work();//几天后，我不想让Student工作了，想换Teacher，此时只需要将Student改为Teacher就行了，后续代码无需修改。

2、定义方法的时候，使用父类型作为参数，可以接收所有子类对象，体现多态的扩展性与遍历

七、弊端

不能调用子类的特有功能

解决方案：变会子类类型就可以了。

细节：转换的时候不能瞎转，如果转乘其他类的类型，就会报错。

八、引用数据类型的类型转换分为

1、自动类型转换

Person p = new Student();

2、强制类型转换

Student s = (Student) p;

九、强转能解决什么问题

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

2、转换类型与真实对象类型不一致就会报错

3、转换的时候用instanceof关键字进行判断

if(a instenceof Dog){
    Dog d = (Dog) a;
    d.lookHome();
}else if(a instenceof Cat){
    Cat c = (Cat) a;
    c.catchMouse();
}else{
    System.out.println("没有这个类型，无法转换");
}

JDK14的时候提出新特性：判断和强转结合在一起

//先判断a是否是Dog类型，如果是则强转dog类型，变量名为d，如果不是，则不强转，结果为false
if(a instenceof Dog d){
    d.lookHome();
}else if(a instenceof Cat c){
    c.catchMouse();
}else{
    System.out.println("没有这个类型，无法转换");
}

课后习题：

题目：

/*1.定义狗类
属性:
行为:
年龄，颜色
eat(String something)(something表示吃的东西)看家lookHome方法(无参数)
2.定义猫类
属性:年龄，颜色
行为:eat(String something)
方法(something表示吃的东西)逮老鼠catchMouse方法(无参数)
3.定义Person类//饲养员属性:
姓名，年龄
行为:
    keepPet(Dog dog,String something)方法功能: 喂养宠物狗，something表示喂养的东西
行为:
    keepPet(Cat cat,String something)方法功能: 喂养宠物猫，something表示喂养的东西
    生成空参有参构造，set和get方法
4.定义测试类(完成以下打印效果):
    keepPetDog dog,String somethind)方法
    打印内容如下:年龄为30岁的老王养了一只黑颜色的2岁的狗2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
    keepPet(Cat cat,String somethind)方法
    打印内容如下:年龄为25岁的老李养了一只灰颜色的3岁的猫3岁的灰颜色的猫眯着眼睛侧着头吃鱼
5.思考
1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处?
2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法?*/

//Anmial类
public class Anmial {
    /*属性：
    * 年龄，颜色
    * 行为：吃*/
    private int age;
    private String color;

    public Anmial() {
    }

    public Anmial(int age, String color) {
        this.age = age;
        this.color = color;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    public void eat(String something){
        System.out.println("动物在吃" + something);
    }
}

//Dod类
public class Dog extends Anmial{
    /*定义狗类
    * 行为：吃骨头，看家*/

    public Dog() {
    }

    public Dog(int age, String color) {
        super(age, color);
    }

    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的" + getColor() + "颜色的狗两只前腿死死的抱住骨头猛吃");
    }
    public void lookHome(){
        System.out.println("狗在看家");
    }
}

//Cat类

public class Cat extends Anmial{
    public Cat() {
    }

    public Cat(int age, String color) {
        super(age, color);
    }
    @Override
    public void eat(String something) {
        System.out.println(getAge() + "岁的" + getColor() + "颜色的猫眯着眼睛侧着头吃鱼");
    }
    public void catchMouse(){
        System.out.println("猫在逮老鼠");
    }

}

//Person类
public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    /*行为:
    keepPet(Dog dog,String something)方法功能: 喂养宠物狗，something表示喂养的东西
行为:
    keepPet(Cat cat,String something)方法功能: 喂养宠物猫，something表示喂养的东西*/
    /*//方法一：
    public void keepPet(Dog dog,String something){
        System.out.println("年龄为"+getAge()+"岁的"+getName()+"养了一只"+dog.getColor()+"颜色的"+dog.getColor()+"岁的狗");
        dog.eat(something);
    }

    public void keepPet(Cat cat,String something){
        System.out.println("年龄为"+getAge()+"岁的"+getName()+"养了一只"+cat.getColor()+"颜色的"+cat.getColor()+"岁的猫");
        cat.eat(something);
    }*/
    //方法二：多态的引用
    public void keepPet(Anmial a,String something) {
        if (a instanceof Dog){
            Dog d = (Dog) a;
            System.out.println("年龄为" + getAge() + "岁的" + getName() + "养了一只" + d.getAge() + "颜色的" + d.getColor() + "岁的狗");
            d.eat(something);
        } else if (a instanceof Cat ) {
            Cat c = (Cat) a;
            System.out.println("年龄为" + getAge() + "岁的" + getName() + "养了一只" + c.getAge() + "颜色的" + c.getColor() + "岁的猫");
            c.eat(something);
        }else {
            System.out.println("没有这个类型，无法转换");
        }


    }
}

//测试类：
public class ceshi {
    public static void main(String[] args) {
       /*//方法一：
        Person p1 = new Person("老王",30);
        Dog d = new Dog(2,"黑");
        p1.keepPet(d,"骨头");

        Person p2 = new Person("老李",25);
        Cat c = new Cat(3,"灰");
        p2.keepPet(c,"鱼");*/
        //方法二：
        Person p1 = new Person("老王",30);
        Dog d = new Dog(2,"黑");
        p1.keepPet(d,"骨头");

        Person p2 = new Person("老李",25);
        Cat c = new Cat(3,"灰");
        p1.keepPet(c,"猫");
    }
}

输出结果如下：