java反射的深入（二）

雨点打透心脏的1/2处 2022-07-03 12:17 238阅读 0赞

通过反射调用类的方法

在正常情况下一个类的对象功能产生之后，就可以直接调用类中的方法了，若想要调用，则必须知道方法名称，之后用Class类中的 getMethod()方法 ，

public Method getMethod（String name ，Class<？> … parameterTypes）

然后invoke（Method对象）来执行方法，

接上例：

  1. package com.java.reflect;
  3. import java.lang.reflect.Method;
  5. public class InvokesayChinaDemo {
  6.     public static void main(String[] args) {
  7.         Class<?> c1 = null;
  8.         try {
  9.             c1 = Class.forName("com.java.reflect.PersonDemo1");// 实例化对象
  10.         } catch (ClassNotFoundException e) {
  11.             e.printStackTrace();
  12.         }
  13.         try {
  14.             Method met = c1.getMethod("sayChina");// 找到sayChina方法
  15.             met.invoke(c1.newInstance());// 调用方法
  16.         } catch (Exception e) {
  17.             e.printStackTrace();
  18.         }
  19.     }
  20. }

通过Class类的getMethod()方法根据一个类中的方法名称可以取得Method对象，并通过invoke调用指定的方法，但是在使用invoke（）方法的时候必须传入一个类的实例化对象，因为在sayChina()方法上没有任何的参数，所以没有设定参数类型和参数内容。

改进后：

  1. package com.java.reflect;
  3. import java.lang.reflect.Method;
  5. public class InvokesayChinaDemo {
  6.     public static void main(String[] args) {
  7.         Class<?> c1 = null;
  8.         try {
  9.             c1 = Class.forName("com.java.reflect.PersonDemo1");// 实例化Class对象
  10.         } catch (ClassNotFoundException e) {
  11.             e.printStackTrace();
  12.         }
  13.         try {
  14.             Method met = c1.getMethod("sayChina");// 找到sayChina方法
  15.             met.invoke(c1.newInstance());// 调用方法
  17.             Method meth = c1.getMethod("sayHello", String.class, int.class);
  18.             String rv = null;
  19.             rv = (String) meth.invoke(c1.newInstance(), "汪兵", 25);//调用方法
  20.             System.out.println(rv);
  21.         } catch (Exception e) {
  22.             e.printStackTrace();
  23.         }
  24.     }
  25. }

通过反射调用类setter和getter

  1. package com.java.reflect;
  3. import java.lang.reflect.Method;
  5. public class InvokeSetterGetterDemo {
  6.     public static void main(String[] args) {
  7.         Class<?> c1 = null;
  8.         Object obj = null;
  9.         try {
  10.             c1 = Class.forName("com.java.reflect.PersonDemo1");// 实例化Class对象
  11.         } catch (ClassNotFoundException e) {
  12.             e.printStackTrace();
  13.         }
  14.         try {
  15.             obj = c1.newInstance();
  16.         } catch (Exception e) {
  17.             e.printStackTrace();
  18.         }
  19.         setter(obj, "name", "李兴华", String.class);// 设置setter方法
  20.         setter(obj, "age", 25, int.class);// 设置setter方法
  21.         System.out.println("年龄：");
  22.         getter(obj, "age");
  23.         System.out.println("姓名：");
  24.         getter(obj, "name");
  25.     }
  27.     public static void getter(Object obj, String att) {
  28.         try {
  29.             Method met = obj.getClass().getMethod("get" + initStr(att));
  30.             System.out.println(met.invoke(obj));// 调出getter的内容
  31.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.         }
  34.     }
  36.     /**
  37.      * Object obj：要操作的对象 String att：要操作的属性 Object value：设置属性值
  38.      * Class<?>type：设置属性类型
  39.      */
  40.     public static void setter(Object obj, String att, Object value,
  41.             Class<?> type) {
  42.         Method met = null;
  43.         try {
  44.             met = obj.getClass().getMethod("set" + initStr(att), type);// 得到setter方法
  45.             // 设置setter内容
  46.             met.invoke(obj, value);
  47.         } catch (Exception e) {
  48.             e.printStackTrace();
  49.         }
  51.     }
  53.     public static String initStr(String old) {// 将单词的首字母大写
  54.         String str = old.substring(0, 1).toUpperCase() + old.substring(1);
  55.         return str;
  57.     }
  58. }

