Java多态讲解（1）

多态是什么？

指同一个实体同时具有多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

这么说太抽象了。

我们从头开始讲起：

Java引用变量有两种类型，一个是编译时的类型，一个是运行时的类型。

一般来说，对象的创建是这样的：

类型1 变量 = new 类型1（）；

编译类型由声明该变量时使用的类型决定，运行时类型由实际赋值给该变量的值决定。

等号左边的是编译时的类型，等号右边是运行时的类型。

如果编译类型和运行类型不一致，就会出现所谓的多态。

类型1 变量 = new 类型2（）；

多态的三个条件：

1. 有类的继承
2. 有方法的重写
3. 有父类的变量指向子类的对象

（变量存储的是对象资源的地址）

多态的本质就是通过父类的引用变量来引用子类的对象，并根据具体的对象类型执行相应的方法，从而实现动态绑定的机制。

注意：如果没有继承和重写这两个特性，多态就无法实现。

如果没有继承，父类和子类之间就没有任何关系，也就无法使用父类的引用来引用子类的对象。

如果没有重写，父类和子类之间就没有相同的方法名，更无法通过父类的引用来调用子类的方法。

因此，可以说在Java中，类的继承和方法的重写是多态实现的必要条件。

在访问成员变量和成员方法的时候，分情况来讲解：

1. 如果访问的是成员方法，编译时期向左看，运行时期向右看。
2. 如果访问的是成员变量，编译时期向左看，运行时期向左看。
3. 如果访问的是静态方法，编译时期向左看，运行时期向左看。

测试一 如果访问的是成员方法，编译时期向左看，运行时期向右看。

public class  ReviewDuoTai{
    public static void main(String[] args) {
Animal01 c1 = new Dog01();//有父类的引用变量指向子类的对象
c1.show();
    }
        }


class Animal01{
  public void show(){
      System.out.println("父类方法");
  }
}

class Dog01 extends Animal01{//有类的继承
    @Override
    public void show() {
        System.out.println("子类方法");//有方法的重写
    }
}

输出的结果是

子类方法

在Java当中，方法多态是最常见也是最具有代表性的表现形式。

当一个父类引用变量调用子类对象的方法时，Java会根据这个父类引用变量所指向的子类类型来执行对应的方法实现。

尽管animal的编译时类型是Animal类，但实际对象是Dog类型的实例，因此调用c1.show()时，实际调用的是Dog类中定义的方法，输出结果是"子类方法"。这就是方法的动态绑定，实现了运行时多态性。

测试二 如果访问的是成员变量，编译时期向左看，运行时期向左看。

class Animal01{
  int a = 1000;
}

class Dog01 extends Animal01{
    int a = 100;
}//在子类和1父类里都定义成员变量

public class  ReviewDuoTai{
    public static void main(String[] args) {
Animal01 c1 = new Dog01();
        System.out.println(c1.a);
    }
        }//引用成员变量

输出结果是1000

因为成员变量不具有多态性，不同于方法的动态绑定，成员变量的访问在编译时就已经确定了。

即使实际对象是Dog01类型，c1.a仍然会访问Animal01类中定义的a成员变量，而不是Dog01类中定义的a成员变量，因为c1的编译时类型是Animal01。

头脑风暴：成员变量不具有多态性，是由于成员变量的访问在编译时期就已经确定了。在Java中，成员变量是直接绑定到类上的，而不是绑定到对象上。

引用变量只是一个指向对象的指针，其类型决定了它所能够访问的成员变量，与实际对象的类型无关。因此，子类中定义的成员变量并不能够覆盖父类中的同名成员变量，而是简单地隐藏了父类中的同名成员变量。

相反的，方法具有动态绑定的特性。动态绑定是指，在运行时根据实际对象类型确定调用哪个方法的过程。

如果子类中定义了与父类同名的方法，并且子类对象通过该方法进行调用，那么将会执行子类中的方法，而不是父类中的方法。这就是方法的动态绑定。

总之，Java中的成员变量不具有多态性，而方法具有动态绑定的特性。方法的动态绑定是指，在运行时根据实际对象类型确定调用哪个方法的过程。

测试三 如果访问的是静态方法，编译时期向左看，运行时期向左看

public class  ReviewDuoTai{
    public static void main(String[] args) {
Animal01 c1 = new Dog01();
    c1.show();
       
    }
        }

 class Animal01{
   public static void show(){
       System.out.println("动物叫");
   }
 }

 class Dog01 extends Animal01{
    public static void show(){
        System.out.println("狗狗叫");
    }
 }

输出结果是动物叫。

为什么？

等号左边是类资源，右边是对象资源。

静态方法可以通过类名直接调用，（成员方法需要先创建类的实例对象，然后通过该对象来调用。）静态方法和静态变量是属于类的，而不是属于具体实例对象的。它们在类被加载时就会被分配内存，即使没有创建任何实例对象，它们也可以被访问和使用。

因此，静态方法是类资源不是对象资源，通过类的加载优先加载到内存中，直接找到的是Animal类。

因此，谁调用静态资源就执行谁的方法。

补充知识：

Java中静态方法和成员方法的区别主要体现在以下几个方面：

1.调用方式不同

静态方法可以通过类名直接调用，成员方法需要先创建类的实例对象，然后通过该对象来调用。

2.内存分配不同

静态方法和静态变量是属于类的，而不是属于具体实例对象的。它们在类被加载时就会被分配内存，即使没有创建任何实例对象，它们也可以被访问和使用。而成员方法和成员变量则必须在创建实例对象之后才能被访问和使用。

3.作用域不同

静态方法和静态变量的作用域是整个类，所有的对象都可以共享访问。而成员方法和成员变量则属于具体的实例对象，每个对象拥有自己独立的一份。

4.访问权限不同

静态方法只能直接访问静态成员变量或调用其他的静态方法，不能直接访问非静态的成员变量或调用非静态的成员方法。而成员方法则可以直接访问属于该对象的成员变量和方法。

下篇文章，我们用一个案例说明多态是如何发挥作用的。