反射机制之Class类的使用

class类的使用

默认情况（无参）

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

，操作正常的情况下，使用关键字new为对象实例化。如果现在已经实例化好了class对象，则可以利用class类中提供的

public T newInstance()
              throws InstantiationException,
                     IllegalAccessException

完成对象的实例化

注意：之前的三种方法是实例化Class类，而这里的newInstance是用来实例化其他的类

package InstanceDemo;
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;
	}
	public String toString() {
		return "姓名：" + this.name + ", 年龄：" + this.age;
	}
}
public class instanceDemo01 {
	public static void main(String[] args) {
		Class<?> c = null;
		
		try {
			c = Class.forName("InstanceDemo.Person");
			
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		Person person = null;//声明Person对象
		
		try {
			person = (Person) c.newInstance();//实例化对象
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		person.setName("yue");//设置姓名
		person.setAge(17);//设置年龄
		System.out.println(person);//内容输出调用toString方法
		
	}
}

这个例子中没有使用关键字new但是完成了对象Person的实例化，反射的作用，但是有一点必须注意：

1.在操作类中必须存在无参构造方法，否则无法进行实例化；

2.没有写构造方法的类中有一个默认的无参构造方法，但是如果写出了有参构造方法，那么就没有默认的无参的构造方法，就只有写出的构造方法，这时候必须定义无参的构造方法。

有参构造调用

使用这种方法还是要找构造方法，符合对象的实例化要求。

而如果要解决上述注意的问题，就必须明确的指定要调用的构造方法，并传递相应的参数；但是从实际开发情况来讲，一般使用反射机制来实例化对象的时候，类中都最好存在一个无参的构造方法；这样的操作比较合理。

如果要调用有参，那么就必须按照以下步骤进行：

a.通过Class类中的getConstructors（）取得本类中的全部构造方法

b.向构造方法中传递一个对象数组进去，里面包含了构造方法中所需的各个参数

c.之后通过Constructor实例化对象

在Constructor中存在一个方法：

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

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

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

package InstanceDemo;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

class P{
	private String name;
	private int age;
	public P(String name,int age) {
		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;
	}
	public String toString() {
		return "姓名：" + this.name + ", 年龄：" + this.age;
	}
}
public class instanceDemo02 {
	public static void main(String[] args) {
		Class<?> c = null;
		
		try {
			c = Class.forName("InstanceDemo.P");
			
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		P person = null;//声明Person对象
		Constructor<?> cons[] = null;
		cons = c.getConstructors();
		try {
			person = (P) cons[0].newInstance("yu",17);//实例化对象
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		System.out.println(person);//内容输出调用toString方法
		
	}
}

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

1.这是Class使用最多的功能

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

3.如过想调用有参构造进行对象的实例化操作则必须使用Constructor类完后，此类

表示构造方法，并通过可变参数传递需要的数据，（数组）