Class对象和反射

1.class对象
在java中一切都是对象，从某种意义上，java中的对象可以分为：实例对象和Class对象。实例对象通过new关键得到，那么Class对象呢？Class对象无法通过new关键字获取，在类加载的过程中，JVM生成一个与加载的字节码文件相关的class对象。通过类名可以获取对应Class对象。class对象主要用来对应类的所有对象。java程序在运行之前并未完全加载，各个类只在需要的时候才将该类加载进内存，生成对应的class对象。

所有的类都是在对其第一次使用的时候，动态加载到JVM中，当程序创建第一个对类静态成员的引用的时候，就会加载这个。使用new创建类的对象的也会被当做是对类静态成员的引用。因此java程序在它开始运行之前并非被完全加载，其各个部分是在必须的时候才加载。一旦某个类的Class对象被载入内存，它就用来创建这个类的所有的对象。如下面程序所示：

 class Test1{
     static{
         System.out.println("loading1");
     }

 }
 class Test2{
     static{
         System.out.println("loading2");
     }

 }
 class Test3{
     static{
         System.out.println("loading3");
     }

 }
 public class Demo {
     public static void main(String[] args) {
         //new Test1();
         Class clz = Test1.class;//注意Class clz = Test1.class;，不会触发静态块的执行，即不会自动初始化该Class对象
         try {

             Class.forName("Test2");
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
         new Test3();
     }

 }

输出结果：

loading1
loading2
loading3

2.Class对象的获取

Class对象是jvm用来保存对象实例对象的相关信息的，除此之外，我们完全可以把Class对象看成一般的实例对象，事实上所有的Class对象都是类Class的实例。获取Class对象主要有三种方式：

 /**
 *    获取Class对象的三种方式
 */
 public class Demo{
     public static void main(String[] args){
         //1.通过实例对象获取class对象
         Demo demo = new Demo();
         Class clsdemo = demo.getClass();

         //2.通过Class的静态方法forName
         try {
             Class clsdemo2 = Class.forName("Demo");
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         }

         //3.通过类名和class关键字获取
         Class clsdemo3 = Demo.class;
     }
 }

3.Class对象的使用和反射
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。通过反射机制来访问一个类java对象的属性，方法，甚至我们可以轻易改变一个私有成员。java反射是基于Class类和java.lang.Reflect类库。反射机制使得我们可以创建一个编译时完全未知的对象，并调用这个对象的方法。

 public class Demo{
     public static void main(String[] args){

         Test test = new Test();
         System.out.println(test.getClass()==Test.class);//一个类对应的class对象在内存中是唯一的

         Class cls = Test.class;//字节码文件加载进内存，生成class对象，但是不会进行相关的初始化工作，不引起静态块的执行
         try {

             Field [] fields = cls.getDeclaredFields();
             for (Field field : fields) {
                 System.out.println(field);
             }
             Method [] methods = cls.getDeclaredMethods();
             for (Method method : methods) {
                 System.out.println(method);
             }
         } catch (SecurityException e) {
             e.printStackTrace();
         }
     }
 }
 class Test{
     public static int count=0;
     private int age=20;
     public String name="xm";
     static{
         System.out.println("类被加载");
     }
     public void test(){
         System.out.println("sss");
     }
     private void call(){
         System.out.println("hi");
     }
 }

类被加载
true
public static int com.test.demo.Test.count
private int com.test.demo.Test.age
public java.lang.String com.test.demo.Test.name
public void com.test.demo.Test.test()
private void com.test.demo.Test.call()

4.泛化的Class引用

Class引用总是指向某个Class对象，它可以制造实例，并包含可以作用于这些实例的所有方法代码，且包含该类的静态成员，因此Class引用表示的就是它指向的对象的确切类型，而该对象便是Class类的一个对象。class引用可泛化。通过泛型语法，可以让编译器强制的执行额外的类型检查。如果希望放松些限制，可以使用通配符？，表示“任何事物”，如Class<?> intClass = int.class;在java SE5中，Class<?>优于平凡的Class.如下：

public class Demo {
    public static void main(String[] args) {
        Class intClass = int.class;
        Class<Integer> integerClass = int.class;
        integerClass = Integer.class;
　　　　　Class<?> integerClz = Integer.class;

} }