13 Java反射机制

最新推荐文章于 2023-06-22 23:32:42 发布

xnudhi

最新推荐文章于 2023-06-22 23:32:42 发布

阅读量127

点赞数

分类专栏： javaSE 文章标签： java

本文链接：https://blog.csdn.net/qq_34106499/article/details/109202015

版权

javaSE 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

文章目录

Java反射机(Java Reflection)制概述
- 动态语言 vs 静态语言
Class类的理解与获取Class的实例
类的加载与ClassLoader的理解
反射的应用

Java反射机(Java Reflection)制概述

关于反射的理解

Reflection（反射）是被视为动态语言的关键，反射机制允许程序在执行期借助于Reflection API取得任何类的内部信息，并能直接操作任意对象的内部属性及方法。

加载完类之后，在堆内存的方法区中就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息。我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所以，我们形象的称之为：反射。

框架 = 反射 + 注解 + 设计模式。
Java反射机制研究及应用
1. 在运行时判断任意一个对象所属的类
2. 在运行时构造任意一个类的对象
3. 在运行时判断任意一个类所具有的成员变量和方法
4. 在运行时获取泛型信息
5. 在运行时调用任意一个对象的成员变量和方法
6. 在运行时处理注解
7. 生成动态代理
相关API
1. java.lang.Class：反射的源头
2. java.lang.reflect.Method;
3. java.lang.reflect.Field;
4. java.lang.reflect.Constructor;
5. …

动态语言 vs 静态语言

动态语言：

是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。通俗点说就是在运行时代码可以根据某些条件改变自身结构。

主要动态语言： Object-C、 C#、 JavaScript、 PHP、 Python、 Erlang。
静态语言：

与动态语言相对应的，运行时结构不可变的语言就是静态语言。如Java、 C、C++。

Class类的理解与获取Class的实例

Class类

对象照镜子后可以得到的信息：某个类的属性、方法和构造器、某个类到底实现了哪些接口。对于每个类而言， JRE 都为其保留一个不变的 Class 类型的对象。一个 Class 对象包含了特定某个结构(class/interface/enum/annotation/primitive type/void/[])的有关信息。
1. Class本身也是一个类
2. Class 对象只能由系统建立对象
3. 一个加载的类在 JVM 中只会有一个Class实例
4. 一个Class对象对应的是一个加载到JVM中的一个.class文件
5. 每个类的实例都会记得自己是由哪个 Class 实例所生成
6. 通过Class可以完整地得到一个类中的所有被加载的结构
7. Class类是Reflection的根源，针对任何你想动态加载、运行的类，唯有先获得相应的Class对象
类的加载过程：

程序经过javac.exe命令以后，会生成一个或多个字节码文件(.class结尾)。接着我们使用java.exe命令对某个字节码文件进行解释运行。相当于将某个字节码文件加载到内存中。此过程就称为类的加载。加载到内存中的类，我们就称为运行时类，此运行时类，就作为Class的一个实例。换句话说，Class的实例就对应着一个运行时类。加载到内存中的运行时类，会缓存一定的时间。在此时间之内，我们可以通过不同的方式来获取此运行时类。
哪些类型可以有Class对象？

① class：外部类、成员（成员内部类、静态内部类）、局部内部类、匿名内部类
② interface：接口
③ [] : 数组
④ enum ：枚举
⑤ annotation：注解@interface
⑥ primitive type: 基本数据类型
⑦ void

Class类的常用方法

方法名	功能说明
static Class forName(String name)	返回指定类名为name的Class对象
Object newInstance()	调用缺省构造函数，返回该Class对象的一个实例
get name ()	返回此Class对象所代表的实体（类，接口，数组类，基本类型或void）名称
Class getSuperClass()	返回当前Class对象的父类的Class对象
Class [] getInterfaces()	获取当前Class对象的接口
ClassLoader getClassLoader()	返回该类的类加载器
Constructor[] getConstructors()	返回一个包含某些Constructor对象的数组
Field[] getDeclaredFields()	返回Field对象的一个数组
Method getMethod(String name,Class … paramTypes)	返回一个Method对象，此对象的形参类型为paramType

