Java基础巩固系列 面向对象的特征三：多态性

多态性指的是什么？

多态性，可以理解为一个事物的多种形态。    1）方法的重载与重写 2）子类对象的多态性

 

1.子类对象的多态性使用的前提：

     ①要有类的继承

     ②要有子类对父类方法的重写

2.程序运行分为编译状态和运行状态，对于多态性来说:

     ①编译时，“看左边”，将此引用变量理解为父类的类型

     ②运行时，“看右边”，关注于真正对象的实体，子类的对象。那么执行的方法就是子类重写的。

3.子类对象的多态性，并不使用于属性，只适用于方法。

代码示例：

Person类

package com.peter.java5;

public class Person {
    private String name;
    private int age;

    public Person() {
    }

    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 void walk(){
        System.out.println("人走路");
    }

    public void  eat(){
        System.out.println("人吃饭");
    }
}

Man类

package com.peter.java5;

public class Man extends Person{
    private boolean smoking;

    public Man() {
    }

    public Man(boolean smoking) {
        this.smoking = smoking;
    }

    public boolean isSmoking() {
        return smoking;
    }

    public void setSmoking(boolean smoking) {
        this.smoking = smoking;
    }

    @Override
    public void walk() {
        System.out.println("男人笔挺的走路");
    }

    @Override
    public void eat() {
        System.out.println("男人多吃点肉");
    }

    public void entertainment(){
        System.out.println("男人请客");
    }
}

Woman类

package com.peter.java5;

public class Woman extends Person{
    private boolean isBeauty;

    public Woman() {
    }

    public Woman(boolean isBeauty) {
        this.isBeauty = isBeauty;
    }

    public boolean isBeauty() {
        return isBeauty;
    }

    public void setBeauty(boolean beauty) {
        isBeauty = beauty;
    }

    @Override
    public void walk() {
        System.out.println("女儿窈窕的走路");
    }

    @Override
    public void eat() {
        System.out.println("女人应该少吃，减肥");
    }

    public void shopping(){
        System.out.println("女人爱购物");
    }
}

Test类

package com.peter.java5;

public class Test {
    public static void main(String[] args) {
        Person p = new Person();
        p.eat();
        p.walk();

        Man m = new Man();
        m.eat();
        m.walk();

        //子类对象的多态性：父类的引用指向子类对象
        Person p1 = new Man();//向上转型
        //虚拟方法调用：通过父类的引用指向子类的对象实体，当调用方法时，实际执行的是子类重写父类的方法
        p1.eat();
        p1.walk();

//        person1.entertainment();

        Person p2 = new Woman();
        p2.eat();
        p2.walk();
//        person2.shopping();

        Woman w = (Woman) p2;   //向下转型,使用强转符：（）
        w.shopping();

//        Woman w1 = (Woman)p1;   //ClassCastException
//        w1.shopping();

//        Woman w2 = (Woman) new Man();
        //instanceof:
        //格式：对象a instanceof 类A：判断对象a是否是类A的一个实例，是的话，返回true；否则返回false
        //若a是A类的实例，那么a也一定是A类的父类的实例。
        if (p1 instanceof Woman){
            System.out.println("hello!");
            Woman w1 = (Woman)p1;
            w1.shopping();
        }

        if (p1 instanceof Man){
            Man m1 = (Man)p1;
            m1.entertainment();
        }

        if (p1 instanceof Person){
            System.out.println("你好！");
        }
    }

    public void show(Person p){ //Person p = new Man(); 多态的好处：可以省略以下的多种冗余写法

    }

//    public void show(Man m){  //Man p = new Man();
//
//    }
//
//    public void show(Woman w){
//
//    }
}

结果：

人吃饭
人走路
男人多吃点肉
男人笔挺的走路
男人多吃点肉
男人笔挺的走路
女人应该少吃，减肥
女儿窈窕的走路
女人爱购物
男人请客
你好！