一、 认识Class类
1.1 正常我们再使用一个类时，大多情况是先获取类的对象，然后通过对象去操作类中的属性或方法。 那，大家有没有想过，如果我们已经有了一个类的对象，我能否通过该对象去获取到类的信息呢？答案是肯定的。
java允许通过对象来找到其所在类的信息，那么实际上就是Class类的功能。接下来，我们先看一个例子，定义一个类Person，并实例化Person类的一个对象，我们通过该对象去寻找到该Person类
package com.chen.yuan.ref;
class Person{
}
public class ClassDemo
{
public static void main(String[] args)
{
Person per = new Person();
Class c1 = per.getClass();
System.out.println(c1.getName());
}
}输出： com.chen.yuan.ref.Person
我们发现，现在所有的操作都和我们以前的习惯是反着的了，即通过对象去获取类，而非通过类获取对象。
1.2 从上面的例子中我们可以看出，对象可以通过getClass()方法，获取对象的源头（类），那这个getClass（）方法在哪里定义的呢？ 查看JDK可以看到，在Object中定义了这个方法，此方法将被所有子类继承：
· public final Class getClass()
` 以上方法的返回值的类型是一个Class类，实际上此类是Java反射的源头。 所谓的反射从程序的运行结果可以这样理解： 可以通过对象反射求出类的名称。
1.3 Class类中常用的方法：
|
forName(String className) |
传入完成的”包.类”名称实例化Class对象 |
|
getName() |
获得类的完整名字 |
|
getFields() |
获得类的public类型的属性 |
|
getDeclaredFields() |
获得类的所有属性 |
|
getMethods() |
获得类的public类型的方法 |
|
getDeclaredMethods() |
获得类的所有方法 |
|
getMethod(String name, Class[] parameterTypes) |
获取类的特定方法(name参数指定方法名字，parameterTypes参数指定方法参数类型) |
|
getConstructors() |
获得类的public类型的构造方法 |
|
getConstructor(Class[] parameterTypes) |
获得类的特定构造方法(parameterTypes参数指定构造方法的参数类型) |
|
newInstance() |
通过类的不带参数的构造方法创建这个类的一个对象 |
1.4 实例化Class的三种方法：
通过查看源码或JDK文档我们可以发现，Class类的构造方法是私有的，即它无法通过构造方法进行实例化。 Java提供了三种可以实例化Class对象的方法：
a) 使用Class类的静态方法forName：
Class.forName("java.lang.String");
b) 使用类的.class语法：
String.class;
c) 使用对象的getClass()方法(java.lang.Object类中的方法)：
String s = "aa";
Class<?> clazz = s.getClass();
package com.chen.yuan.ref;
class Person{
}
public class ClassDemo
{
public static void main(String[] args) throws Exception
{
Class<?> c1 = null;
Class<?> c2 = null;
Class<?> c3 = null;
// 通过Class.forName()进行实例化
c1 = Class.forName("com.chen.yuan.ref.Person");
//通过对象.getClass()方法进行实例化
c2 = new Person().getClass();
// 通过类.class进行实例化
c3 = Person.class;
System.out.println("类名称： "+c1.getName());
System.out.println("类名称： "+c2.getName());
System.out.println("类名称： "+c3.getName());
}
}二、 使用Class类
上文已经提到了一些Class类中的常用方法，当然不全，可以查看JDK文档，了解更加详细的Class中的方法。
接下来，我们假设，如果现在已经实例化好了Class对象，则就可以通过Class类中提供的newInstance()方法，实例化源类（比如Person）的对象。
package com.chen.yuan.ref;
class Person{
private String name;
private int age;
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
@Override
public String toString()
{
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class ClassDemo
{
public static void main(String[] args) throws Exception
{
Class<?> c1 = null;
// 通过Class.forName()进行实例化
c1 = Class.forName("com.chen.yuan.ref.Person");
Person per = (Person) c1.newInstance();
per.setName("无缘");
per.setAge(25);
System.out.println(per);
}
}
输出： Person [name=无缘, age=25]
通过以上代码，我们发现，即使不使用new关键字，对象也可以进行实例化操作，这就是反射的作用。
但是，我们需要记住，此时的操作，必须为Person类一共一个无参数的构造方法，否则无法实例化。
package com.chen.yuan.ref;
class Person{
private String name;
private int age;
public Person(String name, int age)
{
super();
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
@Override
public String toString()
{
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class ClassDemo
{
public static void main(String[] args) throws Exception
{
Class<?> c1 = null;
// 通过Class.forName()进行实例化
c1 = Class.forName("com.chen.yuan.ref.Person");
Person per = (Person) c1.newInstance();
per.setName("无缘");
per.setAge(25);
System.out.println(per);
}
}
运行之后，程序会报错：
Exception in thread "main" java.lang.InstantiationException: com.chen.yuan.ref.Person
at java.lang.Class.newInstance(Class.java:359)
at com.chen.yuan.ref.ClassDemo.main(ClassDemo.java:42)
所以说，使用以上的方式，实际上还是需要类中构造方法的支持，才能进行对象的实例化。
如果想要解决该问题，则必须明确指定要调用的构造方法，并传递参数。但是，在实际开发中，一般用到反射的地方我们都要求类中含有一个无参的构造方法，便于操作。
如果想调用有参数的构造方法进行反射实例化，可以按如下步骤：
1） 通过Class类的getConstructors（）取得本类中的全部构造方法。
2） 向构造方法中传递一个对象数组进去，里面包含了构造方法中所需的各个参数。
3） 之后通过Constructor实例化对象。
package com.chen.yuan.ref;
import java.lang.reflect.Constructor;
class Person
{
private String name;
private int age;
public Person(String name, int age)
{
super();
this.name = name;
this.age = age;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public int getAge()
{
return age;
}
public void setAge(int age)
{
this.age = age;
}
@Override
public String toString()
{
return "Person [name=" + name + ", age=" + age + "]";
}
}
public class ClassDemo
{
public static void main(String[] args) throws Exception
{
Class<?> c1 = null;
// 通过Class.forName()进行实例化
c1 = Class.forName("com.chen.yuan.ref.Person");
Constructor<?>[] cons = c1.getConstructors();
System.out.println(cons.length);
Person per = (Person) cons[0].newInstance("无缘", 25);
per.setName("无缘");
per.setAge(25);
System.out.println(per);
}
}输出： Person [name=无缘, age=25]
可以看出，通过这种方式，我们确实可以做到对象的实例化，但是，我们最好不要如此操作，最好能为类添加一个无参的构造方法。