通过反射调用属性

如果现在假设要操作一个类中的属性，则也可以通过Filed完成，而不必麻烦的通过setter和getter方法

得到公共属性:

public Field getField （String name ）

得到本类属性:

public Field getDeclaredField （String name ）

取得属性内容：

public Object get（Object obj）

设置属性内容：

public void set（object obj，object value）

  1. package com.java.reflect;
  3. import java.lang.reflect.Field;
  5. public class InvokeFieldDemo {
  6.     public static void main(String[] args) {
  7.     Class<?> c1 = null;
  8.     Object obj = null;
  9.     try {
  10.         c1 = Class.forName("com.java.reflect.PersonDemo1");
  11.     } catch (ClassNotFoundException e) {
  12.         e.printStackTrace();
  13.     }
  14.     try {
  15.         obj = c1.newInstance();
  16.     } catch (InstantiationException e) {
  17.         e.printStackTrace();
  18.     } catch (IllegalAccessException e) {
  19.         e.printStackTrace();
  20.     }
  21.     Field nameField = null;
  22.     Field ageField = null;
  23.     try {
  24.         nameField = c1.getDeclaredField("name");
  25.         ageField = c1.getDeclaredField("age");
  26.         nameField.setAccessible(true);// 设置私有属性可见
  27.         ageField.setAccessible(true);
  28.         nameField.set(obj, "sdfsdfsd");
  29.         ageField.set(obj, 23);
  30.         System.out.println("姓名：" + nameField.get(obj));
  31.         System.out.println("年龄" + ageField.get(obj));
  32.     } catch (NoSuchFieldException | SecurityException
  33.         | IllegalArgumentException | IllegalAccessException e) {
  34.         e.printStackTrace();
  35.     }
  37.     }
  38. }

通过反射操作数组

反射机制不光只使用在类中，也可以应用在任意的引用数据类型上，当然包含了数组，数组使用Array类完成

  1. public Class<?> getComponentType()

得到数组指定下标的内容：

  1. public static Object get(Object array,
  2.          int index)
  3.                   throws IllegalArgumentException,
  4.                          ArrayIndexOutOfBoundsException
  6. public static void set(Object array,
  7.               int index,
  8.               boolean z)
  9.                        throws IllegalArgumentException,
  10.                               ArrayIndexOutOfBoundsException

开辟新的数组：

  1. public static Object newInstance(Class<?> componentType,
  2.                  int... dimensions)
  3.                           throws IllegalArgumentException,
  4.                                  NegativeArraySizeException

取得数组的内容：

  1. package com.java.reflect;
  3. import java.lang.reflect.Array;
  5. public class ClassArrayDemo {
  6.     public static void main(String[] args) {
  7.     int temp[] = { 1, 2, 3 };
  8.     Class<?> c = temp.getClass().getComponentType();// 取得数组的Class对象
  9.     System.out.println("类型：" + c.getName());// 取得数组类型的名称
  10.     System.out.println("长度：" + Array.getLength(temp));
  11.     System.out.println("第一个内容是：" + Array.getInt(temp, 1));// 得到第一个数组的内容
  12.     Array.set(temp, 2, 20);
  13.     System.out.println(temp[2]);
  14.     }
  15. }

