面向对象特征之多态性

面向对象的多态性：

1.多态性理解为一个事物多种表现形态

  ①. 方法的重载与重写为多态性的表现

  ②.子类对象的多态性

2.子类对象的多态性使用的前提：①要有类的继承

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

3.程序运行分为编译状态和运行状态。

                  对于多态性来说，编译时，看左边，将此引用变量理解为父类的类型

                  运行时，看右边，关注对象的实体：子类的对象，那么执行的方法就是子类重写的。

4.子类对象的多态性，并不适用于属性

// instanceof:
// 格式：对象a instanceof 类A :判断a是否是类A的一个实例，是的话，返回true，否则返回false
// 若a是A的实例， 那么a也一定是A类的父亲的实例

Person：

package com.aff.java1;

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

    public Person() {
        super();
    }

    public Person(String name, int age) {
        super();
        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.aff.java1;

public class Man extends Person {
    private boolean smoking;

    public Man() {
        super();
    }

    public Man(String name, int age) {
        super(name, age);
    }

    public boolean isSmoking() {
        return smoking;
    }

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

    public void walk() {
        System.out.println("直走");
    }

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

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

}

Woman：

package com.aff.java1;

public class Woman extends Person {
    private boolean beauty;

    public Woman(boolean beauty) {
        super();
        this.beauty = beauty;
    }

    public Woman() {
        super();
    }

    public boolean isBeauty() {
        return beauty;
    }

    public void setBeauty(boolean beauty) {
        this.beauty = beauty;
    }

    public void walk() {
        System.out.println("慢走");
    }

    public void eat() {
        System.out.println("吃水果");
    }

    public void shooping() {
        System.out.println("购物");

    }
}

TestPerson：

package com.aff.java1;

public class TestPerson {
    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();// 吃菜 直走 输出的为 new man

        // p1.entertainment(); 调不出来的 应为没有继承 person没有这个方法

        Person p2 = new Woman();
        p2.eat();
        p2.walk();
        // p2.shooping(); 同理调用不了，但是可以使用向下转型

        // 这样理解 父类的为上 ， 子类为下
        Woman w = (Woman) p2;// 向下转型， 父类person转换为woman了
        w.shooping();

        // instanceof:
        // 格式：对象a instanceof 类A :判断a是否是类A的一个实例，是的话，返回true，否则返回false
        // 若a是A的实例， 那么a也一定是A类的父亲的实例
        if (p1 instanceof Woman) {
            System.out.println("能进来");
            Woman w1 = (Woman) p1;
            w1.shooping();
        }
        if (p1 instanceof Man) {
            Man m1 = (Man) p1;
            m1.entertainment();
        }
        if (p1 instanceof Person) {
            System.out.println("进来了");
        }
    }
}