Java之多态（Polymorphism）与虚方法（Virtual Method）

多态（Polymorphism）

        多态是同一个行为具有多个不同表现形式或形态的能力。

        多态就是同一个接口，使用不同的实例而执行不同操作。

        如：

        现实中，比如我们按下 F1 键这个动作：
        如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
        如果当前在 Word 下弹出的就是 Word 帮助；
        在 Windows 下弹出的就是 Windows 帮助和支持。

        也就是说，同一个事件发生在不同的对象上会产生不同的结果。  

多态的优点

        消除类型之间的耦合关系
        可替换性
        可扩充性
        接口性
        灵活性

        简化性

多态存在的条件

        继承
        重写
        父类引用指向子类对象

        当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

        多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

示例代码如下：    

Test.java  

public class Test {
    public static void main(String[] args) {
        show(new Cow());
        show(new Pig());

        Animal animalOne = new Dog();
        animalOne.eat();
        ((Dog) animalOne).work();
        ((Dog) animalOne).Info("Nick", 5, "公的");
    }

    public static void show(Animal animal) {
        animal.eat();
        if (animal instanceof Cow) {
            Cow cow = (Cow) animal;
            cow.work();
        } else if (animal instanceof Pig) {
            Pig pig = (Pig) animal;
            pig.work();
        }
    }
}

abstract class Animal {
    abstract void eat();
}

class Cow extends Animal {
    public void eat() {
        System.out.println("吃草");
    }

    public static void work() {
        System.out.println("产牛奶");
    }
}

class Pig extends Animal {
    public void eat() {
        System.out.println("吃饲料");
    }

    public static void work() {
        System.out.println("长肥肉");
    }
}

class Dog extends Animal {
    public void eat() {
        System.out.println("吃骨头");
    }

    public static void work() {
        System.out.println("看家");
    }

    public void Info(String name, int age, String sex) {
        System.out.println("狗狗的名字是：" + name);
        System.out.println("狗狗的年龄是：" + age);
        System.out.println("狗狗的性别是：" + sex);
    }
}

运行结果：

吃草
产牛奶
吃饲料
长肥肉
吃骨头
看家
狗狗的名字是：Nick
狗狗的年龄是：5
狗狗的性别是：公的

Process finished with exit code 0

虚方法（Virtual Method）

        当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。
        多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
        我们将介绍在Java中，当设计类时，被重写的方法的行为怎样影响多态性。
        我们已经讨论了方法的重写，也就是子类能够重写父类的方法。
        当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。
        要想调用父类中被重写的方法，则必须使用关键字super。

示例代码如下：

Person.java

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

    public Person(String name, String address, int age, String sex) {
        System.out.println("构造函数");
        this.name = name;
        this.address = address;
        this.age = age;
        this.sex = sex;
    }

    public void hasSomeone() {
        System.out.println("Person_hasSomeone");
        System.out.println("名字叫：" + this.name);
        System.out.println("地址为：" + this.address);
        System.out.println("年龄为：" + this.age);
        System.out.println("性别为：" + this.sex);
    }

    public String toString() {
        return name + " " + address + "" + age;
    }

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String newAddress) {
        address = newAddress;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex(){
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

Salary.java

public class Salary extends Person {
    private double salary;

    public Salary(String name, String address, int age, String sex,double salary) {
        super(name, address, age, sex);
        setSalary(salary);
    }

    @Override
    public void hasSomeone() {
        System.out.println("Salary_hasSomeone");
        System.out.println("您的姓名为：" + getName());
        System.out.println("您的地址为：" + getAddress());
        System.out.println("您的年龄为：" + getAge());
        System.out.println("您的性别为：" + getSex());
        System.out.println("您的工资为：" + getSalary());
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double newSalary) {
        if (newSalary >= 0.0) {
            salary = newSalary;
        }
    }

    public double pay() {
        System.out.println("工资给：" + getName());
        return salary ;
    }
}

VirtualMethodDemo.java

public class VirtualMethodDemo {
    public static void main(String []args){
        Salary salary = new Salary("KT","Buma",22,"F",25000);
        salary.pay();
        salary.hasSomeone();

        Person person = new Person("YZX","Gaoling",24,"M");
        person.hasSomeone();
    }
}

运行结果：

构造函数
工资给：KT
Salary_hasSomeone
您的姓名为：KT
您的地址为：Buma
您的年龄为：22
您的性别为：F
您的工资为：25000.0
构造函数
Person_hasSomeone
名字叫：YZX
地址为：Gaoling
年龄为：24
性别为：M


Process finished with exit code 0

不足之处，请多指教！