java基础-多态

深藏阁楼爱情的钟 2023-09-27 13:25 143阅读 0赞

> **前言：**
> 
> 小亭子正在努力的学习编程，接下来将开启java的学习~~
> 
> 分享的文章都是学习的笔记和感悟，如有不妥之处希望大佬们批评指正~~
> 
> 同时如果本文对你有帮助的话，**烦请点赞关注支持一波, 感激不尽~~**

**目录**

什么是多态

多态实现条件

多态的常见形式

多态体现：

向上转型

向下转型：（强制类型转换）

多态中访问成员的特点

多态的优缺点

--------------------

## 什么是多态 ##

**同类型的对象，执行同一个行为，会表现出不同的行为特征。**

### 多态实现条件 ###

在java中要实现多态，必须要满足如下几个条件，缺一不可：

1.  必须在继承体系下
2.  子类必须要对父类中方法进行重写
3.  通过父类的引用调用重写的方法

### 多态的常见形式 ###

*  父类类型 对象名称 = new 子类构造器；
 *  接口 对象名称 = new 实现类构造器；

### 多态体现： ###

在代码运行时，当传递不同类对象时，会调用对应类中的方法。

public class Animal {
        String name;
        int age;
        public Animal(String name, int age){
            this.name = name;
            this.age = age;
        }
        public void eat(){
            System.out.println(name + "吃饭");
        }
    }
     class Cat extends Animal{
        public Cat(String name, int age){
            super(name, age);
        }
        @Override
        public void eat(){
            System.out.println(name+"吃鱼~~~");
        }
    }
     class Dog extends Animal {
        public Dog(String name, int age){
            super(name, age);
        }
        @Override
        public void eat(){
            System.out.println(name+"吃骨头~~~");
        }
    }
    
    //----------------------------------------------
    class TestAnimal {
        // 编译器在编译代码时，并不知道要调用Dog 还是 Cat 中eat的方法
    // 等程序运行起来后，形参a引用的具体对象确定后，才知道调用那个方法
    // 注意：此处的形参类型必须时父类类型才可以
        public static void eat(Animal a){
    
            a.eat();
        }
        public static void main(String[] args) {
            Cat cat = new Cat("元宝",2);
            Dog dog = new Dog("小七", 1);
            eat(cat);
            eat(dog);
        }
    }

> 运行结果：
> 
> 元宝吃鱼~~~
> 
> 小七吃骨头~~~
> 
> ![8084fcddaf98492cbf78b8d5465f078e.png][]
> 
> 【简单描述下就是：定义一个A类，A类中有成员变量和成员方法，再写其他的B类继承这个A类，B类中重写A类的成员方法，main方法中用实例化B类给C，C在调用B的成员方法的时候，调用的是B重写A的成员方法以后的那个方法】

### 向上转型 ###

实际就是创建一个子类对象，将其当成父类对象来使用。（相当于子类对象赋值给父类类型的变量指向）

**语法格式：父类类型 对象名称 = new 子类构造器；**

举个栗子：

public class TestAnimal {
    // 2. 方法传参：形参为父类型引用，可以接收任意子类的对象
    public static void eatFood(Animal a){
    a.eat();
    }
    // 3. 作返回值：返回任意子类对象
    public static Animal (String var){
    if("狗".equals(var) ){
    return new Dog("狗狗",1);
    }else if("猫" .equals(var)){
    return new Cat("猫猫", 1);
    }else{
    return null;
    }
    }
    public static void main(String[] args) {
    Animal cat = new Cat("元宝",2); // 1. 直接赋值：子类对象赋值给父类对象
    Dog dog = new Dog("小七", 1);
    eatFood(cat);
    eatFood(dog);
    Animal animal = buyAnimal("狗");
    animal.eat();
    animal = buyAnimal("猫");
    animal.eat();
    }
    }

**向上转型的优点：让代码实现更简单灵活。**

**向上转型的缺陷：不能调用到子类特有的方法。**

### 向下转型：（强制类型转换） ###

相当于父类类型的变量赋值给子类类型变量使用

**子类类型 对象名称 = new 父类类型 变量名称；**

作用：

*  可以解决多态的劣势，实现调用子类独有的功能
 *  一般用得少，建议用instanceof判断当前对象的真实性。
 *  因为转型后的类型与对象真实类型不是一种类型，会出现ClassCastException报错。

instanceof 关键词官方介绍：[Chapter 15. Expressions (oracle.com)][Chapter 15. Expressions _oracle.com]

### 多态中访问成员的特点 ###

**方法调用：编译看左边，运行看右边**

**变量调用：编译看左边，运行也看左边**

举个栗子：

> 先定义一个animal父类，一个Dog子类，一个Tortoise子类![1bad5668d4104e68a1ea72e7364b9ec2.png][]

### 多态的优缺点 ###

多态的优点：

1. 能够降低代码的 "圈复杂度", 避免使用大量的 if - else

2. 可扩展能力更强

多态缺陷：代码的运行效率降低。

1. 属性没有多态性 当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性

2. 构造方法没有多态性

[8084fcddaf98492cbf78b8d5465f078e.png]: https://img-blog.csdnimg.cn/8084fcddaf98492cbf78b8d5465f078e.png
[Chapter 15. Expressions _oracle.com]: https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.20.2
[1bad5668d4104e68a1ea72e7364b9ec2.png]: https://img-blog.csdnimg.cn/1bad5668d4104e68a1ea72e7364b9ec2.png