【大数据】学习笔记 1 Java SE 第6章面向对象基础(中) 6.3 多态

柔情只为你懂 2024-03-22 11:24 35阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第6章 面向对象基础(中)
             *   *  6.3 多态
                 *   *  6.3.1 多态解决什么样的问题
                     *  6.3.2 多态的形式和体现
                     *  6.3.3 应用多态解决问题
                     *  6.3.4 向上转型与向下转型
                     *  6.3.5 虚方法
                     *  6.3.6 成员变量没有多态的说法

![在这里插入图片描述][ace27ab22d6b4518baa4fc6bc032bd36.png_pic_center]

#### 1 Java SE ####

##### 第6章 面向对象基础(中) #####

###### 6.3 多态 ######

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

生活中，比如求面积的功能，圆、矩形、三角形实现起来是不一样的。跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。那么此时就会出现各种子类的类型。

###### 6.3.1 多态解决什么样的问题 ######

有的时候，我们在设计一个数组、或一个成员变量、或一个方法的形参、返回值类型时，无法确定它具体的类型，只能确定它是某个系列的类型。

案例：

（1）声明一个Dog类，包含public void eat()方法，输出“狗狗啃骨头”

（2）声明一个Cat类，包含public void eat()方法，输出“猫咪吃鱼仔”

（3）声明一个Person类，

*  包含宠物属性
 *  包含领养宠物方法 public void adopt(宠物类型 pet)
 *  包含喂宠物吃东西的方法 public void feed()，实现为调用宠物对象.eat()方法

package com.dingjiaxiong.polymorphism.problem;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Dog
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:14
     */
    
    public class Dog {
        
        public void eat() {
        
            System.out.println("狗狗啃骨头");
        }
    }

package com.dingjiaxiong.polymorphism.problem;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Cat
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:15
     */
    
    public class Cat {
        
        public void eat() {
        
            System.out.println("猫咪吃鱼仔");
        }
    }

package com.dingjiaxiong.polymorphism.problem;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Person
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:15
     */
    
    public class Person {
        
        private Dog dog;
    
        //adopt：领养
        public void adopt(Dog dog) {
        
            this.dog = dog;
        }
    
        //feed：喂食
        public void feed() {
        
            if (dog != null) {
        
                dog.eat();
            }
        }
        /*
        问题：
        1、从养狗切换到养猫怎么办？   
            修改代码把Dog修改为养猫？
        2、或者有的人养狗，有的人养猫怎么办？  
        3、要是同时养多个狗，或猫怎么办？
        4、要是还有更多其他宠物类型怎么办？
        如果Java不支持多态，那么上面的问题将会非常麻烦，代码维护起来很难，扩展性很差。
        */
    }

###### 6.3.2 多态的形式和体现 ######

【1】多态引用

Java规定**父类类型的变量可以接收子类类型的对象**，这一点从逻辑上也是说得通的。

父类类型 变量名 = 子类对象；

> 父类类型：指子类继承的父类类型，或者实现的父接口类型。
> 
> 所以说继承是多态的前提

【2】多态引用的表现

表现：编译时类型与运行时类型不一致，编译时看“父类”，运行时看“子类”。

【3】多态引用的好处和弊端

弊端：编译时，只能调用父类声明的方法，不能调用子类扩展的方法；

好处：运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；变量引用的子类对象不同，执行的方法就不同，实现动态绑定。代码编写更灵活、功能更强大，可维护性和扩展性更好了。

【4】多态演示

让Dog和Cat都继承Pet宠物类。

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Pet
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:20
     */
    
    public class Pet {
        
        private String nickname;
    
        public String getNickname() {
        
            return nickname;
        }
    
        public void setNickname(String nickname) {
        
            this.nickname = nickname;
        }
    
        public void eat() {
        
            System.out.println(nickname + "吃东西");
        }
    }

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Cat
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:20
     */
    
    public class Cat extends Pet {
        
        //子类重写父类的方法
        @Override
        public void eat() {
        
            System.out.println("猫咪" + getNickname() + "吃鱼仔");
        }
    
        //子类扩展的方法
        public void catchMouse() {
        
            System.out.println("抓老鼠");
        }
    }

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Dog
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:21
     */
    
    public class Dog extends Pet {
        
        //子类重写父类的方法
        @Override
        public void eat() {
        
            System.out.println("狗狗" + getNickname() + "啃骨头");
        }
    
        //子类扩展的方法
        public void watchHouse() {
        
            System.out.println("看家");
        }
    }

测试类：

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestPet
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:22
     */
    
    public class TestPet {
        
        public static void main(String[] args) {
        
            //多态引用
            Pet pet = new Dog();
            pet.setNickname("小白");
    
            //多态的表现形式
            /*
            编译时看父类：只能调用父类声明的方法，不能调用子类扩展的方法；
            运行时，看“子类”，如果子类重写了方法，一定是执行子类重写的方法体；
             */
            pet.eat();//运行时执行子类Dog重写的方法
    //        pet.watchHouse();//不能调用Dog子类扩展的方法
    
            pet = new Cat();
            pet.setNickname("雪球");
            pet.eat();//运行时执行子类Cat重写的方法
        }
    }

