JAVA反射机制——Class 类的使用

可以使用Class 类完成对象的实例化操作

可以通过Constructor 类调用有参构造方法完成对象的实例化操作

Class 主要是反射的源头，不光可以取得对象所在类的信息，也可以直接通过 Class 类的方法进行对象的实例化操作正常情况下，使关键字 new 对象实例化，如果现在已经实例化好了 Class 对象，则就可以通过 Class  类中提供的

public T newInstance()
              throws InstantiationException,
                     IllegalAccessException

实例化对象

package org.lxh.demo15.instancedemo ;
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 InstanceDemo01{
	public static void main(String args[]){
		Class<?> c = null ;		// 声明Class对象
		try{
			c = Class.forName("org.lxh.demo15.instancedemo.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()
	}
};

通过以上的代码，可以发现，即使不使用关键字 new 对象也可以进行实例化操作，反射的作用。但是，在使用以上操作的时候有一点必须注意，在操作中类中必须存在无参构造方法。否则无法实例化。

package org.lxh.demo15.instancedemo ;
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 InstanceDemo02{
	public static void main(String args[]){
		Class<?> c = null ;		// 声明Class对象
		try{
			c = Class.forName("org.lxh.demo15.instancedemo.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()
	}
};

所以说，发现，使用以上的方式实际上还是需要类的的构造方法的支持，符合于对象的实例化要求。

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

如果要想调用有参，则必须按照以下的步骤进行：

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

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

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

package org.lxh.demo15.instancedemo ;
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 InstanceDemo03{
	public static void main(String args[]){
		Class<?> c = null ;		// 声明Class对象
		try{
			c = Class.forName("org.lxh.demo15.instancedemo.Person") ;
		}catch(ClassNotFoundException e){
			e.printStackTrace() ;
		}
		Person per = null ;	// 声明Person对象
		Constructor<?> cons[] = null ;
		cons = c.getConstructors() ;
		try{
			per = (Person)cons[0].newInstance("李兴华",30) ;	// 实例化对象
		}catch(Exception e){
			e.printStackTrace() ;
		}
		System.out.println(per) ;	// 内容输出，调用toString()
	}
};

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

总结：

1、本章功能是 Class 用的最多的功能，而且在开发中用户也会经常使用到的开发模式

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

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