Java 多态性（概述）

多态性

多态性是发送消息给某个对象，让该对象自行决定响应何种行为。通过将子类对象引用复制给超类对象引用变量来实现动态方法调用

多态形成的三个必要条件：

• 有继承，父类定义方法，子类重写方法

• 父类的引用指向子类的对象 Object obj = new Date();

• 可以使用参数传递时多态，也可以直接创建对象时多态

多态可以用三个定义个两个方法来总结

• 三个定义分别是父类定义子类构建、接口定义实现类构建、抽象类定义实体类构建

• 两个方法分别是方法重载和方法重写

多态分为两种：

• 编译时多态：方法的重载

• 运行时多态：Java运行时系统根据调用该方法的实例的类来决定选择调用哪个方法则被称为运行时多态

变量的两种类型

• 编译期类型

• 运行时类型

public class Test04 {
    public static void main(String[] args) {
        Person p = new Student();
    //如果试图直接调用Student子类中特定的方法，不包含在Person类定义中
    //  p.study();  //语法报错
    }
}
class Person {
    public String toString() {
        String name = "Person";
        return name;
    }
}
​
class Student extends Person {
    public String toString() {
        String name = "Student";
        return name;
    }
    public void study() {
        System.out.println("Student Study");
    }
}

在IDE工具进行编译时系统识别p为Person类型，所以p只能调用Person类中定义的方法。如果Person类中没有定义study方法，则会出现语法报错

//如果需要调用Student类中定义的方法，但是Person父类中并没有定义的方法，则需要强制类型转换
if(p instanceof Student){  //判断p是否为Student类型
    Student s = (Student)p;
    s.study();
}

调用方法时具体执行的是谁的方法

p.toString()执行的是谁的方法？

public class Test04 {
    public static void main(String[] args) {
        Person p = new Student();
        System.out.println(p.toString());  //返回结果为  Student
        System.out.println(((Student)p).getName());//此例中Person类型要引用Student类的实例，因Person中未定义getName()方法，故需要把Person类显式地转换为Student类，然后调用Student中的getName方法。
    }
}
​
class Person {
    public String toString() {
        String name = "Person";
        return name;
    }
}
​
class Student extends Person {
    public String toString() {
        String name = "Student";
        return name;
    }
    public String getName() {
        int age = 18;
        return age;
    }
}

Java支持运行时多态，意为p.toString()实际执行p所引用实例的toString()，究竟执行Person类还是Man类的方法，运行时再确定。如果Man类声明了toString()方法，则执行之；否则执行Person类的toString()方法。

程序运行时，Java从实例所属的类开始寻找匹配的方法执行，如果当前类中没有匹配的方法，则沿着继承关系逐层向上，依次在父类或各祖先类中寻找匹配方法，直到Object类。

父类对象只能执行那些在父类中声明、被子类覆盖了的子类方法，如toString()，不能执行子类增加的成员方法。

//接着上边的例子
public class Test04 {
    public static void main(String[] args) {
        Person p = new Person();  
        System.out.println(p.toString());  //返回结果为Person
        Student s = new Student(); 
        //调用子类中所定义的方法  这个方法可以是继承来的，也可以是自定义的  
        System.out.println(s.toString());  //返回结果为 Student
    }
}

将例子中Person和Student中的方法换成静态的会是什么结果？

public class Test04 {
    public static void main(String[] args) {
        Person p = new Student();
        System.out.println(p.attribute);  //返回结果为  p
        System.out.println(p.getName());  //返回结果为  Person
    }
}
​
class Person {
    String attribute = "p";
​
    public static String getName() {
        String name = "Person";
        return name;
    }
}
​
class Student extends Person {
    String attribute = "m";
​
    public static String getName() {
        String name = "Student";
        return name;
    }
}

所谓静态，就是在运行时，虚拟机已经认定此方法属于哪个类。“重写”只能适用于实例方法，不能

用于静态方法。对于静态方法，只能隐藏，重载，继承。

   子类对于父类静态方法的隐藏(hide)，子类的静态方法完全体现不了多态，就像子类属性隐藏父类属性一样，在利用引用访问对象的属性或静态方法时，是引用类型决定了实际上访问的是哪个属性，而非当前引用实际代表的是哪个类。因此，子类静态方法不能覆盖父类的静态方法。 

    父类中属性只能被隐藏，而不能被覆盖；而对于方法来说，方法隐藏只有一种形式，就是父类和子类存在相同的静态方法。

多态性通过允许同一界面指定一类动作减少了程序的复杂度，编译器工作就是选择适用于各个情况的特定动作，而 程序员无需手动进行选择，使用者仅仅是记得以及利用这个统一的界面

变量的声明

父类 obj = new 子类();

将子类对象赋值给父类引用变量时，可以称之为向上类型转换，向上类型转换永远可以成功，不需要进行类型判断。同时也证明了子类实际上就是一种特殊的父类

指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而

父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方

法，在调用该些方法的时候，必定是使用子类中定义的这些方法

**指向子类的父类引用由于向上转型了，它只能访问父类中拥有的方法和属性，而对于子类中存在而父类中不存在的方法，该引用是不能使用的，尽管是重载该方法。若子类重写了父类中的某些方法，在调用该些方法的时候，必定是使用子类中定义的这些方法（动态连接、动态调用）

类内多态

要求：方法名称相同，但是参数不同

• 在Java类中唯一确定一个方法，至少需要两个参数

  • 方法名称

  • 参数类型列表

  • 和返回类型无关，和参数名称无关

• 重载

  • 参数个数不同

  • 参数类型不同

  • 参数顺序不同

class Person{  //重载可以是在一个类中，也可以在父子类中
    public void pp(){}
    public void pp(int age){}
    public void pp(String name){}
    public void pp(int age,String name){}
    public void pp(String name,int age){}
}

• 方法重载进行调用时，按照最佳匹配原则选择需要调用的方法

public void pp(Integer kk){}
public void pp(Object kk){}
public int pp(Long kk){}  
​
pp(123);   //调用方法时，传入的参数和方法中的参数最佳匹配决定调用那个方法