![在这里插入图片描述][f22b2d0b541e40f9bf17aaff40c71baa.png_pic_center]

###### 6.3.3 应用多态解决问题 ######

【1】声明变量是父类类型，变量赋值子类对象

*  方法的形参是父类类型，调用方法的实参是子类对象
 *  实例变量声明父类类型，实际存储的是子类对象

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: OnePersonOnePet
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:25
     */
    
    public class OnePersonOnePet {
        
        private Pet pet;
    
        public void adopt(Pet pet) {
        //形参是父类类型，实参是子类对象
            this.pet = pet;
        }
    
        public void feed() {
        
            pet.eat();//pet实际引用的对象类型不同，执行的eat方法也不同
        }
    }

测试类

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestOnePersonOnePet
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:25
     */
    
    public class TestOnePersonOnePet {
        
        public static void main(String[] args) {
        
            OnePersonOnePet person = new OnePersonOnePet();
    
            Dog dog = new Dog();
            dog.setNickname("小白");
            person.adopt(dog);//实参是dog子类对象，形参是父类Pet类型
            person.feed();
    
            Cat cat = new Cat();
            cat.setNickname("雪球");
            person.adopt(cat);//实参是cat子类对象，形参是父类Pet类型
            person.feed();
        }
    }

![在这里插入图片描述][ffe9794274b0440b922041eac55cca9d.png_pic_center]

【2】数组元素是父类类型，元素对象是子类对象

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: OnePersonManyPets
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:26
     */
    
    public class OnePersonManyPets {
        
        private Pet[] pets;//数组元素类型是父类类型，元素存储的是子类对象
    
        public void adopt(Pet[] pets) {
        
            this.pets = pets;
        }
    
        public void feed() {
        
            for (int i = 0; i < pets.length; i++) {
        
                pets[i].eat();//pets[i]实际引用的对象类型不同，执行的eat方法也不同
            }
        }
    }

测试类：

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestPets
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:26
     */
    
    public class TestPets {
        
        public static void main(String[] args) {
        
            Pet[] pets = new Pet[2];
            pets[0] = new Dog();//多态引用
            pets[0].setNickname("小白");
            pets[1] = new Cat();//多态引用
            pets[1].setNickname("雪球");
    
            OnePersonManyPets person = new OnePersonManyPets();
            person.adopt(pets);
            person.feed();
        }
    }

![在这里插入图片描述][0d88bb393b0a4a688ba5106c1b9355ef.png_pic_center]

【3】方法返回值类型声明为父类类型，实际返回的是子类对象

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: PetShop
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:27
     */
    
    public class PetShop {
        
        //返回值类型是父类类型，实际返回的是子类对象
        public Pet sale(String type) {
        
            switch (type) {
        
                case "Dog":
                    return new Dog();
                case "Cat":
                    return new Cat();
            }
            return null;
        }
    }

测试类：

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestPetShop
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:28
     */
    
    public class TestPetShop {
        
        public static void main(String[] args) {
        
            PetShop shop = new PetShop();
    
            Pet dog = shop.sale("Dog");
            dog.setNickname("小白");
            dog.eat();
    
            Pet cat = shop.sale("Cat");
            cat.setNickname("雪球");
            cat.eat();
        }
    }

![在这里插入图片描述][e2e9bd8597be42e8b9bf4fc907fbbd03.png_pic_center]

###### 6.3.4 向上转型与向下转型 ######

首先，一个对象在new的时候创建是哪个类型的对象，它从头至尾都不会变。即这个对象的运行时类型，本质的类型用于不会变。但是，把这个对象赋值给不同类型的变量时，这些变量的编译时类型却不同。

这个和基本数据类型的转换是不同的。基本数据类型是把数据值copy了一份，相当于有两种数据类型的值。而对象的赋值不会产生两个对象。

【1】为什么要类型转换呢？

因为多态，就一定会有把子类对象赋值给父类变量的时候，这个时候，**在编译期间**，就会出现类型转换的现象。

但是，使用父类变量接收了子类对象之后，我们就**不能调用**子类拥有，而父类没有的方法了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做类型转换，使得**编译通过**。

*  **向上转型**：当左边的变量的类型（父类） > 右边对象/变量的类型（子类），我们就称为向上转型
    
     *  此时，编译时按照左边变量的类型处理，就只能调用父类中有的变量和方法，不能调用子类特有的变量和方法了
     *  但是，**运行时，仍然是对象本身的类型**，所以执行的方法是子类重写的方法体。
     *  此时，一定是安全的，而且也是自动完成的
 *  **向下转型**：当左边的变量的类型（子类）<右边对象/变量的编译时类型（父类），我们就称为向下转型
    
     *  此时，编译时按照左边变量的类型处理，就可以调用子类特有的变量和方法了
     *  但是，**运行时，仍然是对象本身的类型**
     *  不是所有通过编译的向下转型都是正确的，可能会发生ClassCastException，为了安全，可以通过isInstanceof关键字进行判断

【2】如何向上转型与向下转型

