• Java三大特性篇之——多态篇(千字详解)


    JAVA面向对象编程有三大特性:封装、继承、多态,在我们学习了继承后,我们将继续学习多态。

    前言:什么是多态?

    通俗来说:就是多种形态,具体点就是去完成某个行为,当不同的对象去完成时会产生出不同的状态!

    比如stuendt是一个父类,那么在操场上上体育课的学生和在教室里面的学生就是它的子类。这时上课铃声响了,上体育课的学生去操场,在教室里面上课的学生则是回教室,不同的学生有着不同的反应,这就是多态。

    一、多态实现

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

    1. 必须在继承体系下
    2. 子类必须要对父类中方法进行重写
    3. 通过父类的引用调用重写的方法
    4. 向上转型:在多态中需要将子类的引用赋给父类对象,只有这样该引用才能够具备技能调用父类的方法和子类的方法。

    多态体现在代码运行时,当传递不同类对象时,会调用对应类中的方法.
    eg:

    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+"在吃骨头");
        }
    }
    
    public class text1 {
            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);
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    运行结果如下:
    在这里插入图片描述

    当类的调用者在编写 eat 这个方法的时候, 参数类型为 Animal (父类), 此时在该方法内部并不知道, 也不关注当前的a 引用指向的是哪个类型(哪个子类)的实例. 此时 a这个引用调用 eat方法可能会有多种不同的表现(和 a 引用的实例相关), 这种行为就称为 多态.

    二、再谈重写

    重写(override):也称为覆盖。重写是子类对父类非静态、非private修饰,非final修饰,非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变,核心重写!重写的好处在于子类可以根据需要,定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法

    我们在上一篇继承中已经具体讲述过,可以参考之前文章中提到的来学习,具体点击下方:
    Java三大特性篇——继承篇

    在写代码中我们要注意这个问题:避免在构造方法中调用重写的方法!

    尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.

    【重写和重载的区别】

    在这里插入图片描述
    即:方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现

    也因此我们有了如下定义

    1. 静态绑定:也称为前期绑定(早绑定),即在编译时,根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
    2. 动态绑定:也称为后期绑定(晚绑定),即在编译时,不能确定方法的行为,需要等到程序运行时,才能够确定具体调用那个类的方法。(体现多态)

    三、向上转移

    • 向上转型:实际就是创建一个子类对象,将其当成父类对象来使用

    • 语法格式:父类类型 对象名 = new 子类类型()

    Animal animal = new Cat("锅巴",7);
    
    • 1

    animal是父类类型,但可以引用一个子类对象,因为是从小范围向大范围的转换。

    • 适用场景:1. 直接赋值;2. 方法传参;3. 方法返回

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

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

    向下转型我们不经常使用,而且不安全,万一转换失败,运行时就会抛异常。我们就不多介绍!

    四、多态优缺点

    优点:

    • .能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
    • 可扩展能力更强

    缺点:

      1. 当父类和子类都有同名属性的时候,通过父类引用来引用父类自己的成员属性
      1. 构造方法没有多态性

    我们通过一段代码实例感受多态:

    五、多态案例

    /*
     * 演示多态数组
     * 创建一个 Person 对象
     * 创建一个 Student 对象
     * 创建一个 Teacher 对象
     * 统一放在数组里,并调用每个对象的 mission() 方法。
     */
    
    class Person {
        private String name;
    
        public Person(String name) {
            this.name = name;
        }
    
        // getter 和 setter
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
    
        // mission() 方法
        public String mission() {
            return name + "\t" + "要开开心心";
        }
    }
    
    class Student extends Person {
        private double score;
    
        public Student(String name, double score) {
            super(name);
            this.score = score;
        }
    
        public double getScore() {
            return score;
        }
    
        public void setScore(double score) {
            this.score = score;
        }
    
        //重写父类的say方法
        @Override
        public String mission() {
            return super.mission() + " score =" + score + " 要好好学习!";
        }
    }
    
    class Teacher extends Person {
        private double salary;
    
        public Teacher(String name, double salary) {
            super(name);
            this.salary = salary;
        }
    
        public double getSalary() {
            return salary;
        }
    
        public void setSalary(double salary) {
            this.salary = salary;
        }
    
        //重写父类的 mission 方法
        @Override
        public String mission() {
            return super.mission() + " salary =" + salary + " 要好好教书!";
        }
    }
    
    public class text {
        public static void main(String[] args) {
            Person[] persons = new Person[3];
            persons[0] = new Person("小汤");
            persons[1] = new Student("小韬", 100);
            persons[2] = new Teacher("小蒲", 10000);
    
            //循环遍历多态数组,调用 mission
            for(int i = 0; i < persons.length; i++) {
                //此处涉及动态绑定机制
                // Person[i] 编译类型是 Person ,运行类型根据实际情况由 JVM 判断
                System.out.println(persons[i].mission());
            }
        }
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91

    在这里插入图片描述

    最后

    感谢大家读完了本篇博客,希望能帮到大家,我们下篇再见!

  • 相关阅读:
    MySQL和Redis的双写一致性
    呈现高效的软件测试技术 助力软件研发提升10倍质量
    Java 经典面试题
    WebSocket--1.协议解析
    “软硬结合”- 转转搜索少无结果模块简介
    [答疑]涉众给的规范里有“数据精确度”,算设计约束吗
    c语言进阶 数据的存储(上)
    超好用的手机开源自动化测试工具分享
    uvm白皮书练习_ch2_ch223_加入objection机制
    JavaEE初阶学习:HTTP协议和Tomcat
  • 原文地址:https://blog.csdn.net/m0_65038072/article/details/127919887