获取Class类的实例（四种方式）

通过类

若已知具体的类，通过类的class属性获取，该方法最为安全可靠，程序性能最高

实例：Class clazz = String.class;
通过类的对象

已知某个类的实例，调用该实例的getClass()方法获取Class对象

实例：Class clazz = "hello world".getClass();
通过Class的静态方法

已知一个类的全类名，且该类在类路径下，可通过Class类的静态方法forName()获取，可能抛出ClassNotFoundException

实例：Class clazz = Class.forName(java.lang.String);
通过类的加载器（了解）

ClassLoader cl = this.getClass().getClassLoader(); Class clazz = cl.loadClass("java.lang.String");

类的加载与ClassLoader的理解

了解类的加载过程

当程序主动使用某个类时，如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化。

加载（Load）：

将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象，作为方法区中类数据的访问入口（即引用地址）。所有需要访问和使用类数据只能通过这个Class对象。这个加载的过程需要类加载器参与。

链接（Link）：

将Java类的二进制代码合并到JVM的运行状态之中的过程。
① 验证：确保加载的类信息符合JVM规范，例如：以cafe开头，没有安全方面的问题
② 准备：正式为类变量（static）分配内存并设置类变量默认初始值的阶段，这些内存都将在方法区中进行分配。
③ 解析：虚拟机常量池内的符号引用（常量名）替换为直接引用（地址）的过程。

初始化（Initialize）：

① 执行类构造器<clinit>()方法的过程。类构造器<clinit>()方法是由编译期自动收集类中所有类变量的赋值动作和静态代码块中的语句合并产生的。（类构造器是构造类信息的，不是构造该类对象的构造器）。
② 当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
③ 虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确加锁和同步
什么时候发生类的初始化

（1）类的主动引用（一定会发生类的初始化）

① 当虚拟机启动，先初始化main方法所在的类
② new一个类的对象
③ 调用类的静态成员（除了final常量）和静态方法
④ 使用java.lang.reflect包的方法对类进行反射调用
⑤ 当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类

（2）类的被动引用（不会发生类的初始化）

① 当访问一个静态域时，只有真正声明这个域的类才会被初始化
```
 > 当通过子类引用父类的静态变量， 不会导致子类初始化
```
② 通过数组定义类引用，不会触发此类的初始化
③ 引用常量不会触发此类的初始化（常量在链接阶段就存入调用类的常
量池中了）
类的加载器的作用

类加载器作用是用来把类(class)装载进内存的。 JVM 规范定义了如下类型的类的加载器。

实例

  @Test
  public void test1() throws ClassNotFoundException, IOException {
      //1 获取系统加载器
      ClassLoader classLoader  = this.getClass().getClassLoader();
      System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
      //2 获取系统加载器的父类，即扩展加载器
      classLoader = classLoader.getParent();
      System.out.println(classLoader);//sun.misc.Launcher$ExtClassLoader@a09ee92
      //3 获取扩展加载器的父类，即引导加载器
      classLoader = classLoader.getParent();
      System.out.println(classLoader);//null，引导加载器无法获得
      //4 获取测试当前类是由哪个类的加载器加载的
      classLoader = Class.forName("com.lipu.java.ReflectTest.ClassLoaderTest").getClassLoader();
      System.out.println(classLoader);//sun.misc.Launcher$AppClassLoader@18b4aac2
      //5 测试JDK提供的Object类是由哪个类的加载器加载的
      classLoader = Class.forName("java.lang.Object").getClassLoader();
      System.out.println(classLoader);//null，引导加载器无法获得
      //6 使用类的加载器获取指定路径下文件的输入流
      classLoader = this.getClass().getClassLoader();
      InputStream is = classLoader.getResourceAsStream("users.properties");
      Properties pro = new Properties();
      pro.load(is);
      String name = pro.getProperty("name");
      String password = pro.getProperty("password");
      System.out.println("name = " + name + ", password = " + password);//name = 张三, password = 123123

  }