*  向上转型：自动完成
 *  向下转型：（子类类型）父类变量

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: ClassCastTest
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:30
     */
    
    public class ClassCastTest {
        
        public static void main(String[] args) {
        
            //没有类型转换
            Dog dog = new Dog();//dog的编译时类型和运行时类型都是Dog
    
            //向上转型
            Pet pet = new Dog();//pet的编译时类型是Pet，运行时类型是Dog
            pet.setNickname("小白");
            pet.eat();//可以调用父类Pet有声明的方法eat，但执行的是子类重写的eat方法体
    //        pet.watchHouse();//不能调用父类没有的方法watchHouse
    
            Dog d = (Dog) pet;
            System.out.println("d.nickname = " + d.getNickname());
            d.eat();//可以调用eat方法
            d.watchHouse();//可以调用子类扩展的方法watchHouse
    
            Cat c = (Cat) pet;//编译通过，因为从语法检查来说，pet的编译时类型是Pet，Cat是Pet的子类，所以向下转型语法正确
            //这句代码运行报错ClassCastException，因为pet变量的运行时类型是Dog，Dog和Cat之间是没有继承关系的
        }
    }

![在这里插入图片描述][18e2689ae7b547898d6c6814beaed3f5.png_pic_center]

【3】instanceof关键字

为了避免ClassCastException的发生，Java提供了 `instanceof` 关键字，给引用变量做类型的校验，只要用instanceof判断返回true的，那么强转为该类型就一定是安全的，不会报ClassCastException异常。

变量/匿名对象 instanceof 数据类型

那么，哪些instanceof判断会返回true呢？

*  变量/匿名对象的编译时类型 与 instanceof后面数据类型是直系亲属关系才可以比较
 *  变量/匿名对象的运行时类型<= instanceof后面数据类型，才为true

示例代码：

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestInstanceof
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:31
     */
    
    public class TestInstanceof {
        
        public static void main(String[] args) {
        
            Pet[] pets = new Pet[2];
            pets[0] = new Dog();//多态引用
            pets[0].setNickname("小白");
            pets[1] = new Cat();//多态引用
            pets[1].setNickname("雪球");
    
            for (int i = 0; i < pets.length; i++) {
        
                pets[i].eat();
    
                if (pets[i] instanceof Dog) {
        
                    Dog dog = (Dog) pets[i];
                    dog.watchHouse();
                } else if (pets[i] instanceof Cat) {
        
                    Cat cat = (Cat) pets[i];
                    cat.catchMouse();
                }
            }
        }
    }

![在这里插入图片描述][85824d958ba4442b9be19ec92d3f2f68.png_pic_center]

###### 6.3.5 虚方法 ######

在Java中虚方法是指在编译阶段和类加载阶段都不能确定方法的调用入口地址，在运行阶段才能确定的方法，即可能被重写的方法。

当我们通过“对象xx.方法”的形式调用一个虚方法时，要如何确定它具体执行哪个方法呢？

（1）静态分派：先看这个对象xx的编译时类型，在这个对象的编译时类型中找到能匹配的方法

匹配的原则：看实参的编译时类型与方法形参的类型的匹配程度
    A：找最匹配    实参的编译时类型 = 方法形参的类型
    B：找兼容      实参的编译时类型 < 方法形参的类型

（2）动态绑定：再看这个对象xx的运行时类型，如果这个对象xx的运行时类重写了刚刚找到的那个匹配的方法，那么执行重写的，否则仍然执行刚才编译时类型中的那个匹配的方法

###### 6.3.6 成员变量没有多态的说法 ######

package com.dingjiaxiong.polymorphism.grammar;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: TestVariable
     * @Author: Ding Jiaxiong
     * @Date:2023/4/24 20:32
     */
    
    public class TestVariable {
        
        public static void main(String[] args) {
        
            Base b = new Sub();
            System.out.println(b.a);
            System.out.println(((Sub) b).a);
    
            Sub s = new Sub();
            System.out.println(s.a);
            System.out.println(((Base) s).a);
        }
    }
    
    class Base {
        
        int a = 1;
    }
    
    class Sub extends Base {
        
        int a = 2;
    }

![在这里插入图片描述][f34882d611584b60982a4cc865d74a92.png_pic_center]

[ace27ab22d6b4518baa4fc6bc032bd36.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c6d0ae5139ca4002a31d9e4bcd89da10.png
[f22b2d0b541e40f9bf17aaff40c71baa.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/369faf31ee7646329a45f5b12e603460.png
[ffe9794274b0440b922041eac55cca9d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/a30cf7ac391a488e9e9bb1f395a1082e.png
[0d88bb393b0a4a688ba5106c1b9355ef.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/0b0e180267934a5f85227618ea38b6ea.png
[e2e9bd8597be42e8b9bf4fc907fbbd03.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ef2a36cfd31044f5bff851a632fe7958.png
[18e2689ae7b547898d6c6814beaed3f5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/58919d3ff1c24bad92136d531c1e2705.png
[85824d958ba4442b9be19ec92d3f2f68.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/44ce1b5842514ee28c2eec74c921cdbb.png
[f34882d611584b60982a4cc865d74a92.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/129d32500b1e41228ea3f428af6879cb.png