使用Array类还可以修改数组的大小：（实际上就是新建一个新的数组，将旧的数据复制进去）

  1. package com.java.reflect;
  3. import java.lang.reflect.Array;
  5. public class ChangeArrayDemo {
  6.     public static void main(String[] args) {
  7.     int temp[] = { 1, 2, 3 };
  8.     int newTemp[] = (int[]) arrayInc(temp, 5);// 重新开辟空间
  9.     print(newTemp);
  10.     }
  12.     public static Object arrayInc(Object obj, int len) {// 建立新的数组并拷贝
  13.     Class<?> c = obj.getClass();
  14.     Class<?> arr = c.getComponentType();// 得到数组的Class
  15.     Object newO = Array.newInstance(arr, len);// 拷贝内容
  16.     int co = Array.getLength(obj);
  17.     System.arraycopy(obj, 0, newO, 0, co);// 拷贝数组
  18.     return newO;
  19.     }
  21.     public static void print(Object obj) {// 数组输出
  22.     Class<?> c = obj.getClass();
  23.     if (!c.isArray()) {// 判断是否是数组
  24.         return;
  25.     }
  26.     Class<?> arr = c.getComponentType();
  27.     System.out.println(arr.getName() + "数组长度是：" + Array.getLength(obj));
  28.     for (int i = 0; i < Array.getLength(obj); i++) {
  29.         System.out.print(Array.get(obj, i) + "、");// 通过Array输出
  31.     }
  32.     }
  33. }

代理设计：

一个操作的接口有两个子类，其中一个是真是主题的实现类，另一个是代理类，代理实现类要完成比真实主体实现类更多的内容，而且本身还需要处理一些与具体业务有关的程序代码。

  1. package com.java.reflect;
  3. interface Subject {
  4.     public String say(String name, int age);
  5. }
  7. class RealSubject implements Subject {
  9.     @Override
  10.     public String say(String name, int age) {
  11.     return "姓名：" + name + ",年龄：" + age;
  12.     }
  13. }
  15. class ProxySubject implements Subject {
  16.     private Subject sub = null;
  18.     public ProxySubject(Subject sub) {
  19.     this.sub = sub;
  20.     }
  22.     @Override
  23.     public String say(String name, int age) {
  24.     return this.sub.say(name, age);
  25.     }
  26. }
  28. public class DyProxyDemo {
  29.     public static void main(String[] args) {
  30.     Subject sub = new ProxySubject(new RealSubject());
  31.     String info = sub.say("李兴华", 99);
  32.     System.out.println(info);
  33.     }
  34. }

以上代码称为静态代理，一个代理只能为一个接口服务，

InvocationHandler接口：

public interface InvocationHandler{ 

  1. Object invoke(Object proxy,
  2.               Method method,
  3.               Object[] args)
  4.               throws Throwable

}

Object proxy：被代理的接口

Method method：要调用的方法

Object[] args：方法调用时所需要的参数

可以将InvocationHandler接口的子类想象成一个代理的最终操作类，替换掉ProxySubject

Proxy类

是专门完成代理的操作类，可以通过此类为一个或者多个接口动态地生成实现类，此类提供如下的方法

  1. public static Object newProxyInstance(ClassLoader loader,
  2.                                       Class<?>[] interfaces,
  3.                                       InvocationHandler h)
  4.                                throws IllegalArgumentException

loader - 定义代理类的类加载器
interfaces - 代理类要实现的接口列表
h - 得到的InvocationHandle接口子类实例

类加载器：

图1 图1

工厂设计模式：

实例：

  1. package com.java.reflect;
  3. interface Fruit {
  4.     public void eat();
  5. }
  7. class Apple implements Fruit {
  8.     public void eat() {
  9.     System.out.println("eat apple");
  10.     }
  11. }
  13. class Orange implements Fruit {
  14.     public void eat() {
  15.     System.out.println("eat orange");
  16.     }
  17. }
  19. // 工厂类
  20. class Factory {
  21.     public static Fruit getInstance(String className) {
  22.     Fruit fruit = null;
  23.     fruit = null;
  24.     if ("apple".equals(className)) {
  25.         fruit = new Apple();
  26.     }
  28.     if ("orange".equals(className)) {
  29.         fruit = new Apple();
  30.     }
  31.     return fruit;
  32.     }
  34. }
  36. public class FactoryDemo01 {
  37.     public static void main(String[] args) {
  38.     Fruit f = Factory.getInstance("apple");
  39.     if (f != null) {
  40.         f.eat();
  41.     }
  42.     }
  44. }

