Java反射-调用构造方法、获取继承关系、动态代理

• • 一、调用构造方法
  • 二、获取继承关系
  • 三、动态代理

1、通过Class类提供的newInstance()方法可以实例化一个类

Person p = Person.class.newInstance();
//局限性在于 实例化只能调用 public属性的 无参构造方法

2、通过构造器来调用构造方法 Constructor 对象

• getConstructor(Class...)：获取某个public的Constructor；
• getDeclaredConstructor(Class...)：获取某个Constructor；
• getConstructors()：获取所有public的Constructor；
• getDeclaredConstructors()：获取所有Constructor。

注意：Constructor总是调用当前类的构造方法，不存在多态的问题；调用非public的Constructor时，必须首先通过setAccessible(true)设置允许访问。setAccessible(true)可能会失败。

import java.lang.reflect.Constructor;
public class GetConstructor {
    public static void main(String[] args) throws Exception {
        System.out.println("-----------测试使用Constructor构造器------------");
        Constructor c1 = Integer.class.getConstructor(String.class); //接受的参数类型是Class类
        Integer i = (Integer) c1.newInstance("123");
        System.out.println(i);
    }
}

在Class类中提到过，获取Class类有三种方法,同时注意JVM对于每个加载的Class只创建一个Class实例，因此下面三种方式获取到的是一个Class类：

• getClass()方法获取
• forName(参数：完全限定名)方法获取
• class属性获取

1、获取父类的Class getSuperclass()

2、获取所有实现的接口的Class getInterfaces(),只能获取当前类实现的接口，不能获得父类实现的接口

3、通过Class对象的isAssignableFrom()方法可以判断一个向上转型是否可以实现

public class GetExtend {
    public static void main(String[] args) {
        System.out.println("------------测试通过反射获取继承------------");
        Class c1 = Integer.class;
        //获取父类的Class， 因此还是Class类
        Class sc1 = c1.getSuperclass();
        System.out.println(sc1);
        //获取当前类实现的接口
        Class[] i = c1.getInterfaces();
        System.out.println(i.length);
        for(Class j : i){
            System.out.println(j);
        }
        // 通过 isAssignableFrom 判断向上转型是否成功
        System.out.println(Integer.class.isAssignableFrom(Number.class));  //False
        //Number对象 转到Integer 是向下转型，所以结果为False
        System.out.println(Number.class.isAssignableFrom(Integer.class));
    }
}

主要通过 Proxy.newProxyInstance()来实现，动态代理相对于静态而言，指的是在运行期间，创建某个 interface实例

package reflect;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

public class DynamicProxy {
   public static void main(String[] args) {
       InvocationHandler handle = new InvocationHandler() {
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               System.out.println(method);
               if (method.getName().equals("morning")){
                   System.out.println("Good morning");
                   System.out.println(args.length);
                   for(Object i: args){
                       System.out.println(i);
                   }
               }
               return null;
           }
       };
       Hello hello = (Hello) Proxy.newProxyInstance(
               Hello.class.getClassLoader(),
               new Class[]{Hello.class},
               handle
       );
       hello.morning("3ackr0d");

   }

}
interface Hello{
   void morning(String name);
}