⑴ java解释器如何加载类
类加载次序：1、静态代码块或者静态方法－>2、main方法调用到的方法
对象加载次序:1、静态代码块或者静态方法－>2、非静态代码块或者非静态方法－>3、对象的构造方法。
但是有一段代码没有办法解释。代码忘了，过段时间丢上来
个人感觉应该好像不大对劲，我觉得应该是:
类装载时，1、静态代码块或者静态方法被调用
然后是程序的运行，main调用到的方法会被执行，如果是新建一个对象，则
2、非静态代码块或者非静态方法－>3、对象的构造方法顺序执行。
===============================================
首先我们要分析类加载原理，java中默认有三种类加载器：引导类加载器，扩展类加载器，系统类加载器(也叫应用类加载器)引导类加载器负责加载jdk中的系统类，这种类加载器都是用c语言实现的，在java程序中没有办法获得这个类加载器，对于java程序是一个概念而已，基本上不用考虑它的存在，像String,Integer这样的类都是由引导类加载器加载器的.
扩展类加载器负责加载标准扩展类，一般使用java实现，这是一个真正的java类加载器，负责加载jre/lib/ext中的类，和普通的类加载器一样，其实这个类加载器对我们来说也不是很重要，我们可以通过java程序获得这个类加载器。
系统类加载器，加载第一个应用类的加载器(其实这个定义并不准确,下面你将会看到)，也就是执行java MainClass 时加载MainClass的加载器，这个加载器使用java实现，使用的很广泛，负责加载classpath中指定的类。
类加载器之间有一定的关系(父子关系)，我们可以认为扩展类加载器的父加载器是引导类加载器(当然不这样认为也是可以的，因为引导类加载器表现在java中就是一个null),不过系统类加载器的父加载器一定是扩展类加载器，类加载器在加载类的时候会先给父加载器一个机会，只有父加载器无法加载时才会自己去加载。
我们无法获得引导类加载器，因为它是使用c实现的，而且使用引导类加载器加载的类通过getClassLoader方法返回的是null.所以无法直接操作引导类加载器，但是我们可以根据Class.getClassLoader方法是否为null判断这个类是不是引导类加载器加载的，可以通过下面的方法获得引导类加载器加载的类路径(每个jar包或者文件夹对应了一个URL);
sun.misc.Launcher.getBootstrapClassPath().getURLs()
你可以直接在你的main函数中输出就可以了
System.out.println(java.util.Arrays.asList(sun.misc.Launcher.getBootstrapClassPath().getURLs()).toString());
得到的结果是：
[file:/C:/Program%20Files/Java/j2re1.4.2_10/lib/rt.jar,
file:/C:/Program%20Files/Java/j2re1.4.2_10/lib/i18n.jar,
file:/C:/Program%20Files/Java/j2re1.4.2_10/lib/sunrsasign.jar,
file:/C:/Program%20Files/Java/j2re1.4.2_10/lib/jsse.jar,
file:/C:/Program%20Files/Java/j2re1.4.2_10/lib/jce.jar,
file:/C:/Program%20Files/Java/j2re1.4.2_10/lib/charsets.jar,
file:/C:/Program%20Files/Java/j2re1.4.2_10/classes]
其实我们是可以指定引导类加载器的类路径的，java提供了一个-Xbootclasspath参数，不过这个参数不是标准参数。
java -Xbootclasspath: 运行时指定引导类加载器的加载路径(jar文件或者目录)
java -Xbootclasspath/p:和上面的相同，不过把这个路径放到原来的路径前面
java -Xbootclasspath/a:这个就是在原引导类路径后面添加类路径。
上面我们有提过加载第一个应用类未必就是系统加载器。
如果我把这个应用类的路径放到引导类路径中，它将会被引导类加载器加载，大致这样
java -Xbootclasspath/a:myjar.jar MainClass
如果MainClass在myjar.jar中,那么这个类将会被引导类加载器加载。
如果希望看详情，使用-verbose参数，为了看的更清楚，使用重定向，大致为(windows下)：
java -verbose -Xbootclasspath/a:myjar.jar MainClass -> C:\out.txt
通过这个参数我们可以实现自己的系统类，比如替换掉java.lang.Object的实现，自己可以扩展
一些方法，不过这样做似乎没有好处，因为那就不是标准了。
我们最关心的还是系统类加载器，一般都认为系统类加载器是加载应用程序第一个类的加载器，
也就是java MainClass命令中加载MainClass的类加载器，这种说法虽然不是很严谨，但基本上还是可以这样认为的，因为我们很少会改变引导类加载器和扩展类加载器的默认行为。应该说系统类加载器负责加载classpath路径中的而且没有被扩展类加载器加载的类(当然也包括引导类加载器加载的)。如果classpath中有这个类，但是这个类也在扩展类加载器的类路径，那么系统类加载器将没有机会加载它。
我们很少改变扩展类加载器的行为，所以一般你自己定义的类都是系统类加载器加载器的。
获得系统类加载器非常简单，假设MyClass是你定义的一个类
MyClass.class.getClassLoader()返回的就是系统类加载器，当然这种方法无法保证绝对正确，我们可以使用更简单而且一定正确的方式：
ClassLoader.getSystemClassLoader()获得系统类加载器。我们知道ClassLoader是一个抽象类，所以系统类加载器肯定是ClassLoader的一个子类实现。我们来看看它是什么
ClassLoader.getSystemClassLoader().getClass();
结果是class sun.misc.Lancher$AppClassLoader
可以看出这是sun的一个实现，从名字可以看出是一个内部类，目前我也没有看到这个源代码，似乎还不是很清晰：
我们在看看它的父类是什么：
ClassLoader.getSystemClassLoader().getClass().getSuperclass();
结果是：class java.net.URLClassLoader
这个是j2se的标准类，它的父类是SecureClassLoader,而SecureClassLoader是继承ClassLoader的。
现在整个关系应该很清楚，我们会看到几乎所有的ClassLoader实现都是继承URLClassLoader的。
因为系统类加载器是非常重要的，而且是我们可以直接控制的，所以我们后面还会介绍，不过先来看一下扩展类
加载器以及它们之间的关系。
扩展类加载器似乎是一个不起眼的角色，它负责加载java的标准扩展(jre/lib/ext目录下的所有jar)，它其实就是一个普通的加载器，看得见摸得着的。
首先的问题是怎么知道扩展类加载器在哪里?
的确没有直接途径获得扩展类加载器，但是我们知道它是系统类加载器的父加载器，我们已经很容易的获得系统类加载器了，所以我们可以间接的获得扩展类加载器：
ClassLoader.getSystemClassLoader().getParent().getClass();
其实是通过系统类加载器间接的获得了扩展类加载器，看看是什么东西：
结果是：class sun.misc.Launcher$ExtClassLoader
这个类和系统类加载器一样是一个内部类，而且定义在同一个类中。
同样看看它的父类是什么：
ClassLoader.getSystemClassLoader().getParent().getClass().getSuperclass();
可以看出结果也是class java.net.URLClassLoader
扩展类加载jre/lib/ext目录下的所有类，包括jar,目录下的所有类(目录名不一定要classes).
现在可以回答上面的问题了，你写一个HelloWorld，放到jre/lib/ext/下的某个目录
比如 jre/lib/ext/myclass/HelloWorld.class
然后在你classpath也设置一份到这个类的路径，结果执行java HelloWorld时，这个类是被扩展类加载器加载器的，可以这样证明
public static void main(String[] args){
System.out.println("loaded by"+HelloWorld.class.getClassLoader().getClass());
System.out.println("Hello World");
}
结果可以得到class sun.misc.Launcher$ExtClassLoader
当然如果你把jre/lib/ext下myclass这个目录删除，仍然可以运行，但是这样结果是
class sun.misc.Lancher$AppClassLoader
如果你不知道这个过程的话，假设在你扩展类路径下有一份classpath中的拷贝，或者是比较低的版本，当你使用新的版本时会发现没有起作用，知道这个过程你就不会觉得奇怪了。另外就是两个不同的类加载器是可以加载一个同名的类的，也就是说虽然扩展类加载器加载了某个类，系统类加载器是可以加载自己的版本的，
但是现有的实现都没有这样做，ClassLoader中的方法是会请求父类加载器先加载的，如果你自己定义类加载器完全可以修改这种默认行为，甚至可以让他没有父加载器。
这里给出一个方法如何获得扩展类加载器加载的路径：
String path=System.getProperty("java.ext.dirs");
File dir=new File(path);
if(!dir.exists()||!dir.isDirectory()){
return Collections.EMPTY_LIST;
}
File[] jars=dir.listFiles();
URL[] urls=new URL[jars.length];
for(int i=0;i<jars.length;i++){
urls[i]=sun.misc.URLClassPath.pathToURLs(jars[i].getAbsolutePath())[0];
}
return Arrays.asList(urls);
对于扩展类加载器我们基本上不会去关心，也很少把你自己的jar放到扩展路径，大部分情况下我们都感觉不到它的存在，当然如果你一定要放到这个目录下，一定要知道这个过程，它会优先于classpath中的类。
现在我们应该很清楚知道某个类是哪个加载器加载的，并且知道为什么是它加载的，如果要在运行时获得某个类的类加载器，直接使用Class的getClassLoader()方法就可以了。
用户定义的类一般都是系统类加载器加载的,我们很少直接使用类加载器加载类,我们甚至很少自己加载类。
因为类在使用时会被自动加载，我们用到某个类时该类会被自动加载,比如new A()会导致类A自动被加载，不过这种加载只发生一次。
我们也可以使用系统类加载器手动加载类,ClassLoader提供了这个接口
ClassLoader.getSystemClassLoader().loadClass("classFullName");
这就很明确的指定了使用系统类加载器加载指定的类,但是如果该类能够被扩展类加载器加载,系统类加载器还是不会有机会的。
我们最常用的还是使用Class.forName加载使用的类，这种方式没有指定某个特定的ClassLoader,会使用调用类的ClassLoader。
也就是说调用这个方法的类的类加载器将会用于加载这个类。比如在类A中使用Class.forName加载类B,那么加载类A的类加载器将会用于加载类B,这样两个类的类加载器是同一个。
最后讨论一下如何获得某个类加载器加载了哪些类，这个似乎有一定的使用价值，可以看出哪些类被加载了。其实这个也不是很难，因为ClassLoader中有一个classes成员变量就是用来保存类加载器加载的类列表，而且有一个方法
void addClass(Class c) { classes.addElement(c);}
这个方法被JVM调用。
我们只要利用反射获得classes这个值就可以了,不过classes声明为private的,我们需要修改它的访问权限(没有安全管理器时很容易做到)
classes = ClassLoader.class.getDeclaredField("classes");
classes.setAccessible(true);
List ret=(List) classes.get(cl); //classes是一个Vector
可惜的是对于引导类加载器没有办法获得加载的类，因为它是c实现的,在java中很难控制
⑵ 关于Java中类的加载的疑问
当创建一个类的对象时(new 类名)和执行某类的静态方法时(类名.方法名),该类的.class文件会被加载到一段内存中
这句话倒是没错，但当创建一个类的对象时（new）
1.先将该类的.class文件会被加载到一段内存，初始化static属性和方法，为他们分配空间，以后一直在内存中（这就是不建议使用static属性和方法的原因之一）
2.其中非static属性和方法，为他们初始化，分配空间，然后才可以使用，因为非static的属性和方法是跟随对象的，所以当对象被回收时，属于该对象的属性和方法也被回收，再new的时候再生成。
static还有一点不好的就是所有对象共用，这样可能导致数据的不安全性（比如我在用的时候，你突然给改变了，我再用的时候值可能就不连续了）
所以建议使用非static
⑶ java怎么获取类加载
import java.io.File;
import java.io.IOException;
import java.net.URL;
public class MyUrlDemo {
public static void main(String[] args) {
MyUrlDemo muDemo = new MyUrlDemo();
try {
muDemo.showURL();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public void showURL() throws IOException {
// 第一种：获取类加载的根路径 D:\git\tie\tie\target\classes
File f = new File(this.getClass().getResource("/").getPath());
System.out.println(f);
// 获取当前类的所在工程路径; 如果不加“/” 获取当前类的加载目录 D:\git\tie\tie\target\classes\my
File f2 = new File(this.getClass().getResource("").getPath());
System.out.println(f2);
// 第二种：获取项目路径 D:\git\tie\tie
File directory = new File("");// 参数为空
String courseFile = directory.getCanonicalPath();
System.out.println(courseFile);
// 第三种： file:/D:/git/tie/tie/target/classes/
URL xmlpath = this.getClass().getClassLoader().getResource("");
System.out.println(xmlpath);
// 第四种： D:\git\tie\tie
System.out.println(System.getProperty("user.dir"));
/*
* 结果： C:\Documents and Settings\Administrator\workspace\projectName
* 获取当前工程路径
*/
// 第五种： 获取所有的类路径 包括jar包的路径
System.out.println(System.getProperty("java.class.path"));
}
}
⑷ java如何实现类加载
重新定义类加载器，也就是ClassLoader，覆盖其中的一个方法findClass
例如，应用程序可以创建一个网络类加载器，从服务器中下载类文件。示例代码如下所示：
ClassLoader loader = new NetworkClassLoader(host, port);
Object main = loader.loadClass("Main", true).newInstance();
. . .
⑸ 关于JAVA中的初始化及类的加载
你不太可能完全用代码证明类加载的动作，因为在你用这个类之前（也就是你想要开始证明一个类加载的过程时）她已经加载了。
现在来说，静态成员会和类加载的时候一起初始化，所以最多最多也只能通过静态成员来证明类的加载。
那么问题就是如何在静态成员被初始化的时候提示消息，两种方法：
第一种是使用静态的字段成员，此成员指定为一个对象初始化，在这个初始化对象的构造函数做通知。代码：
public class StaticLoad{
public static LoadNotify = new LoadNotify();
}
public class LoadNotify{
public LoadNotify(){
System.out.println("Class is Loaded");
}
}
那么使用StaticLoad类的时候，会打出Class is Loaded证明类加载的时候初始化了static成员，调用多次也仅会打出一次。
第二种是使用静态块，代码：
public class StaticLoad{
public static LoadNotify = new LoadNotify();
static {
System.out.println("Class is Loaded");
}
}
此时类加载时也会执行静态块中的代码。
这是进行当类加载的时候进行通知的方法，你可以自己写一写代码，他们仅会打出一次。
对于类的加载顺序，网上有详细的，我这里只说一些简单的：
首先需要用到一个类的时候，虚拟机会从classpath读取此类的代码，到内存的类的代码存储区，然后对于每一个静态字段开辟一个存储区，再存储方法的代码。接着初始化类，所有的静态成员按照顺序初始化（按代码声明顺序从上到下开始），当需要加载其他类的时候加载其他的类。然后完成初始化供虚拟机使用。
当实例化一个类的时候，如果需要加载的话，会按照上面的顺序加载，然后在内存中分配所有实例字段的空间，接着调用构造函数，其中构造函数会（显示或隐式的）调用父类构造函数（此过程向上递归），然后执行剩下的构造代码。最后返回实例化的对象的引用返回构造函数。
⑹ 描述java虚拟机加载类的过程，要详尽！
先将class文件读到JVM,找到static
的变量并初始化，在找到static代码段执行，在初始化普通变量，然后是构造方法。最后载入其他方法。
⑺ java类的加载过程是怎么样的
类加载到jvm需要经历如下几个过程:
一.加载
通过类的全限定名转换为二进制字节流,在jvm堆中生成代表这个Class的对象,作为方法区域的方法入口.
二.连接
1.验证:验证class的字节流是否对jvm虚拟机造成伤害,是否符合jvm的规范,这里包含几个验证.
2.准备:为类的static变量赋初始值,其中不包含类其它实例成员的初始化.
3.解析:将常量池内的符号引用替换成直接引用
三.初始化
这里是static{}块,构造函数,代码块{}的执行过程.
四.使用
对象的属性,方法等调用操作.
五.销毁
jvm通过确定对象没有引用后进行gc操作.
⑻ java程序什么是类加载
你可以了解一下
深入理解java虚拟机,
java类加载
是因为在运行时当它需要引用某个类的时候,会先去加载这个类,就是去读这个class文件到内存里面来,现在还没有创建这个类的实例,
你可以理解为
你写的java代码在编译成class文件后,并没有去执行,或者去引用他,只有程序运行时它将要使用这个类的时候才会去读取这个class文件,这时候叫做类加载,当缓存了这个类文件之后,后面的创建类的时候都会去引用它,因为类加载是运行是加载,所以java代码在运行时是有办法修改的,同样java类加载也允许加载一个远程的class文件,也代表它是支持程序不停止时更新程序代码的。
⑼ java中类加载的两种方法是什么
java类有两种方法一种是类方法就是用static修饰的，一种是实例方法，就是没有static修饰的方法
⑽ Java中用import导入类和用Class方法加载类有什么区别
import仅仅包含导入操作，并不包含将字节码文件加载进内存这一动作，将字节码文件加载进内存是后续的实例化操作完成的。例如通过import导入了一堆包和类，但是后续什么都没用（没用实例化），那么导入的东西是不会被加载进内存的。而且import是编译期的，如果你在后续代码中没有使用到你导入的内容，那么import语句甚至不会编译和执行。查看字节码文件可以看出，import的作用就是对你程序中要用到（实例）的东西进行署名（signature），当程序运行的时候好知道你实例化的对象的类的字节码文件去哪里找。
而Class.forName方法包含的动作是：根据给出的全类名（方法的参数）找到对应的字节码文件，并将字节码文件通过ClassLoader加载进内存中生成Class类对象（方法的返回值就是Class类对象）。
这些就是二者的区别了。