如果扩充了一个子类，则肯定要修改工厂类，如果希望扩充子类时不用修改工厂类的话，则必须使用反射完成。

例子：

  1. package com.java.reflect;
  3. interface Fruit {
  4.     public void eat();
  5. }
  7. class Apple implements Fruit {
  8.     public void eat() {
  9.     System.out.println("eat apple");
  10.     }
  11. }
  13. class Orange implements Fruit {
  14.     public void eat() {
  15.     System.out.println("eat orange");
  16.     }
  17. }
  19. // 工厂类
  20. class Factory {
  21.     public static Fruit getInstance(String className) {
  22.     Fruit fruit = null;
  23.     /**
  24.      * if ("apple".equals(className)) { fruit = new Apple(); }
  25.      * 
  26.      * if ("orange".equals(className)) { fruit = new Apple(); } return
  27.      * fruit; }
  28.      */
  29.     try { fruit = (Fruit) Class.forName(className).newInstance(); } catch (Exception e) { e.printStackTrace(); } return fruit; }
  30. }
  32. public class FactoryDemo01 {
  33.     public static void main(String[] args) {
  34.     Fruit f = Factory.getInstance("com.java.reflect.Apple");
  35.     if (f != null) {
  36.         f.eat();
  37.     }
  38.     }
  40. }

以上在扩充子类时，不用修改工厂类，但是输入完整的“包.类”名称，比较麻烦，此时可以通过一些拍之文件的方式保存这些完整的类的路径。

图2图2

  1. package com.java.reflectFactory;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.FileOutputStream;
  6. import java.io.IOException;
  7. import java.util.Properties;
  9. interface Fruit {
  10.     public void eat();
  11. }
  13. class Apple implements Fruit {
  14.     public void eat() {
  15.     System.out.println("eat apple");
  16.     }
  17. }
  19. class Orange implements Fruit {
  20.     public void eat() {
  21.     System.out.println("eat orange");
  22.     }
  23. }
  25. class Init {
  26.     public static Properties getPro() {
  27.     Properties pro = new Properties();
  28.     File f = new File("F:/JAVA深入学习/fruit.properties");// 找到属性文件
  29.     /**
  30.      * 配置文件的内容 apple =com.java.reflectFactory.Apple
  31.      * orange=com.java.reflectFactory.Orange
  32.      * */
  33.     if (f.exists()) {// 如果文件存在
  34.         try {
  35.         pro.load(new FileInputStream(f));
  36.         } catch (IOException e) {
  37.         e.printStackTrace();
  38.         }
  39.     } else {
  40.         pro.setProperty("apple", "com.java.reflectFactory.Apple");
  41.         pro.setProperty("orage", "com.java.reflectFactory.Orange");
  42.         try {
  43.         pro.store(new FileOutputStream(f), "FRUIT CLASS");
  44.         } catch (IOException e) {
  45.         e.printStackTrace();
  46.         }
  47.     }
  48.     return pro;
  50.     }
  51. }
  53. // 工厂类
  54. class Factory {
  55.     public static Fruit getInstance(String className) {
  56.     Fruit fruit = null;
  57.     try {
  58.         fruit = (Fruit) Class.forName(className).newInstance();
  59.     } catch (Exception e) {
  60.         e.printStackTrace();
  61.     }
  62.     return fruit;
  63.     }
  64. }
  66. public class FactoryDemo02 {
  67.     public static void main(String[] args) {
  68.     Properties pro = Init.getPro();
  69.     Fruit f = Factory.getInstance(pro.getProperty("apple"));
  70.     if (f != null) {
  71.         f.eat();
  72.     }
  73.     }
  74. }

配置文件与程序相分离的！

发表评论

表情：
评论列表 （有 0 条评论，238人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Java反射的深入浅出

    刚开始接触反射这个概念，感觉反射这个机制很复杂很难懂，所以在这篇文章中对java的反射机制以个人的理解总结归纳。 1. 什么是反射？ 什么是反射？在官方文档中是这样说的

    浅浅的花香味﹌浅浅的花香味﹌/ 0 赞/ 394 阅读