Java动态加载类

一、Class 类

Class.forName("类的全称")

• 不仅表示类的类类型，还代表了动态加载类
• 请大家区分编译、运行
• 编译时刻加载类是静态加载类、运行时刻加载类是动态加载类

 

 

二、静态加载类

1、我们看下面这段代码，通过 new 的方式来创建对象，这其实是静态方式来加载类(Word和Excel)

1. public class Office {
3.     public static void main(String args[]) {
5.         if("Word".equals(args[0])) {
6.             Word w = new Word();
7.             w.start();
8.         }
10.         if("Excel".equals(args[0])) {
11.             Excel e = new Excel();
12.             e.start();
13.         }
14.     }
15. }

如上代码，目前是没有 Word 和 Excel 两个类，我们编译程序

结果如下

可见，因为我们没有 Word 和 Excel 类，自然也没有 start 方法，报了四个错误。

 

2、我们创建 一个 Word 类

1. public class Office {
3.     public static void main(String args[]) {
5.         if("Word".equals(args[0])) {
6.             Word w = new Word();
7.             w.start();
8.         }
10.         if("Excel".equals(args[0])) {
11.             Excel e = new Excel();
12.             e.start();
13.         }
14.     }
15. }
17. class Word {
19.     public void start() {
20.         System.out.println("start word...");
21.     }
22. }

再次编译，结果如下

这次只报了两个错误了，显示 Excel 类和其对象的 start() 方法不存在

 

3、结论

使用 new 创建对象的方式，是静态加载类，编译阶段，就会加载可能要用到类，如果不存在就报错，无法通过编译。

如上，第2中的例子，Word 类存在，Excel 不存在，导致 Word 类也用不了。

我们当然希望，Word 类存在 Word 就能用，用 Excel 的时候发现 Excel 类不存在再报错吧。

如果将来我们有100个功能，有一个功能有问题，其他99个也用不了，十分不好。

这就是编译时加载导致的，静态加载类。

我们希望，用的时候再加载类，不用不加载，动态加载类可以实现。

 

三、使用动态加载的方式

1、 OfficeAble.java  定义规范的接口

1. public interface OfficeAble {
2.     void start();
3. }

2、Word.java  实现 OfficeAble 接口

1. public class Word implements OfficeAble {
3.     public void start() {
4.         System.out.println("start word...");
5.     }
6. }

3、Excel.java   实现 OfficeAble 接口

1. public class Excel implements OfficeAble {
3.     @Override
4.     public void start() {
5.         System.out.println("start excel...");
6.     }
7. }

4、OfficeBetter.java

1. public class OfficeBetter {
3.     public static void main(String args[]) {
4.         try {
5.             //动态加载类，在运行的时候加载类
6.             Class c = Class.forName(args[0]);
7.             //通过类类型
8.             OfficeAble oa = (OfficeAble) c.newInstance();
9.             oa.start();
10.         } catch (ClassNotFoundException e) {
11.             e.printStackTrace();
12.         } catch (IllegalAccessException e) {
13.             e.printStackTrace();
14.         } catch (InstantiationException e) {
15.             e.printStackTrace();
16.         }
17.     }
18. }

 

然后我们在终端依次编译 Word类，Excel 类，OfficeBetter类

再运行 Office类，带 Word 参数

再运行 OfficeBtter类，带 Excel 参数

同时，已经编译的，生成了.class 文件，下次就可以直接运行了，而不需要重新编译，这就是所谓的“一次编译，到处运行”。

一般情况，软件升级也是如此，只需要编译需要新的功能，而之前的功能也可以正常使用。