Constructor类理解
这里Constructor，我们知道是构造函数
为什么是数组形式的呢？
因为可能有多个构造
这个时候，我们写一个DummyClass2， 这里有2个构造
其他和前面一个Bean类似，有setter，getter，toString方法
这个时候，我们分别打印一下DummyClass和 DummyClass2 的 Constructor
具体打印工具方法
private static void printConstructor(Constructor<?>[] cons){
for(int i=0; i<cons.length; i++){
System.out.println(cons[i]);
}
}
具体打印方法
private void getAndPrintConstructors(Class cls){
Class<?> c1 = cls;
Constructor<?>[] cons= c1.getConstructors();
DUtils.printConstructor(cons);
}
具体简单调用
DoConstructor doClass = new DoConstructor();
doClass.getAndPrintConstructors(DummyClass.class);
doClass.getAndPrintConstructors(DummyClass2.class);
具体我们可以看见结果
public com.aohuan.dodo.javacode.reflect.utils.DummyClass()
- - -
public com.aohuan.dodo.javacode.reflect.utils.DummyClass2(java.lang.String)
public com.aohuan.dodo.javacode.reflect.utils.DummyClass2(java.lang.String,int)
也就是，对象可以得到这个Class中，所有的构造方法
对应的构造方法，会通过数组返回
如果我们需要知道一个类中，有哪些构造方法，就可以这样去做了
当然，得到构造，也就是为了创建实例，
我们下面再一起回顾newInstance()方法
newInstance()方法，深入
我们先看一下源码
public T newInstance()
throws InstantiationException, IllegalAccessException
{
if (System.getSecurityManager() != null) {
checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
}
// NOTE: the following code may not be strictly correct under
// the current Java memory model.
// Constructor lookup
if (cachedConstructor == null) {
if (this == Class.class) {
throw new IllegalAccessException(
"Can not call newInstance() on the Class for java.lang.Class"
);
}
try {
Class<?>[] empty = {};
final Constructor<T> c = getConstructor0(empty, Member.DECLARED);
// Disable accessibility checks on the constructor
// since we have to do the security check here anyway
// (the stack depth is wrong for the Constructor's
// security check to work)
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction<Void>() {
public Void run() {
c.setAccessible(true);
return null;
}
});
cachedConstructor = c;
} catch (NoSuchMethodException e) {
throw new InstantiationException(getName());
}
}
Constructor<T> tmpConstructor = cachedConstructor;
// Security check (same as in java.lang.reflect.Constructor)
int modifiers = tmpConstructor.getModifiers();
if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
Class<?> caller = Reflection.getCallerClass();
if (newInstanceCallerCache != caller) {
Reflection.ensureMemberAccess(caller, this, null, modifiers);
newInstanceCallerCache = caller;
}
}
// Run constructor
try {
return tmpConstructor.newInstance((Object[])null);
} catch (InvocationTargetException e) {
Unsafe.getUnsafe().throwException(e.getTargetException());
// Not reached
return null;
}
}
前面的判断权限，判断调用不在对应的Class类型中
也就是
throw new IllegalAccessException(
"Can not call newInstance() on the Class for java.lang.Class");
异常等问题的处理，我们略
下面通过getConstructor0(empty, Member.DECLARED);
获得一个 Constructor<T>，在执行方法（执行的方法，我们后面几节会提到）
这里对应的getConstructor0方法
private Constructor<T> getConstructor0(Class<?>[] parameterTypes,
int which) throws NoSuchMethodException
{
Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
for (Constructor<T> constructor : constructors) {
if (arrayContentsEq(parameterTypes,
constructor.getParameterTypes())) {
return getReflectionFactory().copyConstructor(constructor);
}
}
throw new NoSuchMethodException(getName() + ".<init>" + argumentTypesToString(parameterTypes));
}
这里大致
Constructor<T>[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));
先获得Constructor数组（这里which传入的是Member.DECLARED，所以为false）
这样就会拿到所有的构造，包括非public的
再会
arrayContentsEq(parameterTypes,constructor.getParameterTypes())
for each循环去判断
private static boolean arrayContentsEq(Object[] a1, Object[] a2) {
if (a1 == null) {
return a2 == null || a2.length == 0;
}
if (a2 == null) {
return a1.length == 0;
}
if (a1.length != a2.length) {
return false;
}
for (int i = 0; i < a1.length; i++) {
if (a1[i] != a2[i]) {
return false;
}
}
return true;
}
这里大体的判断逻辑
我们外面对应的Class<?>[] empty = {};
所以，走第一个 return a2 == null || a2.length == 0;
我们没有对应的构造（默认的构造，应该是后面的逻辑添加进去的，不会影响这里的逻辑）
这样，我们可以知道，当我们不写构造的时候，会触发创建对象
并且返回 tmpConstructor.newInstance((Object[])null);*
也就是默认调用参数为null的构造
换句话说，
Class的newInstance，
其实是调用的Constructor.newInstance((Object[])null);
修改构造，测试
这个时候，我们调用 DummyClass2 的 newInstance() 试试
（因为 DummyClass2 有2个构造方法，而对应的Class的newInstance如果参数判断通过的前提下，传入的也是空的构造，这样肯定会报错）
我们运行测试
/**
* 我们调用Class的getConstructor的 newInstance((Object[])null);
* 具体的结果，我们可以看见，和前面DoClass类的newInstance方法结果一样
* @throws IllegalAccessException
* @throws InstantiationException
* @throws NoSuchMethodException
* @throws InvocationTargetException
*/
private void doConstructorNewInstance1() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<?> c1 = DummyClass.class;
DUtils.println(c1.getConstructor().newInstance((Object[])null).toString());
}
我们调用Class的getConstructor的 newInstance((Object[])null);
具体的结果，
DummyClass{age=0, name='null'}
我们可以看见，和前面DoClass类的newInstance方法结果一样
再看看调用DummyClass2的构造方法
/**
* 我们调用Class的getConstructor的 newInstance("dodo");
* 会报错，因为源码中，只有没有写构造的时候，才会按上面的流程走
* @throws IllegalAccessException
* @throws InstantiationException
* @throws NoSuchMethodException
* @throws InvocationTargetException
*/
private void doConstructorNewInstance2E() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
Class<?> c2 = DummyClass2.class;
DUtils.println(c2.getConstructor().newInstance("dodo").toString());
}
对应的结果，是
Exception in thread "main" java.lang.NoSuchMethodException: com.aohuan.dodo.javacode.reflect.utils.DummyClass2.<init>()
at java.lang.Class.getConstructor0(Class.java:2971)
at java.lang.Class.getConstructor(Class.java:1812)
at com.aohuan.dodo.javacode.reflect.sample1.DoConstructor.doConstructorNewInstance2E(DoConstructor.java:61)
at com.aohuan.dodo.javacode.reflect.sample1.DoConstructor.main(DoConstructor.java:23)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
at java.lang.reflect.Method.invoke(Method.java:483)
at com.intellij.rt.execution.application.AppMain.main(AppMain.java:140)
可以发现，对应的逻辑是正确的
那如果构造中，有多个参数怎么办？
我们试试newInstance方法后面，带下参数？
发现，Class就只有newInstance()这一个创建对象的方法
....
那我们回想下前面提到的Constructor类
Constructor 类 newInstance()
那我们尝试一下对应的 Constructor类 调用2个构造的方法试试
/**
* DummyClass2 有2个自己的带参数的构造
* 如果通过getConstructors得到构造的数组，在调用对应的构造，传入参数即可
* @throws IllegalAccessException
* @throws InstantiationException
*/
private void doConstructorNewInstance2R1() throws IllegalAccessException, InstantiationException, InvocationTargetException {
Class<DummyClass2> c2 = DummyClass2.class;
DUtils.println(c2.getConstructors()[1].newInstance("dodo", 23).toString());
}
这个时候，我们可以打印对应的bean2
结果为：
DummyClass{age=23, name='dodo'}
这个时候，我们知道我们有2个构造
同理，我们可以
c2.getConstructors()[0].newInstance("dodo").toString();
拿到index为0的Constructor构造类，
打印也可以得到结果
DummyClass{age=0, name='dodo'}
这里age是一般数据类型，不赋值，结果为0
具体Constructor 类的 public T newInstance(Object ... initargs)
我们就不继续跟了
因为依赖的 ConstructorAccessor 类，和今天讨论的主题 有点远了
再加上 没有源码
就不继续扯了
其他简单说明
Constructor：
- getConstructors() ： 获取 public的 Constructor[]（public）
- getDeclaredConstructors() ： 获取 所有的 Constructor[]
- getConstructor(parameterTypes) ： 根据 参数类型（可变参数）， 获取具体 Constructor（public）
- getDeclaredConstructor(parameterTypes)：根据 参数类型（可变参数）， 获取具体 Constructor
这里
- getConstructors()方法
- 是获取 public的构造函数 数组
- getDeclaredConstructors()方法
- 是获取所有的构造函数 数组
- getConstructor(parameterTypes) 方法
- 是根据 参数类型（可以有多个Class<?>的可变参数），
- 获取具体public的 Constructor
- getDeclaredConstructor(parameterTypes) 方法，
- 是根据 参数类型（可以有多个Class<?>的可变参数），
- 获取具体的 Constructor
简单总结
这里大致了解下
Class的简单使用 和 大体作用
其他的内容，后续一起学习具体代码，可以见
https://github.com/2954722256/use_little_demo
对应 javacode 的 Module，对应的reflect包