反射的应用

1、创建运行时类的对象

创建类的对象：调用Class对象的newInstance()方法

要求：

1）类必须要有一个无参构造器
2）类的无参构造器的访问权限必须足够

/**
 * 使用Class创建运行时类的对象
 * @throws IllegalAccessException
 * @throws InstantiationException
 */
@Test
public void test3() throws IllegalAccessException, InstantiationException {
    //1 获取Person的Class的对象
    Class<Person> clazz = Person.class;
    //2 使用对应类的Class创建类的对象，要求有空参构造器，且权限修饰符为public
    Person p = clazz.newInstance();
    System.out.println(p);
}

    /**
 * 通过构造器创建运行时类的对象
 * @throws ClassNotFoundException
 * @throws IllegalAccessException
 * @throws InvocationTargetException
 * @throws InstantiationException
 * @throws NoSuchMethodException
 */
@Test
public void test2() throws ClassNotFoundException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
    //1 根据全类名获取对应的Class对象
    Class clazz = Class.forName("com.lipu.java.ReflectTest.Person");
    //2 调用指定参数结构的构造器，生成Constructor的实例
    Constructor con = clazz.getDeclaredConstructor(String.class, Integer.class);//为什么对应的构造器也需要使用Integer?不理解
    //3 通过Constructor类的实例创建对应类的对象，并初始化类的属性
    Person p = (Person) con.newInstance("张三", 24);
    System.out.println(p);
}

2、获取运行时类的完整结构

我们可以通过反射，获取对应的运行时类中所有的属性、方法、构造器、父类、接口、父类的泛型、包、注解、异常等。。。。

> 实现的全部接口
> 所继承的父类
> 全部的构造器
> 全部的方法
> 全部的Field

获取类的属性

public Field[] getFields()
返回此Class对象所表示的类或接口的public的Field。

public Field[] getDeclaredFields()
返回此Class对象所表示的类或接口的全部Field。

Field方法中：
public int getModifiers()以整数形式返回此Field的修饰符
public Class<?> getType() 得到Field的属性类型
public String getName()返回Field的名称。

 /**
  * 获取属性结构
  */
 @Test
 public void test1() throws NoSuchFieldException {
     Class<Person> p = Person.class;
     //getFields():获取当前运行时类及其父类中声明为public访问权限的属性
     Field[] fields = p.getFields();
     for(Field f: fields){
         System.out.println(f);
     }
     System.out.println("********************");
     //getDeclaredFields():获取当前运行时类中声明的所属性。（不包含父类中声明的属性)
     Field[] fields2 =p.getDeclaredFields();
     for(Field f : fields2){
         System.out.println(f);
     }

 }

获取类的方法

public Method[] getDeclaredMethods()
返回此Class对象所表示的类或接口的全部方法

public Method[] getMethods()
返回此Class对象所表示的类或接口的public的方法

Method类中：
public Class<?> getReturnType()取得全部的返回值
public Class<?>[] getParameterTypes()取得全部的参数
public int getModifiers()取得修饰符
public Class<?>[] getExceptionTypes()取得异常信息

 /**
  * 获取类的方法
  */
 @Test
 public void test2(){
     //获取对应类的Class
     Class<Person> clazz = Person.class;
     //getMethods():获取当前运行时类及其所父类中声明为public权限的方法
     Method[] methods = clazz.getMethods();
     for(Method m : methods){
         System.out.println(m);
     }
     System.out.println("******************");
     //getDeclaredMethods():获取当前运行时类中声明的所方法。（不包含父类中声明的方法
     Method[] methods2 = clazz.getDeclaredMethods();
     for(Method m : methods2){
         System.out.println(m);
     }
 }

获取类的构造器结构

public Constructor<T>[] getConstructors()
返回此 Class 对象所表示的类的所有public构造方法。

public Constructor<T>[] getDeclaredConstructors()
返回此 Class 对象表示的类声明的所有构造方法。

