很浅很浅的谈一下class类（一）

在java中我们常常定义不同的类去定义，描述其他事物，我们都知道类是某一类对象的抽象。但是其实类也是一种对象，它们都有着一定相同的特征，而这些特征的抽象就是class类。

我们写java中所创建的类，都是java.lang.Class的实例。下面来简单的讲一下Class类。

1.class类有三种表示方法

1）任何一个类都有一个隐含的静态成员变量

2）每一个类对象都可以通过getClass方法来获得class类

3）可以通过Class静态方法forName来获取class类

 1 public class javaClass {
 2     void print(){
 3         System.out.println("test");
 4     }
 5     public static void main(String[] args) {
 6         javaClass test = new javaClass();
 7         Class c1 = javaClass.class;
 8         Class c2 = test.getClass();
 9         Class c3 = null;
10         try{
11             c3 = Class.forName("javaClass");
12         }
13         catch (ClassNotFoundException ex){
14             ex.printStackTrace();
15         }
16
17         System.out.print("c1==c2 :" );
18         System.out.println(c1==c2);
19
20     }
21 }

注意:c3 = Class.forName("javaClass"); 这里编写类的路径时候，要加上包名（假如有包名）

上面代码的输出 c1==c2输出结果是 true 相同的类对象 是相同的。

2.基本类型的对象类

 1 Class c1 = int.class      //int的类类型
 2 Class c2 = String.class     //String类的类类型
 3 Class c3 = double.class     //double的类类型
 4 Class c4 = Double.class    //Double的类类型
 5 Class c5 = void.class
 6
 7 //可以通过类类型来获取类名
 8 c1.getName()
 9 c2.getName()
10 c2.getSimplename()
11     

注意:getName()包括 所属包名，getSimplename()只是该类类型对象的类名

3.动态加载和静态加载

介绍动态加载和静态加载前，首先看下面这个例子先吧

 1 public Class Subject{
 2         public static void main(String[] args){
 3             if("English".equals(args[0]){
 4                 English e = new English();
 5                 e.start();
 6             }
 7             if("Maths".equals(args[0]){
 8                 Maths m = new Maths();
 9                 m.start();
10             }
11         }
12 }

用文本编辑器编写上面代码时，当我们运行cmd命令行编译命令javac Subject.java，会抛出异常，找不到Maths类以及English。

或许我们会想，这很理所当然啊，因为没有定义English或Math类啊

但是仔细想一想，加入我们在命令行里输入的不是English也不是Math，if嵌套的代码根本不会运行，但是为什么还是会抛出异常。

其实上述的代码 通过new 创建实例 这是一种静态加载类，在要求再编译时刻就需要加载所有可能使用的类，所以这时候必须要有English和Math类，即使我们不会使用。

让我们再看下面这个例子

 1 public class Subject_B{
 2         public static void main(String[] args){
 3             try{
 4                 Class c = Class.forName(args[0]);
 5                 Math m = (Math)m.newInstance();
 6                 m.start();
 7             }
 8             catch(Exception e){
 9                 e.printStackTrace();
10             }
11         }
12     }

这个时候我们尝试编译上面的代码，发现编译正常，并没有什么异常，这就是通过类类型 的newInstance方法来动态加载类

动态加载类的时候我们并不需要在编译前就准备好要使用的类，而在程序运行时候动态加载我们所需要用的类。

而在这个例子中，因为我们从命令行里面或者 对象名的字符串，如果不是Math类的时候，上述代码就会抛出类型转换异常。

这个时候我们可以定义一个Subject_able的接口

 1 public class Subject_C{
 2     public static void main(String[] args){
 3         try{
 4             Class c = Class.forName(args[0]);
 5             Subject_able m = (Subject_able)c.newInstance();
 6             m.test();
 7         }
 8         catch(Exception e){
 9             e.printStackTrace();
10         }
11     }
12 }
13 public interface Subject_able{
14        void test();
15 }
16 public class Maths implement Subject_able{
17     public void test(){
18         System.out.println("Math");
19     }
20 }
21 public class English implement Subject_able{
22     public void test(){
23         System.out.println("English");
24     }
25 }

当我们需要添加新的科目类的时候，只需要另外编写新的类，并让他implement Subject_able这个接口，

而我们无需要再重新编译一次主类Subject_C,在这里我们似乎可以看到动态加载类的其中一个好处。