这篇文章将为大家详细讲解有关什么是Java动态类加载和重新加载，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。
公司主营业务：网站设计制作、成都网站制作、移动网站开发等业务。帮助企业客户真正实现互联网宣传，提高企业的竞争能力。成都创新互联公司是一支青春激扬、勤奋敬业、活力青春激扬、勤奋敬业、活力澎湃、和谐高效的团队。公司秉承以“开放、自由、严谨、自律”为核心的企业文化，感谢他们对我们的高要求，感谢他们从不同领域给我们带来的挑战，让我们激情的团队有机会用头脑与智慧不断的给客户带来惊喜。成都创新互联公司推出东坡免费做网站回馈大家。
Java中可以在运行时加载和重新加载类，虽然并不像我们想像中那么简单。本文将解释何时、怎样在Java中加载、重新加载类。
你可以争论动态加载类是Java反射的一部分还是Java核心的一部分。不管怎样，我把它放在了Java反射中，因为没有更好的地方放置它。
Java程序的所有类都是使用 java.lang.ClassLoader的一些子类加载的。因此，动态加载类也必须使用 java.lang.ClassLoader的子类。
当一个类加载，它所引用的类也会被加载。类加载模式是递归加载的，直到所有需要的类加载完毕。这可能并不是应用程序的所有类。未被引用的类在引用前不会被加载。
类加载在Java中被组织成层级。当你创建一个独立的ClassLoader，你必须提供一个父级ClassLoader。如果ClassLoader被请求加载一个类，它会请求它的父级ClassLoader去加载它。如果父级类加载器找不到这个类，子类加载器会尝试自加载。
类加载器加载类的步骤如下：
检查该类是否已被加载
如类未加载，请求父类加载器加载它
如父类加载器不能加载该类，尝试使用当前类加载器加载它
当你实现一个能够重载类的类加载器时，你需要从这个序列中偏离一点。不应请求父类加载程序加载要重装的类。稍后再谈。
动态加载类非常简单。所有你需要做的是获得一个ClassLoader并调用它的loadClass()方法。示例如下：
public class MainClass {
public static void main(String[] args){
ClassLoader classLoader = MainClass.class.getClassLoader();
try {
Class aClass = classLoader.loadClass("com.jenkov.MyClass");
System.out.println("aClass.getName() = " + aClass.getName());
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}动态类重新加载有一些挑战。Java内建的类加载器在加载类之前总会检查类是否已被加载。因此，使用Java的内置类加载器不可能重新加载类。重新加载一个类你必须实现自己的ClassLoader子类。
即使使用类加载器的自定义子类，也会遇到挑战。所有已被加载的类都需要被链接。这个方法是final的，因此不能被你的ClassLoader子类重载。resolve()方法不允许ClassLoader实例链接一个类2次。因此，每当你需要重新加载类时，你必须重新创建一个ClassLoader类的实例。这不是不可能的，但必须知道何时设计类重新加载。
如上文述，不能使用加载指定类的ClassLoader重新加载这个类。因此，必须使用不同的ClassLoader加载这个类。但是，这会带来新的问题。
Java程序中加载的每一个类都以其全限定名（包名+类名）标识，并且由ClassLoader实例加载。这意味着，类MyObject由类加载器A加载，是和由类加载器B加载的同一个类MyObject不相同。模拟代码如下：
MyObject object = (MyObject)
myClassReloadingFactory.newInstance("com.jenkov.MyObject");注意，类MyObject在代码中是如何引用的，是作为object类型的变量。这导致MyObject类被已加载过这个类的驻留代码的类加载器加载。
如果myClassReloadingFactory对象工厂使用与驻留代码不同的类加载器加载MyObject，你不能强制转换重新加载的Object类型的变量MyObject为MyObject类型。因为这两个MyObject由不同的类加载器加载，他们被视为不同的类，尽管他们拥有相同的全限定名。尝试强转一个object的类为另一个类的引用将抛出ClassCastException。
有可能绕过这个限制，但是你必须用两种方式来改变你的代码：
使用接口作为变量类型，并且只重新加载实现类
使用超类作为变量类型，并且只重新加载子类
这里是示例代码：
MyObjectInterface object = (MyObjectInterface)
myClassReloadingFactory.newInstance("com.jenkov.MyObject");MyObjectSuperclass object = (MyObjectSuperclass)
myClassReloadingFactory.newInstance("com.jenkov.MyObject");如果变量类型是接口或超类，上面的代码都会正常运行，接口或超类在重新加载实现或子类时不会被重新加载。
为了上面代码的正常运行，你当然需要实现自己的类加载器，让接口或超类由其父类加载。当你的类加载器被请求加载MyObject时，它也会被请求加载MyObjectInterface接口或者MyObjectSuperclass类，因为它们被MyObject类在内部引用。你的类加载器必须把类加载委派给相同的类加载器，即加载了接口或超类的类加载器。
上文包含了很多内容。让我们看一下简单的示例。下面是一个简单的ClassLoader子类。注意它如何将类加载委托给它的父类，除了它想要重装的一个类之外。如果类加载被委派给了它的父类，它以后将不能被重新加载。记住，一个类只能被同一个ClassLoader实例加载。
如前所述，这只是一个示例，它显示了类加载器的行为的基本知识。这并不是一个你的类加载器的生产就绪的模板。你的类加载器可能并不仅限于一个类，可能是一个你想要重新加载的类的集合。此外，你也不能硬编码class path。
public class MyClassLoader extends ClassLoader{
public MyClassLoader(ClassLoader parent) {
super(parent);
}
public Class loadClass(String name) throws ClassNotFoundException {
if(!"reflection.MyObject".equals(name))
return super.loadClass(name);
try {
String url = "file:C:/data/projects/tutorials/web/WEB-INF/" +
"classes/reflection/MyObject.class";
URL myUrl = new URL(url);
URLConnection connection = myUrl.openConnection();
InputStream input = connection.getInputStream();
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int data = input.read();
while(data != -1){
buffer.write(data);
data = input.read();
}
input.close();
byte[] classData = buffer.toByteArray();
return defineClass("reflection.MyObject",
classData, 0, classData.length);
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}下面是使用MyClassLoader的示例：
public static void main(String[] args) throws
ClassNotFoundException,
IllegalAccessException,
InstantiationException {
ClassLoader parentClassLoader = MyClassLoader.class.getClassLoader();
MyClassLoader classLoader = new MyClassLoader(parentClassLoader);
Class myObjectClass = classLoader.loadClass("reflection.MyObject");
AnInterface2 object1 =
(AnInterface2) myObjectClass.newInstance();
MyObjectSuperClass object2 =
(MyObjectSuperClass) myObjectClass.newInstance();
//create new class loader so classes can be reloaded.
classLoader = new MyClassLoader(parentClassLoader);
myObjectClass = classLoader.loadClass("reflection.MyObject");
object1 = (AnInterface2) myObjectClass.newInstance();
object2 = (MyObjectSuperClass) myObjectClass.newInstance();
}reflection.MyObject类是由自定义类加载器加载的。注意，它是如何继承一个超类、实现一个接口的。这只是为了这个例子。在你的代码中，只需要两个中的一个，继承超类或实现接口。
public class MyObject extends MyObjectSuperClass implements AnInterface2{
//... body of class ... override superclass methods
// or implement interface methods
}关于什么是Java动态类加载和重新加载就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果觉得文章不错，可以把它分享出去让更多的人看到。
