反射机制2，Class类的使用

class是反射源头，不光可以取得对象所在类信息，也可直接通过class类的方法进行对象的实例化操作。

使用关键字new为对象实例化。如果已经实例化好了class对象，就可以通过class类中提供的newInstance()操作

public T newInstance()
throws InstantiationException,
IllegalAccessException

来个例子：

package 类集;

class Person{
private String name ;    // name属性
private int age ;        // age属性
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
public String toString(){    // 覆写toString()方法
return "姓名：" + this.name + "，年龄：" + this.age  ;
}
};
public class test1{
public static void main(String args[]){
 Class<?> c = null ;        // 声明Class对象
try{
 c = Class.forName("类集.Person") ;
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
Person per = null ;    // 声明Person对象
try{
per = (Person)c.newInstance() ;    // 实例化对象
}catch(Exception e){
e.printStackTrace() ;
}
per.setName("小明") ;        // 设置姓名
per.setAge(23) ;                // 设置年龄
System.out.println(per) ;    // 内容输出，调用toString()
}
}

返回结果：

姓名：小明，年龄：23

上面的newInstance返回的类型是一个泛型，但是Class<?> c可知，这个类型是一个“？”，实际上是一个object类型，

所以需要向下转型，(Person)c.newInstance()。

通过以上代码发现，即使不使用new关键字也能进行实例化操作，反射作用。

但是，使用以上操作，必须注意：在操作中，类中必须存在无参构造方法。否则无法实例化。

例如：

package 类集;

class Person{
private String name ;    // name属性
private int age ;        // age属性
public Person(String name,int age){
this.setName(name) ;
this.setAge(age);
}
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
public String toString(){    // 覆写toString()方法
return "姓名：" + this.name + "，年龄：" + this.age  ;
}
};
public class test1{
public static void main(String args[]){
Class<?> c = null ;        // 声明Class对象
try{
c = Class.forName("类集.Person") ;
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
Person per = null ;    // 声明Person对象
try{
per = (Person)c.newInstance() ;    // 实例化对象
}catch(Exception e){
e.printStackTrace() ;
}
per.setName("李兴华") ;        // 设置姓名
per.setAge(30) ;                // 设置年龄
System.out.println(per) ;    // 内容输出，调用toString()
}
}

结果；

java.lang.InstantiationException: 类集.Person
at java.lang.Class.newInstance(Class.java:427)
at 类集.test1.main(test1.java:36)
Caused by: java.lang.NoSuchMethodException: 类集.Person.<init>()
at java.lang.Class.getConstructor0(Class.java:3082)
at java.lang.Class.newInstance(Class.java:412)
... 1 more
Exception in thread "main" java.lang.NullPointerException
at 类集.test1.main(test1.java:40)

　　所以发现，使用以上方式，实际上还是需要无参构造方法的支持。符合于对象实例化要求。（实际上跟正常实例化new 类（）方式一样，调用构造方法）。

要想解决这样问题，则必须明确指定要调用的构造方法，并且传递参数。从实际开发角度，一般使用反射实例化对象的时候，类中最好存在一个无参构造，比较合理。

操作步骤如下：

1，通过class类中的getConstructors()取得本类中全部构造方法，返回的结果是一个数组，见下面例子，

2，向构造方法中传递一个对象数组进去，里面保护构造方法所需要的各个参数。

3，之后通过Constructor实例化对象。

在constructor类中存在方法newInstance()，

public T newInstance(Object... initargs)
throws InstantiationException,
IllegalAccessException,
IllegalArgumentException,
InvocationTargetException

传递初始化参数，以进行对象的实例化操作。



明确调用有参构造，实例化对象。

package 类集;

import java.lang.reflect.Constructor;

class Person{
private String name ;    // name属性
private int age ;        // age属性
public Person(String name,int age){
this.setName(name) ;
this.setAge(age);
}
public void setName(String name){
this.name = name ;
}
public void setAge(int age){
this.age = age ;
}
public String getName(){
return this.name ;
}
public int getAge(){
return this.age ;
}
public String toString(){    // 覆写toString()方法
return "姓名：" + this.name + "，年龄：" + this.age  ;
}
};
public class test1{
public static void main(String args[]){
Class<?> c = null ;        // 声明Class对象
try{
 c = Class.forName("类集.Person") ;
}catch(ClassNotFoundException e){
e.printStackTrace() ;
}
Person per = null ;    // 声明Person对象
Constructor<?> cons[] = null ;//返回的是一个数组。
cons = c.getConstructors() ;//取得所有构造方法
try{
per = (Person)cons[0].newInstance("校华",18) ;    // 实例化对象，因为只有一个构造方法，所以使用第一个构造方法，也就是cons[0]，通过newInstance(""，“”)传给构造方法
　　　　别忘了后面还要向下转型，因为返回结果是object类型。
}catch(Exception e){
e.printStackTrace() ;
}
System.out.println(per) ;    // 内容输出，调用toString()
}
}

运行结果：

姓名：校华，年龄：18

注意：接收的原理如下：



但是，如果要使用反射进行对象的实例化操作，最好在类中存在无参数构造。

总结：

1，本周功能是class用的最多的功能，而且开发中也会经常用到的模式

2，在使用class实例化对象的时候，必须保证类中存在无参构造，否则无法使用。

3，如果要想调用有参构造进行对象的实例化操作，必须使用constructor类完成，此类表示构造方法，并通过可变参数传递要求的内容。