java 类 constructor_java反射与注解（二）：Constructor类理解

Constructor类理解

这里Constructor，我们知道是构造函数

为什么是数组形式的呢？

因为可能有多个构造

这个时候，我们写一个DummyClass2， 这里有2个构造

其他和前面一个Bean类似，有setter，getter，toString方法

这个时候，我们分别打印一下DummyClass和 DummyClass2 的 Constructor

具体打印工具方法

private static void printConstructor(Constructor>[] cons){

for(int i=0; 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 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() {

public Void run() {

c.setAccessible(true);

return null;

}

});

cachedConstructor = c;

} catch (NoSuchMethodException e) {

throw new InstantiationException(getName());

}

}

Constructor 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，在执行方法(执行的方法，我们后面几节会提到)

这里对应的getConstructor0方法

private Constructor getConstructor0(Class>[] parameterTypes,

int which) throws NoSuchMethodException

{

Constructor[] constructors = privateGetDeclaredConstructors((which == Member.PUBLIC));

for (Constructor constructor : constructors) {

if (arrayContentsEq(parameterTypes,

constructor.getParameterTypes())) {

return getReflectionFactory().copyConstructor(constructor);

}

}

throw new NoSuchMethodException(getName() + "." + argumentTypesToString(parameterTypes));

}

这里大致

Constructor[] 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.()

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 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包