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

逃离我推掉我的手 2022-05-21 11:39 100阅读 0赞

### 多态（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

不足之处，请多指教！