java多态进阶,吃透多态,这一篇就够了

简介: 1.动态绑定机制java的动态绑定机制非常重要🎈实例A我们来看一个实例:


1.动态绑定机制


java的动态绑定机制非常重要🎈


实例A


我们来看一个实例:



阅读上面的代码,请说明下面的程序将输出什么结果:



程序将会输出40和30,这个实例很简单,直接看运行类型即可,该代码的运行类型为B,所以会调用B类的方法


实例B


我们将上面的代码变通一下,将子类中的如下代码块注销:



随后继承机制会访问父类的sum方法:



那么这里有一个问题,此处的getI(),会执行子类的还是父类的呢?


当调用对象方法的时候,该方法会和该对象的内存地址/运行类型绑定🚀


代码的运行类型依然是B,所以此处会执行子类的getI()方法,结果输出为30


实例C


现在我们再变通以下上面的代码


再将子类中如下的代码块注销:



继承机制会执行父类的sum1方法:



那么这里有一个问题,此处的i,会使用子类的还是父类的呢?

属性没有动态绑定机制,哪里声明,哪里使用(使用当前类的)🐱‍🏍

此处的i在父类进行声明,所以会选用父类的i属性,结果为20


2.多态数组


定义:

数组的定义类型为父类类型,但是保存的实际元素类型为子类类型

Person父类:


/**
 * 多态数组父类
 */
public class Person {
    private String name;
    private int age;
    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;
    }
    public String say() {
        return name + '\t' + age;
    }
}


Student子类:


/**
 * 多态数组学生子类
 */
public class Student extends Person{
    private double score;
    public Student(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }
    // 重写父类的say方法
    public String say() {
        return super.say() + '\t' + score;
    }
}


Teacher子类:


/**
 * 多态数组教师子类
 */
public class Teacher extends Person {
    private double sal;
    public Teacher(String name, int age, double sal) {
        super(name, age);
        this.sal = sal;
    }
    public double getSal() {
        return sal;
    }
    public void setSal(double sal) {
        this.sal = sal;
    }
    public String say() {
        return super.say() + '\t' + sal;
    }
}


测试多态数组的使用:


public class Test {
    public static void main(String[] args) {
        // 多态数组的使用
        Person[] persons = new Person[5];
        persons[0] = new Person("dahe",20);
        persons[1] = new Student("wangwei",11,100);
        persons[2] = new Student("zhangsan",12,60);
        persons[3] = new Teacher("wang",33,15000);
        persons[4] = new Teacher("li",55,25000);
        // 循环遍历多态数组,调用say方法
        for (int i = 0; i < persons.length; i++) {
            String out = persons[i].say(); // 动态绑定机制,编译类型永远都是Person
            // 运行类型是根据实际情况由JVM机决定
            System.out.println(out);
        }
    }
}
----------------------------------
输出:
dahe  20
wangwei 11  100.0
zhangsan  12  60.0
wang  33  15000.0
li  55  25000.0


3.多态数组的高阶用法


现在,教师子类新增了教学方法:


public void teach() {
    System.out.println("老师:" + getName() + "正在讲课!");
}


学生子类新增了学习方法:


public void study() {
    System.out.println("学生:" + getName() + "正在学习!");
}


那么,有没有办法通过多态数组来访问他们子类对应的独有的方法呢?事实上,可以通过巧妙使用instanceof来解决:

变通一下,改变多态数组的循环操作:


// 循环遍历多态数组,调用say方法
for (int i = 0; i < persons.length; i++) {
    String out = persons[i].say(); // 动态绑定机制,编译类型永远都是Person
    // 运行类型是根据实际情况由JVM机决定
    System.out.println(out);
    if (persons[i] instanceof Student) {
        // 向下转型
        Student student = (Student) persons[i];
        student.study();
    } else if (persons[i] instanceof Teacher) {
        Teacher teacher = (Teacher) persons[i];
        teacher.teach();
    }
}
-----------------------------
输出:
dahe  20
wangwei 11  100.0
学生:wangwei正在学习!
zhangsan  12  60.0
学生:zhangsan正在学习!
wang  33  15000.0
老师:wang正在讲课!
li  55  25000.0
老师:li正在讲课!


大功告成!多态数组即强大又完美!🎂


4.多态参数


方法定义的形参类型为父类类型,实参类型允许为子类类型

接下来我们来演示以下多态参数的使用:

父类:


/**
 * 多态参数 - 父类
 */
