JavaSE多态

多态：一个对象在不同条件下表示的不同形态就叫多态。在程序中，多态是父类引用指定子类对象就叫多态。

多态是面向对象程序设计中的第三个特征

// 多态
class Father {
    String name;
    public void desc() {
        System.out.println("----------");
        System.out.println(name + "小头爸爸");
    }
}
class Son extends Father {
    String name;
    public void desc() {
        System.out.println("+++++++++++++");
        System.out.println(name + "大头儿子");
    }
}

public class PolymorphicDemo1 {
    public static void main(String[] args) {
        Father father = new Son();
        father.name = "大头儿子";
        father.desc();
    }
}

另一种多态的使用方式是在方法的参数上，一般我们在使用工厂设计模式时会使用多态。

在参数列表上，使用父类去接收，它也是一种多态的使用方式。

abstract class Animal {
    abstract void haha();
}
class Cat extends Animal {
    @Override
    void haha() {
        System.out.println("Cat haha()");
    }
}
class Dog extends Animal {
    @Override
    void haha() {
        System.out.println("Dog haha()");
    }
}

class HelloKit {
    public static Animal create(Animal animal) {
        if (animal instanceof Cat) {
            return new Cat();
        }else if (animal instanceof Dog) {
            return new Dog();
        } else {
            return null;
        }
    }
}
public class HelloKitDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();
        Dog dog = new Dog();

        Animal animal = HelloKit.create(cat);
        animal.haha();

        Animal animal1 = HelloKit.create(dog);
        animal1.haha();

    }
}

使用多态的注意事项

1）在多态的情况下，不能使用子类特有的方法。

class Person {
    public int age = 5;
    public void show() {
        System.out.println("Person age: " + age);
    }
}
class Student extends Person {
    public int age = 10;
    public String name = "小明";
    public void show() {
        System.out.println("Student age: " + age);
    }
    public void speak() {
        System.out.println(name);
    }
}

public class PolymorphicDemo2 {
    public static void main(String[] args) {
        Person p = new Student();
        p.show(); // 可以执行
        p.speak(); // 报错，因为 speak 方法是子类特有的方法
    }
}

2）多态在实例时如果属性是非静态的，它的值是看等号的左边

// 多态的注意事项
class Person {
    public int age = 5;
    public void show() {
        System.out.println("Person age: " + age);
    }
}
class Student extends Person {
    public int age = 10;
    public String name = "小明";
    public void show() {
        System.out.println("Student age: " + age);
    }
    public void speak() {
        System.out.println(name);
    }
}

public class PolymorphicDemo2 {
    public static void main(String[] args) {
        Person p = new Student();
        System.out.println(p.age); // 5 ，是不是 10
    }
}

原因：我们使用的是多态，也就是说我们输出的 p.age ，而 p 是父为的引用，它获取到的值就是父类中定义的值。

在多态下，编译是看等号的左边，运行时如果是属性则看等号左边。

3）在多态下的非静态方法

// 多态的注意事项
class Person {
    public int age = 5;
    public void show() {
        System.out.println("Person age: " + age);
    }
}
class Student extends Person {
    public int age = 10;
    public String name = "小明";
    public void show() {
        System.out.println("Student age: " + age);
    }
}

public class PolymorphicDemo2 {
    public static void main(String[] args) {
        Person p = new Student();
        p.show();
    }
}

在多态下，编译是看等号的左边，运行时如果方法是非静态的看等号的右边

4）在多态下的静态成员

// 多态的注意事项
class Person {
    public static void x() {
        System.out.println("Person static x");
    }
}
class Student extends Person {
    public static void x() {
        System.out.println("Student static x");
    }
}
public class PolymorphicDemo2 {
    public static void main(String[] args) {
        Person p = new Student();
        p.x(); // Person static x
    }
}

在多态下，静态的成员在编译和运行时都看等号的左边