10-初始化对于类与接口的异同点深入解析

初始化对于类与接口的异同点深入解析

• ★★★当java虚拟机初始化一个类时，要求它的所有父类都已经被初始化，但是，这条规则并不适用于接口

  • （1）在初始化一个类时，并不会先初始化它所实现的接口。【往下有证明】

  • （2）在初始化一个接口时，并不会先初始化它的父接口。【往下有证明】

    • 因此，一个父类接口并不会因为它的子接口或者实现类的初始化而初始化。只有当程序首次使用特定接口的静态变量时，才会导致该接口的初始化。

  • **所以，上面的两种情况对于实例一、实例二是对的，因为这个结论本身就是对应于：在接口中声明一个常量，而且这个常量在编译期就可以完全确定好具体数值的话，压根就不会加载这个接口。**而实例三是在编译器常量值不可以确定的情况。

  • 实例一：

    public class MyTest5 {
        public static void main(String[] args) {
            System.out.println(MyChild5.b);
        }
    }
    interface MyParent5{
        public static int a = 6;
    }
    interface MyChild5 extends MyParent5{
        public static int b = 5;
    }
    运行结果：
    

**结果分析：**

​		**可以看到，这里只有MyTest5被加载了，也就是MyParent5连加载都没有，更别说初始化了，得到的 5  是从常量池中获取的。**

• 实例二：

  public class MyTest5 {
      public static void main(String[] args) {
          System.out.println(MyChild5.b);
      }
  }
  interface MyParent5{
      public static int a = 6;
  }
  class MyChild5 implements MyParent5{
      public static int b = 5;
  }
  

  • 将interface MyChild5 改为 class MyChild5，再看运行结果：
    
    • 这个时候看到，MyChild5、MyParent5都被加载了，并且当你删除MyParent5的class文件一定会加载失败！！[因为对于class说：public static int b=5 不是一个常量，没有被final修饰，因此不会加载到常量池中，但是，将public static int b = 5改为public static final int b= 5，则该常量会被放到常量池中，进而不会对MyChilad5进行加载，也就说不会加载MyParent5。而在接口中，定义的常量，默认就是final的，所以会直接被加载到常量池中]

• 实例三：【读到这里的小伙伴可以一块讨论一下下面这种情况】

  public class MyTest5 {
      public static void main(String[] args) {
          System.out.println(MyChild5.b);
      }
  }
  interface MyParent5{
      public static int a = 6;
  }
  interface MyChild5 extends MyParent5{
      public static final int b = new Random().nextInt(3);
  }
  

  • 此运行结果会导致MyParnt5、Mychild5都被加载：
    
    但是，当我删除MyParnt5的class文件时，报错！说明MyParnt5需要被初始化。【首先Mychild5一定会被初始化，因为b = new Random().nextInt(3)，在运行时才确定值。】
    

• 题外话"代码块"

  • 实例一：

    public class StaticLump {
        public static void main(String[] args) {
            new C();
            new C();
        }
    }
    class C{
        public C(){
            System.out.println("C");
        }
        {
            System.out.println("Hello");
        }
    }
    运行结果：
          Hello
          C
          Hello
          C
    

  • 实例二：

    public class StaticLump {
        public static void main(String[] args) {
            new C();
            new C();
        }
    }
    class C{
        public C(){
            System.out.println("C");
        }
        static {
            System.out.println("Hello");
        }
    }
    运行结果：
          Hello
          C
          C
    

  • 总结：

    • ①代码块在类中的位置并不会改变其"最先"被执行的结果，不论是否由static修饰。
    • ②static修饰的静态代码块只会被执行一次[在构造方法执行之前]，不被修饰的则在每一次类被初始化时构造方法之前都没执行一次。

• 证明：（1）在初始化一个类时，并不会先初始化它所实现的接口。

  public class MyTest5 {
      public static void main(String[] args) {
          System.out.println(MyChild5.b);
      }
  }
  interface MyParent5{
      public static Thread thread = new Thread(){
          {
              System.out.println("MyParent5 invoked");
          }
      };
  }
  class MyChild5 implements MyParent5{
      public static int b = 5;
  }
  

  运行结果：说明，首先MyParent5、MyChild5被加载，MyChild5被初始化了(因为public static int b = 5;不是静态变量)，如果MyParent5被初始化了，那么{…}代码一定会在构造方法之前被输出，这里没有输出，则证明：在初始化一个类时，并不会先初始化它所实现的接口。
  

• 证明：（2）在初始化一个接口时，并不会先初始化它的父接口。

  public class MyTest5 {
      public static void main(String[] args) {
          System.out.println(MyParent5_1.thread);
      }
  }
  interface MyGrandpa5_1{
      public static Thread thread = new Thread(){
          {
              System.out.println("MyParent5 invoked");
          }
      };
  }
  interface MyParent5_1 extends MyGrandpa5_1{
      public static Thread thread = new Thread(){
          {
              System.out.println("MyParent5 invoked");
          }
      };
  }
  

  运行结果：说明，首先MyGrandpa5_1、MyParent5_1被加载，MyParent5_1被初始化了（因为打印了：System.out.println(“MyParent5_1 invoked”);），如果MyGrandpa5_1被初始化了，那么对应的{…}代码一定会在构造方法之前被输出，这里没有输出，则证明：在初始化一个接口时，并不会先初始化它的父接口。