1. 
   
2. public class Test1 {
   
3.         public static void main(String[] args) {
   
4.                 A a = new A();
   
5.                 B b = new B();
   
6.                 C c = new C();
   
7.                 D d = new D();
   
8.         }
   
9. }
   
10. 
    
11. class A{
    
12.         A(){
    
13.                 System.out.println("A");
    
14.         }
    
15. }
    
16. 
    
17. class B{
    
18.         B(){
    
19.                 System.out.println("B");
    
20.         }
    
21. }
    
22. 
    
23. class C{
    
24.         C(){
    
25.                 System.out.println("c");
    
26.         }
    
27. }
    
28. 
    
29. class D{
    
30.         D(){
    
31.                 System.out.println("D");
    
32.         }
    
33. }
    

复制代码

如上，类加载器是一次性把A B C D全部加载，还是用到哪个类就加载哪个类？？如能把你们的测试方法也添上来那就更完美了...

个人认为，你的示例代码中的类的加载顺序是按照代码的执行顺序加载的，就是用到哪个类才加载哪个类。
Java中的类大致分为三种：
1 系统类；
2 扩展类；
3 程序员自定义的类。
JVM在启动时，只加载一些必须的系统类和扩展类，其余的大多数应用类，将在运行时动态加载。
你可以尝试从JVM的运行效率来分析考虑：假设有非常非常多的类文件等待执行，而如果JVM一次性加载所有的类文件到内存中，将会是什么结果？
JVM的运行效率本来就不是很高，这样做的结果可想而知吧。

JVM需要加载一个.class类文件的时候只有在下面几种情况下才会发生：
1 创建一个java实例对象；
2 调用一个类的静态方法；
3  静态域赋值；
4  访问静态域；
5  在顶层类中执行assert语句
当上面的某个条件发生的时候，ClassLoader才会真正的去加载相应的类。

下面来看看关于类的加载器：
JVM中默认的三个主要的类加载器：
BootStrap：负责加载JRE/librt.jar
ExtClassLoader：负责加载JRE/lib/ext/*.jar
AppClassLoader：负责加载CLASSPATH指定路径下的class文件
当JVM启动的时候，最先运行的是BootStrap加载器，依次往下。
三个类加载器是自上而下的继承关系，从下面代码打印的最后两行可以看出AppClassLoader的父类是ExtClassLoader。
其中，BootStrap不是Java语言编写的类，而是由JVM所在系统的语言编写的。在Windows下，此类就是用C++编写的程序。

1. class Apple {
   
2.         Apple() {
   
3.                 System.out.println("Apple");
   
4.         }
   
5. }
   
6. 
   
7. class Boy {
   
8.         Boy() {
   
9.                 System.out.println("Boy");
   
10.         }
    
11. }
    
12. 
    
13. class Cat {
    
14.         Cat() {
    
15.                 System.out.println("Cat");
    
16.         }
    
17. }
    
18. 
    
19. class Dog {
    
20.         Dog() {
    
21.                 System.out.println("Dog");
    
22.         }
    
23. }
    
24. 
    
25. public class Test1 {
    
26.         public static void main(String[] args) {
    
27.                 Apple a = new Apple();
    
28.                 Boy b = new Boy();
    
29.                 Cat c = new Cat();
    
30.                 Dog d = new Dog();
    
31.                
    
32.                 System.out.println(a.getClass().getClassLoader());
    
33.                 System.out.println(b.getClass().getClassLoader());
    
34.                 System.out.println(c.getClass().getClassLoader());
    
35.                 System.out.println(d.getClass().getClassLoader());
    
36.                
    
37.                 ClassLoader loader = a.getClass().getClassLoader();
    
38.                 while(loader != null) {
    
39.                         //循环打印出ClassLoader的父类
    
40.                         System.out.println(loader.getClass().getName());
    
41.                         loader = loader.getParent();
    
42.                 }
    
43.         }
    
44. }

复制代码

打印输出结果：

1. Apple
   
2. Boy
   
3. Cat
   
4. Dog
   
5. sun.misc.Launcher$AppClassLoader@19821f
   
6. sun.misc.Launcher$AppClassLoader@19821f
   
7. sun.misc.Launcher$AppClassLoader@19821f
   
8. sun.misc.Launcher$AppClassLoader@19821f
   
9. sun.misc.Launcher$AppClassLoader
   
10. sun.misc.Launcher$ExtClassLoader

复制代码

从打印输出的结果来看，至少能说明以上4个类对象都是由同一个类加载器加载的，它就是AppClassLoader。

麻烦楼主把问题改一下，这是加载顺序问题，不是ClassLoader问题。

当程序主动使用某个类的时候,类还没有被加载到内存中。加载的步骤大概如下

1.假如这个类没有被加载和连接,就先加载并连接该类。

2.假如该类的直接父类还没有被初始化,那么先初始化其父类.这里需要明白的是,所有的类的父类是java.lang.Object类(它是类层次结构的根),所以JVM总是会初始化它.依次是下一个父类.以此类推.系统会保证该类的所有父类,包括直接的,间接的,都会被初始化。

3.假如类中有初始化语句块,系统就依次执行这些初始化语句块的语句。

public class Test3 {
        public static void main(String[] args) {
                A a = new A("张三");  //把值传给A的构造函数后就赋值了
                B b = new B();
                C c = new C();
                D d = new D();
                //你建立的是构造函数,构造函数一般用于赋值
                //而你直接在里面使用输出语句,所以创建一次就直接输出了
                //如果你要调用函数可以使用一般函数
                a.show(); //如果注释了就不会被调用
        }
}

class A{
                String name;
        A(String name){
                this.name = name;
        }
        public void show(){
                System.out.println("Aaaa");
        }
}

class B{
        B(){
                System.out.println("B");
        }
}

class C{
        C(){
                System.out.println("c");
        }
}

class D{
        D(){
                System.out.println("D");
        }
}

构造函数是对象的创建一同加载到内存的堆内存中,所以你new对象就直接打印出来了.