Java初学-多态

Java初学6.6.2-多态的应用

多态数组：数组定义类型为父类类型，里面的保存的实际元素为子类类型。

在Java中，多态数组是一个强大的特性，它允许你定义一个数组，其元素类型为某个基类（父类），但实际存储的是该基类的子类实例。这利用了Java的向上转型（upcasting），即子类对象可以被赋值给父类引用。

下面是一个使用多态数组的例子，先定义一个基类 Animal 和两个子类 Dog 和 Cat，并且每个类都有一个 speak 方法：

public class Animal {

    public void speak() {

        System.out.println("Some generic animal sound");

    }

}

public class Dog extends Animal {

    public void speak() {

        System.out.println("Woof!");

    }

}

public class Cat extends Animal {

    public void speak() {

        System.out.println("Meow!");

    }

}

接下来，可以创建一个 Animal 类型的数组，并在其中存储 Dog 和 Cat 实例：

public class Main {

   public static void main(String[] args) {

        Animal[] animals = new Animal[2]; // 定义一个Animal类型的数组

        animals[0] = new Dog(); // 存储Dog实例

        animals[1] = new Cat(); // 存储Cat实例

        for (int i=0;i<animals.length;i++) {

            Animals[i].speak(); // 调用speak方法，这里体现了多态性

        }

    }

运行上述代码，输出：

Woof!

Meow!

在这个例子中，虽然数组的声明类型是 Animal，但我们可以将 Dog 或 Cat 实例存储在数组中。当我们通过数组遍历并调用 speak 方法时，实际上调用的是每个对象的特定实现，而不是 Animal 类中的默认实现。这就是多态性的体现：相同的调用在运行时会表现出不同的行为，具体取决于对象的实际类型。

package PolyMorphicTest;

public class PolyTest0003 {
    public static void main(String[] args){
        PolyTest0003A[] p = new PolyTest0003A[5];
        p[0] = new PolyTest0003A("与姜昆",22);
        p[1] = new PolyTest0003B("帐篷非",23,59);
        p[2] = new PolyTest0003B("勺子长",22,59.9);
        p[3] = new PolyTest0003C("坚毅许安",23,19820);
        p[4] = new PolyTest0003C("大帅哥",18,120000);
        //编译类型都是PolyTest0003A,运行类型A，B,B,C,C。
        /*p[0].printPolyTest0003();
        p[1].printPolyTest0003();
        p[2].printPolyTest0003();
        p[3].printPolyTest0003();
        p[4].printPolyTest0003();*/
        //循环遍历数组：
        for(int i=0;i<p.length;i++){
            p[i].printPolyTest0003();//动态绑定机制。

        }
        //调用子类中的特有方法，需要使用向下转型。
        if (p[1] instanceof PolyTest0003B) {
            /*PolyTest0003B x = (PolyTest0003B) p[1];
            x.uniquePolyTest0003B();等价于：*/
            ((PolyTest0003B) p[1]).uniquePolyTest0003B();
        }
        if (p[3] instanceof PolyTest0003C) {
            ((PolyTest0003C) p[3]).uniquePolyTest0003C();
        }
    }
}
class PolyTest0003A {
    private String name;
    private int age;
    public PolyTest0003A(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 printPolyTest0003() {
        System.out.print(getName() +" " + getAge() + " ");
    }
}
class PolyTest0003B extends PolyTest0003A {
    private double score;
    public PolyTest0003B(String name, int age, double score) {
        super(name, age);
        this.score = score;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    public void printPolyTest0003() {
        super.printPolyTest0003();
        System.out.println(getScore());
    }
    public void uniquePolyTest0003B() {
        System.out.println("嘻嘻~");
    }
}
class PolyTest0003C extends PolyTest0003A {
    private double salary;
    public PolyTest0003C(String name, int age, double salary) {
        super(name, age);
        this.salary = salary;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public void printPolyTest0003() {
        super.printPolyTest0003();
        System.out.println(getSalary());
    }
    public void uniquePolyTest0003C() {
        System.out.println("哈哈~");
    }

}

多态参数：在Java中，多态参数主要通过两种方式实现：方法重载（overloading）和方法重写（overriding）。然而，在讨论多态参数时，我们通常指的是后者，即方法重写，因为这直接涉及到对象的多态性和动态绑定。

方法重写（Overriding）实现多态参数

方法重写发生在子类中，子类可以重写（override）从父类继承的方法。这意味着子类提供了自己版本的实现，这个实现可以有不同的行为。当我们通过父类类型的引用调用一个方法时，实际执行的是由引用所指向的对象类型所定义的方法，这就是动态绑定（dynamic binding）。

class Animal {