public class Employee {
    private String name;
    private double sal;
    public Employee(String name, double sal) {
        this.name = name;
        this.sal = sal;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getSal() {
        return sal;
    }
    public void setSal(double sal) {
        this.sal = sal;
    }
    // 得到年工资的方法
    public double getAnnual() {
        return 12 * sal;
    }
}


员工子类:


/**
 * 多态参数 - 子类员工
 */
public class Worker extends Employee{
    public Worker(String name, double sal) {
        super(name, sal);
    }
    public void work() {
        System.out.println("普通员工:" + getName() + "正在工作!");
    }
    public double getAnnual() {
        return super.getAnnual();
    }
}


经理子类:


/**
 * 多态参数 - 经理子类
 */
public class Manager extends Employee{
    private double bonus; // 奖金
    public Manager(String name, double sal, double bonus) {
        super(name, sal);
        this.bonus = bonus;
    }
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    public void manage() {
        System.out.println("经理:" + getName() + "正在管理!");
    }
    @Override
    public double getAnnual() {
        return super.getAnnual() + bonus;
    }
}


我们来测试一下,求不同岗位的雇员的年薪:


/**
 * 多态参数测试类
 */
public class Test {
    public static void main(String[] args) {
        Worker zhang = new Worker("张工",1000);
        Manager milan = new Manager("milan", 5000, 2000);
        Test test = new Test();
        test.showEmpAnnual(zhang);
        test.showEmpAnnual(milan);
    }
    // 获取员工的年薪,采用多态参数
    public void showEmpAnnual(Employee e) {
        System.out.println(e.getAnnual());
    }
}
-------------------------------------
输出:
12000.0
62000.0


5.多态参数的高阶用法


我们来对上面的多态参数代码做一个完善,如果传入的是员工,则调用自己的work方法,如果传入的是经理,则调用自己的manage方法

增加一个下面的方法:


public void testWork(Employee e) {
    if (e instanceof Worker) {
        ((Worker) e).work(); // 向下转型
    } else if (e instanceof Manager) {
        ((Manager) e).manage();
    }
}


测试:


test.testWork(zhang);
test.testWork(milan);
---------------------------
输出:
普通员工:张工正在工作!
经理:milan正在管理!


成功之秘诀,在始终不变其目的🌕

目录
相关文章
|
3月前
|
算法 Java 程序员
在Java的编程世界里,多态不仅仅是一种代码层面的技术,它是思想的碰撞,是程序员对现实世界复杂性的抽象映射,是对软件设计哲学的深刻领悟。
在Java的编程世界里,多态不仅仅是一种代码层面的技术,它是思想的碰撞,是程序员对现实世界复杂性的抽象映射,是对软件设计哲学的深刻领悟。
69 9
|
3月前
|
Java 开发者
在Java面向对象编程的广阔海洋中,多态犹如一股深邃的潜流,它推动着代码从单一走向多元,从僵化迈向灵活。
在Java面向对象编程的广阔海洋中,多态犹如一股深邃的潜流,它推动着代码从单一走向多元,从僵化迈向灵活。
42 7
|
3月前
|
Java 开发者
那些年,我们一同踏入Java编程的大门,多态,这个充满魔法的名字,曾无数次点亮我们探索面向对象编程的热情。
那些年,我们一同踏入Java编程的大门,多态,这个充满魔法的名字,曾无数次点亮我们探索面向对象编程的热情。
49 5
|
3月前
|
Java 程序员
让我们一起探讨Java多态的奥秘,看看它是如何打破“一刀切”的局限,让我们的代码更加生动多彩
让我们一起探讨Java多态的奥秘,看看它是如何打破“一刀切”的局限,让我们的代码更加生动多彩
42 5
|
3月前
|
Java 程序员
Java中的继承和多态:理解面向对象编程的核心概念
【8月更文挑战第22天】在Java的世界中,继承和多态不仅仅是编程技巧,它们是构建可维护、可扩展软件架构的基石。通过本文,我们将深入探讨这两个概念,并揭示它们如何共同作用于面向对象编程(OOP)的实践之中。你将了解继承如何简化代码重用,以及多态如何为程序提供灵活性和扩展性。让我们启程,探索Java语言中这些强大特性的秘密。
|
30天前
|
存储 Java 测试技术
Java零基础-多态详解
【10月更文挑战第10天】Java零基础教学篇,手把手实践教学!
21 4
|
1月前
|
Java 编译器 程序员
Java多态背后的秘密:动态绑定如何工作?
本文介绍了Java中多态的实现原理,通过动态绑定和虚拟方法表,使得父类引用可以调用子类的方法,增强了代码的灵活性和可维护性。文中通过具体示例详细解析了多态的工作机制。
41 4
|
2月前
|
Java 编译器
封装,继承,多态【Java面向对象知识回顾①】
本文回顾了Java面向对象编程的三大特性:封装、继承和多态。封装通过将数据和方法结合在类中并隐藏实现细节来保护对象状态,继承允许新类扩展现有类的功能,而多态则允许对象在不同情况下表现出不同的行为,这些特性共同提高了代码的复用性、扩展性和灵活性。
封装,继承,多态【Java面向对象知识回顾①】
|
1月前
|
Java
java继承和多态详解
java继承和多态详解
42 5
|
1月前
|
存储 Java 测试技术
Java零基础-多态详解
【10月更文挑战第1天】Java零基础教学篇,手把手实践教学!
27 1