Constructor类中：
取得修饰符: public int getModifiers();
取得方法名称: public String getName();
取得参数的类型： public Class<?>[] getParameterTypes();

 /**
  * 获取构造器结构
  */
 @Test
 public void test3(){
     Class<Person> clazz = Person.class;
     //getConstructors():获取当前运行时类中声明为public的构造器
     Constructor[] cons = clazz.getConstructors();
     for(Constructor c: cons){
         System.out.println(c);
     }
     System.out.println("*****************");
     //getDeclaredConstructors():获取当前运行时类中声明的所的构造器
     Constructor[] cons2 = clazz.getDeclaredConstructors();
     for(Constructor c : cons2){
         System.out.println(c);
     }

 }

获取运行时类的父类

public Class<? Super T> getSuperclass()
返回表示此 Class 所表示的实体（类、接口、基本类型）的父类的Class

 /**
  * 获取运行时类的父类
  */
 @Test
 public void test4(){
     Class clazz = Person.class;
     Class superclass = clazz.getSuperclass();
     System.out.println(superclass);

 }

获取运行时类的但泛型的父类

 /**
  * 获取运行时类的带泛型的父类
  */
 @Test
 public void test5(){
     Class clazz = Person.class;
     Type genericSuperclass = clazz.getGenericSuperclass();
     System.out.println(genericSuperclass);
 }

获取运行时类的带泛型的父类的泛型

获取父类泛型类型： Type getGenericSuperclass()

泛型类型： ParameterizedType

获取实际的泛型类型参数数组： getActualTypeArguments()

 /**
  * 获取运行时类的带泛型的父类的泛型
  */
 @Test
 public void test6(){
     Class clazz = Person.class;
     //获取带泛型的父类
     Type genericSuperclass = clazz.getGenericSuperclass();
     //获取泛型类型
     ParameterizedType paraType = (ParameterizedType) genericSuperclass;
     Type[] actualTypeArguments = paraType.getActualTypeArguments();
     System.out.println(((Class)actualTypeArguments[0]).getName());
 }

获取运行时类实现的接口

public Class<?>[] getInterfaces()
确定此对象所表示的类或接口实现的接口。

 /*
 获取运行时实现的接口
  */
 @Test
 public void test7(){
     Class<Person> clazz = Person.class;
     Class[] interfaces = clazz.getInterfaces();
     for(Class c : interfaces){
         System.out.println(c);
     }
     System.out.println("************");
     //获取运行时父类实现的接口
     Class[] superInterface = clazz.getSuperclass().getInterfaces();
     for(Class c: superInterface){
         System.out.println(c);
     }

 }

获取运行时类所在的包

 /**
  * 获取运行时类所在的包
  */
 @Test
 public void test8(){
     Class<Person> clazz = Person.class;
     Package pack = clazz.getPackage();
     System.out.println(pack);

 }

获取运行时类声明的注解

get Annotation(Class<T> annotationClass)
getDeclaredAnnotations()

 /**
  * 获取运行时类声明的注解

  */
 @Test
 public void test9(){
     Class<Person> clazz = Person.class;
     Annotation[] annotations = clazz.getAnnotations();
     for(Annotation a : annotations){
         System.out.println(a);
     }
 }

3、调用运行时类的制定结构

调用指定的属性

在反射机制中，可以直接通过Field类操作类中的属性，通过Field类提供的set()和get()方法就可以完成设置和取得属性内容的操作。

public Field getField(String name)返回此Class对象表示的类或接口的指定的public的Field。
public Field getDeclaredField(String name)返回此Class对象表示的类或接口的指定的Field。

在Field中：
public Object get(Object obj)取得指定对象obj上此Field的属性内容
public void set(Object obj,Object value)设置指定对象obj上此Field的属性内容

 /**
  * 调用并修改指定的成员变量
  */
 @Test
 public void test1() throws IllegalAccessException, InstantiationException, NoSuchFieldException {
     Class<Person> clazz = Person.class;
     //创建运行时类的对象
     Person p = clazz.newInstance();
     //1. getDeclaredField(String fieldName):获取运行时类中指定变量名的属性
     Field name =  clazz.getDeclaredField("name");
     //2 确保该属性可访问
     name.setAccessible(true);
     //3 设置指定对象的此属性
     name.set(p, "张三");
     System.out.println(p);

 }

