java - 基础 - 多态

多态（Polymorphism）：

同一个对象体现出的不同形态，将一种行为体现出不同效果。

实现：父类引用指向子类

 

animal

public class Person extends Animal{

}

Animal a = new Person();

此时a能调用person中的方法

如果父类和子类有相同的属性，调用父类的。

如果子类中重写了父类的方法，则调用的是子类中重写的方法。

如果父类想调用子类独有的方法，需要强制转化

Person  p = （Person）a;

 

package Polymorphism;

public class Animal {

    int age = 1;

    public void setAge(){
        age = 10;
        System.out.println("Animal类中的setAge方法");
    }

}

package Polymorphism;

public class Person extends Animal {

    int age = 2;
    String name;

    public void setName(){
        String name = "aaa";
        System.out.println("Person类中的setName方法");
    }

    public void getName(){
        System.out.println("Person类中的getName方法:name = " + name);
    }

    public void setAge(){
        age = 20;
        System.out.println("Person类中的setAge方法");
    }

    public void getAge(){
        System.out.println("Person类中的getAge方法:age = " + age);
    }
}

 

 

package Polymorphism;

import java.net.SocketTimeoutException;
import java.util.Scanner;

public class Test {

    public static void main(String[] args){
        Animal a = new Person();//多态

        System.out.println(a.age);//如果父类和子类有相同的属性，调用父类的。

        a.setAge();//如果子类中重写了父类的方法，则调用的是子类中重写的方法。

        Person p = (Person) a;//如果父类想调用子类独有的方法，需要强制转化
        p.getAge();


        Object o = new Person();
        Animal aa = null;
        //避免转换异常，可以使用instanceof判断,不能转换（没有继承关系）会直接报错不能编译，如果是 a instanceof b, 且a是b的对象或者子类对象，会返回true
        if(o instanceof Animal){   //o new的是一个Person对象，是animal的子类
            System.out.println("o与Animal可以匹配");
            aa = (Animal)o;//向下强制转换，寻找方法中从Person向父类寻找，Person中有setAge的重写，所以执行的是Person的
            // 能执行的方法和属性是从Animal开始向父类找（必须是Animal或者其父类定义过），执行的方法和属性是从定义时new的Person开始向父类找，有重写的优先运行重写的。
        }
        else{
            System.out.println("o与Animal不匹配");
        }
        System.out.println(a.age);
        aa.setAge();

        Object oo = new Animal();

        if(oo instanceof Person){  //oo声明的是Animal对象，是Person的父类，所以返回false
            System.out.println("oo与Person可以匹配");
        }
        else{
            System.out.println("oo与Person不匹配");
        }

    }
}

 

 

多态的应用：

比如银行取号时，父类为public abstract  class person，子类为不同类型的客户，这样银行可以统一处理客户，而不同客户可以重写他们各自独立的方法。

package Polymorphism.bank;

public abstract class Customer {
    protected String name; //子类可以直接使用

    public abstract void come();
}

package Polymorphism.bank;

public class VIPCustomer extends Customer{

    public VIPCustomer(String name){
        this.name = name;
    }

    public void come(){
        System.out.println("VIP客户" + name + "开始办理业务。");
    }
}

package Polymorphism.bank;

public class CommenCustomer extends Customer{
    public CommenCustomer(String name){
        this.name = name;
    }

    public void come(){
        System.out.println("普通客户" + name + "开始办理业务。");
    }
}

package Polymorphism.bank;

public class Bank {

    public void dealwithCustomer(Customer c){
        c.come();
    }

    public static void main(String[] args){
        Bank b = new Bank();
        Customer vip = new VIPCustomer("王健");  //利用多态对客户进行分类，调用他们重写的方法。
        Customer com = new CommenCustomer("张益");

        b.dealwithCustomer(vip);
        b.dealwithCustomer(com);
    }
}