    void makeSound() {

        System.out.println("Some generic sound");

   }

}

class Dog extends Animal {

    @Override

    void makeSound() {

        System.out.println("Woof!");

    }

}

class Cat extends Animal {

    @Override

    void makeSound() {

        System.out.println("Meow!");

    }

}

public class Main {

    public static void main(String[] args) {

        Animal myAnimal = new Animal();

        Animal myDog = new Dog();

        Animal myCat = new Cat();

        makeSound(myAnimal);

        makeSound(myDog);

        makeSound(myCat);

    }

   public static void makeSound(Animal animal) {

        animal.makeSound();

    }

}

在上述代码中，makeSound 方法是多态的，因为它接受一个 Animal 类型的参数。当我们通过 makeSound 方法传递 Dog 或 Cat 对象时，实际执行的是这些子类重写后的方法，而不是 Animal 类中的方法。这是因为Java使用动态绑定，调用哪个方法取决于运行时对象的实际类型。

package PolyMorphicTest;
public class PolyTest0004 {
    public static void main(String[] args) {
        NormalEmployee n = new NormalEmployee("浴巾阿坤",16000);
        System.out.println(n.getSalary());
        Manager m = new Manager("勺子啊擦",300,900);
        System.out.println(m.getSalary());
        /*PolyTest0004 polyTest0004 = new PolyTest0004();//如果一个方法不是静态的（即没有使用 static 关键字声明），那么它必须通过一个类的实例来调用。
        polyTest0004.show(n);
        polyTest0004.show(m);
        polyTest0004.show01(n);
        polyTest0004.show01(m);*/
        PolyTest0004.show(n);
        PolyTest0004.show(m);
        PolyTest0004.show01(n);
        PolyTest0004.show01(m);
    }
        /*public void show(PolyTest0004Employee a){
             a.getSum();
        }
        public void show01(PolyTest0004Employee a){
        if(a instanceof NormalEmployee){
            ((NormalEmployee) a).NormalWork();
        }else if(a instanceof Manager){
            ((Manager) a).Manage();
        }
        }*/
        public static void show(PolyTest0004Employee a){
            a.getSum();
        }
//将这些方法设置为静态的，那么在 main 方法中，不再需要创建 PolyTest0004 的实例，而是可以直接调用这些静态方法。
    public static void show01(PolyTest0004Employee a){
        if(a instanceof NormalEmployee){
            ((NormalEmployee) a).NormalWork();
        } else if(a instanceof Manager){
            ((Manager) a).Manage();
        }
    }

}
class PolyTest0004Employee {
    private String name;
    private double  salary;
    public PolyTest0004Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
    public String getName() {
        return name;
    }
    public double getSalary() {
        return salary;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public void getSum(){
        System.out.println(16 * getSalary());
    }
}
class NormalEmployee extends PolyTest0004Employee {
    public NormalEmployee(String name, double salary) {
        super(name, salary);
    }
    public void getSum(){
        System.out.println(getName() + ": Normal Employee Salary " + 12 * getSalary());
    }
    public void NormalWork(){
        System.out.println("Normal Work ");
    }
}
class Manager extends PolyTest0004Employee {
    private double bonus;
    public Manager(String name, double salary, double bonus) {
        super(name, salary);
        this.bonus = bonus;
    }
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    public void getSum(){
        System.out.println(getName() + ": Manager Salary " + 14 * getSalary() + "+" + getBonus());
    }
    public void Manage(){
        System.out.println("Manager Work ");
    }
}