类与Class对象
类是程序的一部分，每个类都有一个Class对象，即每当编写并且编译一个新类的时候就会产生一个Class对象。当程序创建第一个对类的静态成员的引用的时候，会将该类动态加载到JVM中，这个说明了类的构造起器也是一个静态方法，即使在构造器之前并没有使用static关键字。所以java程序在运行之前并没有被完全加载，各个类只在需要的时候才将该类的Class对象载入内存，该Class对象被用来创建这个类的所有对象。通过下面的代码可以证明以上内容：
class Demo1 {
static int i;
static {
System.out.println("loading Demo1");
}
}
class Demo2 {
static {
System.out.println("loading Demo2");
}
}
class Demo3 {
static {
System.out.println("loading Demo3");
}
}
class TestDemo {
public static void main(String[] args) {
int i = Demo1.i;
try {
Class.forName("Demo2");
} catch (ClassNotFoundException e) {
System.out.println("couldn't find Demo2");
}
new Demo3();
}
/* output
* loading Demo1
* loading Demo2
* loading Demo3
*/
}
其中static{}是静态块，在类被加载的时候会执行，第一个输出是我们是用Demo1中的静态成员i而加载了Demo1类，而第二个输出我们调用了Class类的一个静态方法forName，参数是一个类的名称，返回的是该类名的类的Class对象，该方法还有一个作用就是若该类未被加载则加载它，最后使用了new关键字创建对象即调用了类的构造器，也对类进行了加载输出了第三行
Class对象的创建
若我们想要在运行的时候获取某个类的类型信息，就必须先获得该类的Class对象。得到Class对象的方法主要有三种
- Class.forName：Class类的一个静态方法，传入类的全名
- 对象.getClass：根类Object的方法，返回该对象的类的Class对象
- 类名.class：这种方法又称为类字面常量，该方法不仅简单，而且更安全，因为可以在编译时就会受到检查
class Demo1 {
static final int i1 = 47;
static final int i2 = (int)(Math.random() * 10000);
static {
System.out.println("loading Demo1");
}
}
class TestDemo {
public static void main(String[] args) {
Class<Demo1> demo1Class = Demo1.class;
System.out.println("after Demo1.class");
int i = Demo1.i1;
System.out.println("after Demo1.i1");
i = Demo1.i2;
System.out.println("after Demo1.i2");
}
/* output
* after Demo1.class
* after Demo1.i1
* loading Demo1
* after Demo1.i2
*/
}从以上的代码中你会发现，通过使用类名.class的方法并没有对类进行加载，因为通过这种方法创建Class对象不会自动地初始化该Class对象。当我们使用某个类的时候实际上可以分为三个步骤：1）加载，这是由类加载器执行的，即通过查找到的字节码创建一个Class对象。2）链接，验证类中的字节码，为静态域分配存储空间，解析对其它类的引用。3）初始化，若该类有父类，则对其初始化，执行静态初始化器和静态块。从这三个步骤中看出只有对Class对象进行初始化才执行静态块。接着我们又调用了Demo1的i1也为执行静态块，因为被static final修饰的是一个编译期常量，当我们读取这个值的时候并不需要的类进行初始化，但并不是说访问的域被static final修饰时就不会对类进行初始化，从调用i2就可以看出，因为i2的值不是一个编译器的常量。
Class对象的使用
Class对象中提供了大量的方法来让我们获取类中的属性与方法，而且我们也可以通过Class对象来创建类的实例与修改属性值和执行方法，以下为Class对象中比较常用的方法：
- getFields：获取public修饰的所有属性，返回一个Field数组（包括父类的）
- getDeclaredFields：获取所有属性，返回一个Field数组
- getField：传入一个参数（属性名），获取单个属性，返回一个Field对象，只能获取public修饰的
- getDeclaredField：传入一个参数（属性名），获取单个属性，返回一个Field对象
public class Demo {
public int field1;
private String field2;
public void method1(Integer arg0) {
System.out.println("执行method1");
}
private String method1() { return null;}
}
class TestDemo {
public static void main(String[] args) throws Exception {
Class<Demo> demoClass = Demo.class;
Field[] fields1 = demoClass.getFields();
Field[] fields2 = demoClass.getDeclaredFields();
System.out.println(Arrays.toString(fields1));
System.out.println(Arrays.toString(fields2));
Field field1 = demoClass.getField("field1");
// Field field2 = demoClass.getField("field2"); // 运行时抛异常
Field field3 = demoClass.getDeclaredField("field2");
System.out.println(field1);
System.out.println(field3);
}
/* output
* [public int Demo.field1]
* [public int Demo.field1, private java.lang.String Demo.field2]
* public int Demo.field1
* private java.lang.String Demo.field2
*/
} - getMethods：获取所有的public修饰的方法，包括父类的，返回Method数组
- getDeclaredMethods：获取所有的返回，不包括父类，返回Method数组
- getMethod：传入一个参数（方法名），返回一个Method对象，只能获取到public修饰的
- getDeclared：传入一个参数（方法名），返回一个Method对象
class TestDemo {
public static void main(String[] args) throws Exception {
Class<Demo> demoClass = Demo.class; //上段代码的Demo类
Method[] methods1 = demoClass.getMethods();
Method[] methods2 = demoClass.getDeclaredMethods();
System.out.println(Arrays.toString(methods1));
System.out.println(Arrays.toString(methods2));
Method method1 = demoClass.getMethod("method1", new Class[]{Integer.class});
// Method method2 = demoClass.getMethod("method2");
Method method3 = demoClass.getDeclaredMethod("method2");
System.out.println(method1);
System.out.println(method3);
}
/**
* [public void Demo.method1(java.lang.Integer), public final void java.lang.Object.wait() throws java.lang.InterruptedException,...
* [public void Demo.method1(java.lang.Integer), private java.lang.String Demo.method2()]
* public void Demo.method1(java.lang.Integer)
* private java.lang.String Demo.method2()
*/
} - newInstance：创建该类型的一个实例
class TestDemo {
public static void main(String[] args) throws Exception {
Class<Demo> demoClass = Demo.class;
Demo demo = demoClass.newInstance();
Field field2 = demoClass.getDeclaredField("field2");
field2.setAccessible(true);
field2.set(demo, "setField2");
System.out.println(field2.get(demo));
Method method1 = demoClass.getMethod("method1", Integer.class);
method1.invoke(demo, new Object[]{11});
}
/**
* setField2
* 执行method1
*/
}以上代码中可以看出创建类的一个实例并不只能通过new关键字来创建，而且上述还使用了Field对象的方法，可以获取一个实例中的属性值。而且你会发现通过Field对象的方法甚至可以改变一个实例的私有的属性值。若想改变私有属性值必须调用setAccessible方法并传入true（默认为false）。后面又使用了Method对象的方法，可以执行实例的方法，传入参数分别为实例与方法的参数数组，若调用Method的setAccessible方法并传入true，可以执行实例的私有方法。到这你可能会想有没有什么办法可以阻止我们通过反射（即Field和Method方法）调用那些私有的属性，可以试着将该属性值放在一个私有内部类中或则放在匿名类中，最后将会发现这都不法阻止反射的调用。但我们可以通过将一个属性用final来修饰，即使可以执行修改操作但并不会真正的改变属性值。