调用指定的方法

通过反射，调用类中的方法，通过Method类完成。步骤：

通过Class类的getMethod(String name,Class…parameterTypes)方法取得一个Method对象，并设置此方法操作时所需要的参数类型。

之后使用Object invoke(Object obj, Object[] args)进行调用，并向方法中传递要设置的obj对象的参数信息。

Object invoke(Object obj, Object … args)说明:

Object 对应原方法的返回值，若原方法无返回值，此时返回null
若原方法若为静态方法，此时形参Object obj可为null
若原方法形参列表为空，则Object[] args为null
若原方法声明为private,则需要在调用此invoke()方法前，显式调用方法对象的setAccessible(true)方法，将可访问private的方法。

 /**
  * 调用指定的方法
  */
 @Test
public void test2() throws NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
     Class<Person> clazz = Person.class;
     //1 获取运行时类的对象
     Person p = clazz.newInstance();

     //2 获取指定的某个方法
     //getDeclaredMethod():参数1 ：指明获取的方法的名称  参数2：指明获取的方法的形参列表
    Method show = clazz.getDeclaredMethod("show",String.class);
    //3 确保当前方法是可访问的
    show.setAccessible(true);
    //4 调用方法的invoke():
    // 参数1：方法的调用者  参数2：给方法形参赋值的实参
    // invoke()的返回值即为对应类中调用的方法的返回值。
    Object returnVal = show.invoke(p, "中国");
    System.out.println(returnVal);

    System.out.println("**********调用静态方法**********");
    // private static void showDesc()
    Method showDesc = clazz.getDeclaredMethod("showDesc");
    showDesc.setAccessible(true);
    //如果调用的运行时类中的方法没返回值，则此invoke()返回null
    //Object returnVal = showDesc.invoke(null);
    Object returnValue = showDesc.invoke(Person.class);
    System.out.println(returnValue);//null
}

调用指定的构造器

 /**
  * 调用指定的构造器
  */
 @Test
 public void test3() throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
     Class<Person> clazz = Person.class;
     //1 获取指定的构造器
     //    private Person(String name，Integer id);
     //    getDeclaredConstructor():参数：指明构造器的参数列表
     Constructor<Person> cons = clazz.getDeclaredConstructor(String.class, Integer.class);
     //2 确保构造器是可访问的
     cons.setAccessible(true);
     //3.调用此构造器创建运行时类的对象
     Person p = cons.newInstance("张三", 23);
     System.out.println(p);

 }

4、动态代理

代理设计模式的原理:

使用一个代理将对象包装起来, 然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

<font color = blue>静态代理</font>，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。 最好可以通过一个代理类完成全部的代理功能。

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。
动态代理使用场合:

调试

远程方法调用
动态代理相比于静态代理的优点：

抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

Java动态代理相关API

Proxy ：专门完成代理的操作类，是所有动态代理类的父类。通过此类为一个或多个接口动态地生成实现类。
提供用于创建动态代理类和动态代理对象的静态方法

static Class<?> getProxyClass(ClassLoader loader, Class<?>... interfaces)创建一个动态代理类所对应的Class对象

static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)直接创建一个动态代理对象

动态代理的实现

静态代理

静态代理的缺点：

① 代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。

② 每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。

