基础

Java中的多态是什么？

多态指的是相同类型的变量在调用同一个方法时呈现出多种不同的行为特征。而造成这一现象的原因在于Java中的变量有两个类型：

  • 编译时类型，由声明变量时的类型决定。
  • 运行时类型，由实际赋值给变量的对象的类型决定，当一个变量的两个类型不一致，就会出现多态。 ```java //BaseClass是SubClass的父类 BaseClass a = new BaseClass(); BaseClass b = new SubClass(); a.baseMethod()//变量a调用baseMethod()方法，实际上会调用BaseClass的baseMethod()方法,会打印111 b.baseMethod()//变量b调用baseMethod方法，实际上会调用SubClass的重写baseMethod()方法，会打印222 Class BaseClass { void baseMethod() { System.out.println(“111”); } } Class SubClass { void baseMethod() { System.out.println(“222”); } } 输出结果： 111 222
  1. 例如这个例子中，
  2. <a name="U4SMf"></a>
  3. ##### [对于变量a而言](http://notfound9.github.io/interviewGuide/#/docs/JavaBasic?id=%e5%af%b9%e4%ba%8e%e5%8f%98%e9%87%8fa%e8%80%8c%e8%a8%80)
  4. a的**编译类型是BaseClass**，**实际类型也是BaseClass**，所以调用baseMethod()会执行BaseClass#baseMethod()方法，打印出111。
  5. <a name="ithgr"></a>
  6. ##### [对于变量b而言](http://notfound9.github.io/interviewGuide/#/docs/JavaBasic?id=%e5%af%b9%e4%ba%8e%e5%8f%98%e9%87%8fb%e8%80%8c%e8%a8%80)
  7. b的的**编译类型是BaseClass**，但是实际赋值时，给变量b赋值的是SubClass对象，所以b的**实际类型是SubClass**。而SubClass重写了父类BaseClass#baseMethod()方法，所以调用baseMethod()方法会调用SubClass#baseMethod()，从而打印出222。<br />a和b的编译类型相同，却展现出了不同的行为特征，这就是多态。<br />（PS：如果直接对b调用只有SubClass有的方法，编译时会报错，但是可以通过反射进行调用。）
  8. <a name="c2yb8"></a>
  9. ### [Java中变量，代码块，构造器之间执行顺序是怎么样的？](http://notfound9.github.io/interviewGuide/#/docs/JavaBasic?id=java%e4%b8%ad%e5%8f%98%e9%87%8f%ef%bc%8c%e4%bb%a3%e7%a0%81%e5%9d%97%ef%bc%8c%e6%9e%84%e9%80%a0%e5%99%a8%e4%b9%8b%e9%97%b4%e6%89%a7%e8%a1%8c%e9%a1%ba%e5%ba%8f%e6%98%af%e6%80%8e%e4%b9%88%e6%a0%b7%e7%9a%84%ef%bc%9f)
  10. Java程序中类中个元素的初始化顺序 初始化的原则是：
  12. - 先初始化**静态**部分，再初始化**动态**部分，
  13. - 先初始化**父类**部分，后初始化**子类**部分，
  14. - 先初始化**变量**，再初始化**代码块**和**构造器**。
  16. 所以依照这个规则可以得出总体顺序是：<br />1.父类的静态成员变量（如果是第一次加载类）<br />2.父类的静态代码块（如果是第一次加载类）<br />3.子类的静态成员变量（如果是第一次加载类）<br />4.子类的静态代码块（如果是第一次加载类）<br />5.父类的普通成员变量<br />6.父类的动态代码块<br />7.父类的构造器方法<br />8.子类的普通成员变量<br />9.子类的动态代码块<br />10.子类的构造器方法<br />下面写了一个Demo进行验证:
  17. ```java
  18. public class Base {
  19.     static Instance staticInstance = new Instance("1---Base类的静态成员变量staticInstance");
  20.     static  {
  21.         System.out.println("2---Base类的静态代码块执行了");
  22.     }
  23.     Instance instance = new Instance("5---Base类的普通成员变量instance");
  24.     {
  25.         System.out.println("6---Base类的动态代码块执行了");
  26.     }
  27.     Base() {
  28.         System.out.println("7---Base类的构造器方法执行了");
  29.     }
  30. }
  32. public class Child extends Base {
  33.     static Instance staticInstance = new Instance("3---Child类的静态成员变量staticInstance");
  34.     static  {
  35.         System.out.println("4---Child类的静态代码块执行了");
  36.     }
  37.     Instance instance = new Instance("8---Child类的普通成员变量instance");
  38.     {
  39.         System.out.println("9----Child类的动态代码块执行了");
  40.     }
  41.     Child() {
  42.         System.out.println("10---Child类的构造器方法执行了");
  43.     }
  44.     public static void main(String[] args) {
  45.         Child child = new Child();
  46.     }
  47. }