public class Person<T> {
 
}
 
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
 
public class Student extends Person<Student> {
public static void main(String[] args) {
Student st=new Student();
Class clazz=st.getClass();
//getSuperclass()获得该类的父类
System.out.println(clazz.getSuperclass());
//getGenericSuperclass()获得带有泛型的父类
//Type是 Java 编程语言中所有类型的公共高级接口。它们包括原始类型、参数化类型、数组类型、类型变量和基本类型。
Type type=clazz.getGenericSuperclass();
System.out.println(type);
//ParameterizedType参数化类型，即泛型
ParameterizedType p=(ParameterizedType)type;
//getActualTypeArguments获取参数化类型的数组，泛型可能有多个
Class c=(Class) p.getActualTypeArguments()[0];
System.out.println(c);
}
}

// 代理的接口
public interface ManToolsFactory { 
    void saleManTools(String size);
}


public class AaFactory implements ManToolsFactory {
    @Override
    public void saleManTools(String size) {
        System.out.println("按需求定制了一个size为"+size+"的model");
    }
}

// 代理类
public class MarkCompany implements InvocationHandler {

    /*持有的真实对象*/
    private Object factory;

    public Object getFactory() {
        return factory;
    }

    public void setFactory(Object factory) {
        this.factory = factory;
    }

    /*通过Proxy获得动态代理对象*/
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(factory.getClass().getClassLoader(),
                factory.getClass().getInterfaces(),this);
    }

    /*通过动态代理对象方法进行增强*/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
  
        Object result = method.invoke(factory, args);
        return result;
    }
    
    
 public class Client {

    public static void main(String[] args) {
        /*动态代理模式---------------*/
        ManToolsFactory aafactory = new AaFactory();
        MarkCompany markCompany = new MarkCompany();

        markCompany.setFactory(aafactory);
        ManToolsFactory employee1
                = (ManToolsFactory)markCompany.getProxyInstance();
        employee1.saleManTools("E");
    }
  }