代码实现：

 //代理类和被代理类需要实现的接口
 interface ClothFactory{
     void produceCloth();
 }
 //代理类
 class ProxyClothFactory implements ClothFactory{
 
     NikeClothFactory nike;//用被代理类对象进行实例化
 
     public ProxyClothFactory(NikeClothFactory nike) {
         this.nike = nike;
     }
 
     @Override
     public void produceCloth() {
 
         System.out.println("代理工厂做一些前准备");
 
         nike.produceCloth();
 
         System.out.println("代理工厂的收尾工作");
 
     }
 }
 //被代理类
 class NikeClothFactory implements ClothFactory{
 
     @Override
     public void produceCloth() {
 
         System.out.println("耐克工厂生产耐克衣服中...");
 
     }
 }
 public class StaticProxyTest {
     public static void main(String[] args) {
         //创建被代理类的对象
         NikeClothFactory nike = new NikeClothFactory();
         //创建代理类的对象
         ProxyClothFactory proxyCloth = new ProxyClothFactory(nike);
         proxyCloth.produceCloth();
     }
 }

动态代理:

步骤：

创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。
创建被代理的类以及接口
通过Proxy的静态方法newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理
通过 Subject代理调用RealSubject实现类的方法

特点：动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

需要解决的两个主要问题：

问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
（通过Proxy.newProxyInstance()实现）
问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
(通过InvocationHandler接口的实现类及其方法invoke())

动态代理与AOP

 /**
  * 动态代理的举例
  * @author lip
  * @creat 2020-10-22 11:44
  */
 //通用接口
 interface Human{
     String getBelief();
     void eat(String food);
 
 }
 //被代理类
 class SuperMan implements Human{
 
     @Override
     public String getBelief() {
         return "I belive I can fly";
     }
 
     @Override
     public void eat(String food) {
         System.out.println("I like eat " + food);
     }
 }
 //通用方法（需要执行的重复代码）
 class HumanUtil{
     public void method1(){
         System.out.println("*************通用方法一*************");
     }
     public void method2(){
         System.out.println("*************通用方法二*************");
     }
 }
 
 /*
 要想实现动态代理，需要解决的问题？
 问题一：如何根据加载到内存中的被代理类，动态的创建一个代理类及其对象。
 问题二：当通过代理类的对象调用方法a时，如何动态的去调用被代理类中的同名方法a。
 
 
  */
 
 //代理类生产工厂
 class ProxyFactory{
     //调用此方法，返回一个代理类，解决问题一
     public static Object getProxyInstance(Object obj){//obj为被代理类
         MyInvocationHandler vocationHandler = new MyInvocationHandler();
         vocationHandler.bind(obj);
         return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), vocationHandler);
     }
 }
 //实现InvocationHandler接口,重写invoke()方法，实现实际调用被代理类的动作
 class MyInvocationHandler implements InvocationHandler{
 
     Object obj;//需要使用被代理类的对象进行赋值
 
     public void bind(Object obj){
         this.obj = obj;
     }
     //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
     //将被代理类要执行的方法a的功能就声明在invoke()中
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//proxy怎么用呢？
 
         HumanUtil util = new HumanUtil();
         util.method1();
 
         //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
         //obj:被代理类的对象
         Object returnVal = method.invoke(obj, args);
 
         util.method2();
         //上述方法的返回值就作为当前类中的invoke()的返回值。
         return returnVal;
     }
 }
 public class ProxyTest {
     public static void main(String[] args) {
         //创建被代理类
         SuperMan superMan = new SuperMan();
         当通过代理类对象调用方法时，会自动的调用被代理类中同名的方法
         Human proxyInstance = (Human)ProxyFactory.getProxyInstance(superMan);
         proxyInstance.eat("麻辣烫");
         System.out.println(proxyInstance.getBelief());
 
         System.out.println("==========生产其他类的代理=============");
         //创建被代理类
         NikeClothFactory nike = new NikeClothFactory();
         //创建代理类
         ClothFactory proxyInstance1 = (ClothFactory) ProxyFactory.getProxyInstance(nike);
         
         proxyInstance1.produceCloth();
 
     }
 
 }

--------------------------------------------------------华丽分割线-------------------------------------------------------------------
系统复习java第一弹，本文资源来源于尚硅谷公开课程：尚硅谷_Java零基础教程-java入门必备-初学者从入门到精通全套完整版(宋红康主讲)