1. class A//加载子类前会先加载父类。
   
2. {
   
3.         B b = new B();
   
4.         A() //加载时会执行构造函数么？
   
5.         {
   
6.                 System.out.print("A");
   
7.         }
   
8.         
   
9.         
   
10. }
    
11. 
    
12. class B
    
13. {
    
14.         B()
    
15.         {
    
16.                 System.out.print("B");
    
17.         }
    
18.         static
    
19.         {
    
20.                 System.out.print("静态代码块");
    
21.         }
    
22. }
    
23. 
    
24. 
    
25. class C extends A
    
26. {
    
27.         B b = new B();
    
28.         C()
    
29.         {
    
30. 
    
31.                 System.out.print("C");
    
32.         }
    
33. 
    
34.         public static void main(String[] args)
    
35.         {
    
36.                 new C();
    
37.         }
    
38. }
    

复制代码

class A//加载子类前会先加载父类。  是的，类初始化阶段加载类之前java会先加载父类并先初始化父类的静态初始化块，
//然后依次向下直到执行当前类的静态初始化块
{
        B b = new B();
        A() //加载时会执行构造函数么？//会，对象初始化阶段  会先执行父类的初始化块、和构造器    然后依次向下直到执行到当前类的初始化块、和构造器
  {
                System.out.print("A");
        }

        }
总结:类加载初始化过程 一个类加载进内存会进行以下两步
1.类初始化阶段:先初始化父类的静态初始化块，然后依次向下直到执行当前类的静态初始化块
2.对象初始化阶段：先执行父类的初始化块、和构造器    然后依次向下直到执行到当前类的初始化块、和构造器

1.类初始化过程：首先会加载父类，并先初始化父类的静态初始化，即

1. static
   
2.          
   
3.                 {
   
4.          
   
5.                         System.out.print("静态代码块");
   
6.          
   
7.                 }

复制代码

然后根据顺序向下执行当前类的静态初始化代码块。
2.对象的初始化：先执行父类的初始化块和构造函数，即

1. B()
   
2.                 {
   
3.          
   
4.                         System.out.print("B");
   
5.          
   
6.                 }

复制代码

然后在依次执行

1. A()
   
2.          
   
3.                 {
   
4.          
   
5.                         System.out.print("A");
   
6.          
   
7.                 }

复制代码

1. B()
   
2.                 {
   
3.          
   
4.                         System.out.print("B");
   
5.          
   
6.                 }

复制代码

1. C()
   
2.                 {
   
3.          
   
4. 
   
5.                         System.out.print("C");
   
6.          
   
7.                 }

复制代码

所以肯定会先执行父类的构造函数

问题已解决