getConstructor报错

package lius.day05;

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

public class reflexed {
    public static void main(String[] args) {
        try{
            Class<?> clz = Class.forName("lius.day05.apple");   //clz可指向任意类型,?是通配符
            Method method = clz.getMethod("change", int.class);    //获取已经加载的类的方法
            Constructor constructor = clz.getConstructor(int.class);    //获取已经加载的类的构造器
            Object object = constructor.newInstance(7);    //通过刚刚获得的构造器来生成实例
            method.invoke(object,4);     //将刚刚生成的实例和参数传入method.invoke中,method代表了apple类里面的change(int b)方法
        }catch(ClassNotFoundException e){
            System.out.println("class not found");
        }catch(NoSuchMethodException | IllegalAccessException |InvocationTargetException | InstantiationException e){
            e.printStackTrace();
        }
    }

}
class apple{
    private int an = 10;
    public apple(int a)
    {
        an = a;
        System.out.println("apple has been build as:" + a);
    }


    static  //类的静态加载器,只要类被加载就会跑
    {
        System.out.println("this is a static class loader");
    }
    public void change(int b)
    {
        an = b;
        System.out.println("apple has been change as:" + b);
    }
}

当没有默认构造函数时

getConstructor()   //error

需要传进去一个int,因为如果没有参数,就无法构造出一个实例

Constructor constructor = clz.getConstructor(int.class);
Object object = constructor.newInstance(7);    //正确<br>
package lius.day05;

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

public class ProxyDynamic implements InvocationHandler {
    private Object object;      //使用了通用的ProxyDynamic类包装HumanImply实例
    public ProxyDynamic(Object target)
    {
        this.object = target;
    }
    public Object invoke(Object obj, Method method,Object[] args) throws Throwable
    {
        if(method.getName().equals("eat"))
            before();   //加入业务逻辑
        Object res = method.invoke(object,args);    //也可以手动new一个目标对象传进去,在这个方法中调用了被代理对象的方法
        if(method.getName().equals("eat"))
            after();
        return res;
    }
    private void before()
    {
        System.out.println("cook");
    }
    private void after()
    {
        System.out.println("cleaning");
    }

    public static void main(String[] args) {
        Human human = new HumanImply();     //Human接口的实现
        ProxyDynamic dynamic = new ProxyDynamic(human);     //动态代理器的实例,这里这个动态代理可以代理任何类,内部有有invoke方法,实现了InvocationHandler接口

        System.out.println("=========================hand=======================");

        try {
            Object[] argsD = new Object[1];
            argsD[0] = new String("shit");
            dynamic.invoke(human.getClass(),human.getClass().getMethod("eat", String.class),argsD);
        }catch (Throwable e){
            e.printStackTrace();
        }

        System.out.println("=========================auto=======================");

        //loader:用哪个类加载器去加载代理对象
        //interface:动态代理类需要实现的接口
        //InvocationHandler h:动态代理方法在执行时,会调用h里面的invoke方法去执行
        //InvocationHandler是个接口,需要实现
        //Proxy.newProxyInstance可以理解为一个打包器,new ProxyDynamic(human)是生成代理(人),new HumanImply()是生成被代理(人),而下面这个是将两者绑在一起,生成一个目标对象
        //这个目标对象已经被代理了
        Human HumanProxy = (Human) Proxy.newProxyInstance(human.getClass().getClassLoader(),human.getClass().getInterfaces(),dynamic);   //实例化了一个具体的代理类(代理对象)
        HumanProxy.eat("apple");
        HumanProxy.walk(2);
        //将被代理的对象作为参数传入就可以执行里面的任意方法,所有的方法调用都通过invoke来完成。不用对每个方法进行处理

        System.out.println("=========================other=======================");


    }
}