类中能存放的元素有属性,方法,代码块,构造器(注释我还没学习暂时不考虑).当一个对象第一次被使用时,类加载器会加载这个类,根据类加载器的全盘委托机制会将这个类所有依赖的类一起加载,比如这个类的父类和这个类中含有的属性所属的类,那么加载的实际顺序到底是怎么样的呢,下面通过代码来说明:
A类当中含有静态属性,实例属性,静态块,实例块,静态方法,实例方法,以及构造器.

1. class A {
   
2.         public static String staticA = "父类静态属性";
   
3.         public String insA = "父类实例属性";
   
4.         static {
   
5.                 sayStaticA();
   
6.                 System.out.println("父类静态块被加载了");
   
7.         }
   
8.         {
   
9.                 sayInsA();
   
10.                 System.out.println("父类实例块被加载了");
    
11. 
    
12.         }
    
13. 
    
14.         public static void sayStaticA() {
    
15.                 System.out.println(staticA + "被加载了\n" + "父类静态方法被加载了");
    
16.         }
    
17. 
    
18.         public void sayInsA() {
    
19.                 System.out.println(insA+"被加载了\n"+"父类实例方法被加载了");
    
20.         }
    
21. 
    
22.         public A() {
    
23.                 System.out.println("父类构造器被加载了");
    
24.         }
    
25. }
    

复制代码

测试代码如下:

1.         public static void main(String[] args) {
   
2.                 A a=new A();
   
3.         }
   

复制代码

控制台输出如下:

1. 父类静态属性被加载了
   
2. 父类静态方法被加载了
   
3. 父类静态块被加载了
   
4. 父类实例属性被加载了
   
5. 父类实例方法被加载了
   
6. 父类实例块被加载了
   
7. 父类构造器被加载了

复制代码

可以清楚的看到类加载器按照静态属性,静态方法,静态块,实例属性,实例方法,实例块,构造器的顺序创建对象.
接下来设计一个继承A类的子类B,也拥有属于自己静态属性,实例属性,静态块,实例块,静态方法,实例方法,以及构造器,代码如下.

1. class B extends A {
   
2.         public static String staticB = "子类静态属性";
   
3.         public String insB = "子类实例属性";
   
4.         static {
   
5.                 sayStaticB();
   
6.                 System.out.println("子类静态块被加载了");
   
7.         }
   
8.         {
   
9.                 sayInsB();
   
10.                 System.out.println("子类实例块被加载了");
    
11. 
    
12.         }
    
13. 
    
14.         public static void sayStaticB() {
    
15.                 System.out.println(staticB + "被加载了\n" + "子类静态方法被加载了");
    
16.         }
    
17. 
    
18.         public void sayInsB() {
    
19.                 System.out.println(insB+"被加载了\n"+"子类实例方法被加载了");
    
20.         }
    
21. 
    
22.         public B() {
    
23.                 System.out.println("子类构造器被加载了");
    
24.         }
    
25. }

复制代码

测试代码如下:

1.         public static void main(String[] args) {
   
2.         /*        A a=new A();*/
   
3.                 B b=new B();
   
4.         }

复制代码

控制台输出如下:

1. 父类静态属性被加载了
   
2. 父类静态方法被加载了
   
3. 父类静态块被加载了
   
4. 子类静态属性被加载了
   
5. 子类静态方法被加载了
   
6. 子类静态块被加载了
   
7. 父类实例属性被加载了
   
8. 父类实例方法被加载了
   
9. 父类实例块被加载了
   
10. 父类构造器被加载了
    
11. 子类实例属性被加载了
    
12. 子类实例方法被加载了
    
13. 子类实例块被加载了
    
14. 子类构造器被加载了

复制代码

通过输出结果可知:
1.当实例化一个对象时,如果该对象的类还没被类加载器加载过,那么类加载器会先将其依赖的类先加载出来.
2.第一次实例化子类对象的顺序为:父类的静态元素,子类的静态元素,父类的实例元素,父类构造器,子类的实例元素,子类构造器.(此处的元素指属性,方法,代码块).子类的构造方法中默认调用了父类的构造方法.
3.子类构造方法中默认调用了父类的无参构造方法.

好好  总结的不错哦  加油1