面向对象编程--多态

多态（多种状态）的基本介绍：

　　方法或对象具有多种形态，是面向对象的三大特征，多态是建立在封装和继承的基础之上的。

　　多态的具体体现

 　　　  1）方法的多态

　　　　2）对象的多态

　　　　　　一个对象的编译类型和运行类型可以不一致；

　　　　　　编译类型在定义对象时就确定了不能改变；

　　　　　　运行类型是可以改变化的；

　　　　　　编译类型看定义时 =号 的左边，运行类型看 =号 右边；

　　　　　　

 

 　　　　　　多态注意事项和细节讨论：

　　　　　　　　1）多态的前提是：两个对象（类）存在继承关系；

　　　　　　　　2）多态的向上转型：

　　　　　　　　　　　（1）本质：父类的引用指向子类的对象；

　　　　　　　　　　　（2）语法：父类类型  引用名 =new 子类类型();

　　　　　　　　　　　（3）特点：编译类型看左边，运行类型看右边。

　　　　　　　　　　　　　　　　  可以调用父类中所有成员（须遵守访问权限）

　　　　　　　　　　　　　　　　  不能调用子类中特有的成员

　　　　　　　　　　　　　　　　  最终运行看子类的具体实现

　　　　     　　3）多态的向下转型：

　　　　　　　　　　　（1）语法：子类类型  引用名 = （子类类型）父类引用；

　　　　　　　　　　　（2）只能强转父类引用不能强转父类对象；

　　　　　　　　　　　（3）可以调用子类类型中的所有成员。   

　　　　　　　属性没有重写之说，属性的值看编译类型。

　　　　　　　instanceof比较操作符，用于判断对象是否为XX类型或XX类型的子类型：　　　　　　

package com.javamj.test;

import com.sun.org.apache.bcel.internal.generic.NEW;

/**
 * Copyright (C), 2018-2021, Mr.Lin
 * Author: Mr.Lin
 * Date: 2021/11/10 22:37
 * FileName: PoliDetail
 * Description: 判断对象类型
 */
public class PoliDetail {
    public static void main(String[] args) {
        //判断a是否为A的子类型 true
        //判断a是否为B的子类型 false
        //判断b是否为A的子类型 false
        A a = new A();
        B b = new B();
        System.out.println(a instanceof A);
        System.out.println(a instanceof B);
        System.out.println(b instanceof A);
        //判断a1是否是A，B的子类型；
        A a1 = new B();
        System.out.println(a1 instanceof A);//true
        System.out.println(a1 instanceof B);//true

    }
}
Java动态绑定机制：
　　1）当调用对象方法的时候，该方法和该对象的内存地址/运行类型绑定
　　2）当调用对象属性时，没有动态绑定机制，那里申明哪里使用
多态的应用：
　　多态数组：多态数组定义类型为父类类型，里面保存的实际元素

package com.javamj.com.javamj.polyparamenter_;

import java.sql.SQLOutput;

/**
 * Copyright (C), 2018-2021, Mr.Lin
 * Author: Mr.Lin
 * Date: 2021/11/11 0:06
 * FileName: PloyParamenter
 * Description:面向对象--多态 的练习(main)
 */
public class PloyParamenter {
    public static void main(String[] args) {
        Person p = new Person("xiaoqiang", 175);
        Manager m = new Manager("王腾欢", 1500, 23000);
        PloyParamenter pl = new PloyParamenter();
        pl.showEmpAnnual(p);
        pl.showEmpAnnual(m);

        pl.testWorke(p);
        pl.testWorke(m);


    }

    public void showEmpAnnual(Employee e){
        System.out.println(e.getAnnual());
    }

    public void testWorke(Employee e){
        if (e instanceof Person) {
            ((Person) e).Manage();
        }else if (e instanceof Manager) {
            ((Manager) e).Management();
        }else {
            System.out.println("没有此类");
        }
    }
}

 

类型是子类类型

经理

package com.javamj.com.javamj.polyparamenter_;

/**
 * Copyright (C), 2018-2021, Mr.Lin
 * Author: Mr.Lin
 * Date: 2021/11/11 0:07
 * FileName: Manager
 * Description: 经理类
 */
public class Manager extends Employee{
    private double bonus;//奖金

    public Manager(String name, double annual,double bonus) {
        super(name, annual);
        this.bonus = bonus;
    }

    public void Management(){
        System.out.println(getName()+" 经理具有管理的方法");
    }

    @Override
    public void Wage() {
        System.out.println(getAnnual()*12+bonus);
    }
}

普通员工

package com.javamj.com.javamj.polyparamenter_;

/**
 * Copyright (C), 2018-2021, Mr.Lin
 * Author: Mr.Lin
 * Date: 2021/11/10 23:51
 * FileName: Polyparamenter
 * Description: 面向对象--多态 的练习(员工)
 */
public class Employee {
    private String name;
    private double annual;

    public Employee(String name, double annual) {
        this.name = name;
        this.annual = annual;
    }
    public void Wage(){
        System.out.println(getAnnual()*12);
    }

    public String getName() {
        return name;
    }

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

    public double getAnnual() {
        return annual;
    }

    public void setAnnual(double annual) {
        this.annual = annual;
    }
}