通过反射来获取某一个类的构造器：
1>获取该类的字节码对象；
2>从该字节码对象中去找需要获取的构造器；
Class类获取构造器方法：
Constructor类：
--表示类中构造器的类型，Constructor的实例就是某一个类中的某一个构造器；
public Constructor<?>[] getConstructors() ;
--该方法只能获取当前Class所表示类的public修饰的构造器；
public Constructor<?>[] getDeclaredConstructors();
--获取当前Class所表示类的所有构造器，和访问权限无关；
public Constructor<T> getConstructor(Class<?>... parameterTypes);
--获取当前Class所表示类中指定的一个public的构造器
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes);
--获取当前Class所表示类中指定的一个构造器；
参数：parameterTypes
--表示：构造器参数的Class类型；
public class _0_GetConstructor {
public static void main(String[] args) throws Exception{
// 获取所有的构造器
getAlls();
// 获取指定的一个构造器
getAppoint();
}
private static void getAlls() {
// 1.获取构造器所在类的字节码对象
Class clz = User.class;
// 2.获取clz对象中所有的构造器
// 该方法只能获取当前Class所表示类的public修饰的构造器；
Constructor<User>[] cons = clz.getConstructors();
System.out.println(cons.length);//2
for (Constructor c : cons) {
System.out.println(c);
//public com.reflection._1_constructor.User()
//public com.reflection._1_constructor.User(java.lang.String)
}
System.out.println("------------------------------");
// 获取当前Class所表示类的所有构造器，和访问权限无关；
cons = clz.getDeclaredConstructors();
System.out.println(cons.length);//3
for (Constructor c : cons) {
System.out.println(c);
//public com.reflection._1_constructor.User()
//public com.reflection._1_constructor.User(java.lang.String)
//private com.reflection._1_constructor.User(java.lang.String,int)
}
}
public static void getAppoint() throws Exception {
System.out.println("------------------------------");
// 1.获取构造器所在类的字节码对象
Class clz = User.class;
// 需求1：获取public User()
Constructor<User> con = clz.getConstructor();
System.out.println(con);//public com.reflection._1_constructor.User()
// 需求2：获取public User(String name)
con = clz.getConstructor(String.class);
System.out.println(con);
// 需求3：获取public User(String name ,int age)
// con = clz.getConstructor(String.class,int.class);//报错：Exception in thread "main" java.lang.NoSuchMethodException:
// com.reflection._1_constructor.User.<init>(java.lang.String, int)
con = clz.getDeclaredConstructor(String.class,int.class);
System.out.println(con);
}
}
class User{
public User(){}
public User(String name){}
private User(String name ,int age){}
}
构造器最大的作用：创建对象；
为什么使用反射创建对象而不直接使用new呢？
在框架中，提供给我们的都是字符串；
很多框架（比如Spring）都是配置化的（比如通过XML文件配置JavaBean,Action之类的），为了保证框架的通用性，它们可能需要根据配置文件加载不同的对象或类，调用不同的方法，这个时候就必须用到反射——运行时动态加载需要加载的对象。
使用反射创建对象
步骤：
1.找到构造器所在类的字节码对象；
2.获取构造器对象；
3.使用反射，创建对象；
Constructor<T>类：表示类中构造器的类型，Constructor的实例就是某一个类中的某一个构造器；
常用方法：
public T newInstance(Object... initarges);
-若调用带参数的构造器，只能使用该方式；
-参数：initarges,表示调动构造器的实际参数；
-返回：返回创建的实例，T表示Class所表示类的类 型；
如果：一个类中的构造器是外界可以 直接访问的，同时没有参数，那么可以直接使用Class类中的newInstance()方法创建对象；
-public Object newInstance();//相当于new 类名();
访问私有的成员
-（Constructor、Method、Field）：
必须先设置可访问的：
语法：对象.setAccessible(true);
见源码：
-public final class Constructor<T> extends Executable ...
-public abstract class Executable extends AccessibleObject{
public static void setAccessible(AccessibleObject[] array,
boolean flag)
}
//使用反射调用构造器所在类来创建其对象
public class _1_CreateObject {
public static void main(String[] args) throws Exception{
Class<Person> clz = Person.class;
Person p = clz.newInstance();
Constructor<Person> con = clz.getConstructor();
Person instance = con.newInstance();//调用无参数构造器
con = clz.getConstructor(String.class);
con.newInstance("INSOMNIA");
con = clz.getDeclaredConstructor(String.class,int.class);
// con.newInstance("INSOMNIA",18);//报错，原因：
//Exception in thread "main" java.lang.IllegalAccessException://非法访问异常
//Class com.reflection._1_constructor._1_CreateObject
//can not access a member of class com.reflection._1_constructor.Person with modifiers "private"
/** 设置当前构造器可以访问*/
con.setAccessible(true);//可解决上述问题；使用枚举，即使反射也不行；
con.newInstance("INSOMNIA",18);
}
}
class Person{
public Person(){
System.out.println("调用无参数构造器");
}
public Person(String name){
System.out.println("调用有参数构造器"+name);
}
private Person(String name ,int age){
System.out.println("调用有参数构造器"+"name = "+name+" & "+"age = "+age);
}
}
