[关闭]
@snail-lb 2017-02-28T15:22:47.000000Z 字数 6409 阅读 1084

java反射

java进阶

java反射学习

本文采用例子进行学习，直接看示例程序应该就能看懂。

一、反射的基本操作

用于操作的Student类

  1. package com.cn.reflect;
  3. public class Student {
  4.     private String name;
  5.     private int age;
  7.     public Student() {
  8.     }
  10.     public Student(String name,int age) {
  11.         this.name = name;
  12.         this.age = age;
  13.     }
  16.     public int getAge() {
  17.         return age;
  18.     }
  20.     public void setAge(int age) {
  21.         this.age = age;
  22.     }
  24.     public void display() {
  25.         System.out.println("学生信息： name=" + name + "   age=" + age);
  26.     }
  28.     public void say(String str){
  29.         System.out.println("学生说：" + str);
  30.     }
  31. }

使用的反射对学生类进行操作

  1. package com.cn.reflect;
  3. import java.lang.reflect.Constructor;
  4. import java.lang.reflect.Field;
  5. import java.lang.reflect.InvocationTargetException;
  6. import java.lang.reflect.Method;
  7. import java.lang.reflect.Modifier;
  9. /**
  10.  * java反射
  11.  * 
  12.  * @author lvbiao
  13.  *
  14.  */
  15. public class TestReflect {
  16.     public static void main(String[] args) {
  17.         Class test = null;
  18.         try {
  19.             test = Class.forName("com.cn.reflect.Student");
  20.         } catch (ClassNotFoundException e) {
  21.             e.printStackTrace();
  22.         }
  23.         //获取完整类名
  24.         System.out.println("------获取完整类名----------");
  25.         System.out.println("完整类名：" + getMothodName(test));
  26.         //无参构造实例化对象
  27.         System.out.println("------无参构造实例化对象----------");
  28.         Student stu1 = (Student) getObjectNoParameters(test);
  29.         stu1.display();
  30.         //通过其他构造函数实例化对象
  31.         System.out.println("------通过其他构造函数实例化对象-----");
  32.         Student stu2 = (Student) getObjectHaveParameters(test);
  33.         stu2.display();
  34.         //获取类全部属性信息
  35.         System.out.println("------获取类全部属性信息----------");
  36.         AttributeInfo(test);
  37.         //获取全部方法信息
  38.         System.out.println("------获取全部方法信息-----------");
  39.         MethodInfo(test);
  40.         //调用类中无参方法
  41.         System.out.println("------调用类中无参方法-----------");
  42.         callMethodNoParameters(test,"display");
  43.         //调用类中有参方法
  44.         System.out.println("------调用类中有参方法-----------");
  45.         callMethodHaveParameters(test,"say","hello");
  46.         //通过反射来操作属性
  47.         System.out.println("------通过反射来操作属性,设置名字为Bob-----------");
  48.         setAttribute(test,"name","Bob");
  51.     }
  53.     // 获取完整类名
  54.     public static String getMothodName(Class cla) {
  55.         return cla.getName();
  56.     }
  58.     // 通过无参构造 实例化对象
  59.     public static Object getObjectNoParameters(Class cla) {
  60.         try {
  61.             return cla.newInstance();
  62.         } catch (InstantiationException e) {
  63.             e.printStackTrace();
  64.         } catch (IllegalAccessException e) {
  65.             e.printStackTrace();
  66.         }
  67.         return null;
  68.     }
  70.     // 通过有参构造 实例化对象
  71.     public static Object getObjectHaveParameters(Class cla) {
  72.         Constructor<?> cons[] = cla.getConstructors();
  73.         Object obj = null;
  74.         try {
  75.             obj = cons[1].newInstance("张三",23);
  76.         } catch (InstantiationException e) {
  77.             e.printStackTrace();
  78.         } catch (IllegalAccessException e) {
  79.             e.printStackTrace();
  80.         } catch (IllegalArgumentException e) {
  81.             e.printStackTrace();
  82.         } catch (InvocationTargetException e) {
  83.             e.printStackTrace();
  84.         }
  85.         return obj;
  86.     }
  88.     //获取类全部属性信息
  89.     public static void AttributeInfo(Class cla){
  90.         Field[] field = cla.getDeclaredFields();
  91.         for (int i = 0; i < field.length; i++) {
  92.             // 权限修饰符
  93.             int mo = field[i].getModifiers();
  94.             String priv = Modifier.toString(mo);
  95.             // 属性类型
  96.             Class<?> type = field[i].getType();
  97.             System.out.println(priv + " " + type.getName() + " "
  98.                     + field[i].getName() + ";");
  99.         }
  100.     }
  102.     //获取类中方法
  103.     public static void MethodInfo(Class cla){
  104.         Method[] method = cla.getDeclaredMethods();
  105.         for (int i = 0; i < method.length; i++) {
  106.             // 权限修饰符
  107.             int mo = method[i].getModifiers();
  108.             String priv = Modifier.toString(mo);
  109.             //获取返回类型
  110.             String retu = method[i].getReturnType().getName();
  111.             // 属性类型
  112.             String name = method[i].getName();
  113.             System.out.println(priv + " " + retu + " "
  114.                     + name + "()");
  115.         }
  116.     }
  118.     //调用无参方法
  119.     public static void callMethodNoParameters(Class cla,String methodName){
  120.         try {
  121.             Method method1 = cla.getMethod(methodName);
  122.             method1.invoke(cla.newInstance());
  123.         } catch (NoSuchMethodException e) {
  124.             e.printStackTrace();
  125.         } catch (SecurityException e) {
  126.             e.printStackTrace();
  127.         } catch (IllegalAccessException e) {
  128.             e.printStackTrace();
  129.         } catch (IllegalArgumentException e) {
  130.             e.printStackTrace();
  131.         } catch (InvocationTargetException e) {
  132.             e.printStackTrace();
  133.         } catch (InstantiationException e) {
  134.             e.printStackTrace();
  135.         }
  136.     }
  138.     //调用有参方法
  139.     public static void callMethodHaveParameters(Class cla,String methodName,String parameter){
  140.         try {
  141.             Method method2=cla.getMethod(methodName, String.class);
  142.             method2.invoke(cla.newInstance(),parameter);
  143.         } catch (NoSuchMethodException e) {
  144.             e.printStackTrace();
  145.         } catch (SecurityException e) {
  146.             e.printStackTrace();
  147.         } catch (IllegalAccessException e) {
  148.             e.printStackTrace();
  149.         } catch (IllegalArgumentException e) {
  150.             e.printStackTrace();
  151.         } catch (InvocationTargetException e) {
  152.             e.printStackTrace();
  153.         } catch (InstantiationException e) {
  154.             e.printStackTrace();
  155.         }
  156.     }
  158.     //通过反射来操作属性
  159.     public static void setAttribute(Class cla,String key,String value){
  160.         try {
  161.             Object obj = cla.newInstance();
  162.             Field field = cla.getDeclaredField(key);
  163.             field.setAccessible(true);
  164.             field.set(obj,value);
  165.             //调用方法来验证是否设置成功
  166.             Method method = cla.getMethod("display");
  167.             method.invoke(obj);
  168.         } catch (InstantiationException e) {
  169.             e.printStackTrace();
  170.         } catch (IllegalAccessException e) {
  171.             e.printStackTrace();
  172.         } catch (NoSuchFieldException e) {
  173.             e.printStackTrace();
  174.         } catch (SecurityException e) {
  175.             e.printStackTrace();
  176.         } catch (NoSuchMethodException e) {
  177.             e.printStackTrace();
  178.         } catch (IllegalArgumentException e) {
  179.             e.printStackTrace();
  180.         } catch (InvocationTargetException e) {
  181.             e.printStackTrace();
  182.         }
  184.     }
  185. }

二、 利用反射实现的代理模式

动态代理的项目接口

  1. package com.cn.reflect.DynamicProxy;
  3. public interface Subject {
  4.     public void say(String name,int age);
  5. }

项目实现

  1. package com.cn.reflect.DynamicProxy;
  3. public class RealSubject implements Subject{
  5.     @Override
  6.     public void say(String name, int age) {
  7.         System.out.println(name + "今年已经" + age + "岁了。");
  8.     }
  10. }

代理实现类

  1. package com.cn.reflect.DynamicProxy;
  3. import java.lang.reflect.InvocationHandler;
  4. import java.lang.reflect.Method;
  5. import java.lang.reflect.Proxy;
  7. public class MyInvocationHandler implements InvocationHandler {
  8.     private Object obj = null;
  10.     public Object bind(Object obj) {
  11.         this.obj = obj;
  12.         return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
  13.     }
  15.     @Override
  16.     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  17.         Object temp = method.invoke(this.obj, args);
  18.         return temp;
  19.     }
  21. }

测试类

  1. package com.cn.reflect.DynamicProxy;
  3. public class Test {
  4.     public static void main(String[] args) {
  5.         MyInvocationHandler demo = new MyInvocationHandler();
  6.         Subject sub = (Subject) demo.bind(new RealSubject());
  7.         sub.say("Rollen",23);
  8.     }
  9. }

三、使用反射完成的工厂模式

1.公共接口

  1. package com.cn.reflect.FactoryPattern;
  3. public interface  Fruit {
  4.      public abstract void eat();
  5. }

2.实现类一

  1. package com.cn.reflect.FactoryPattern;
  3. public class Apple implements Fruit {
  5.     @Override
  6.     public void eat() {
  7.         System.out.println("吃苹果");
  8.     }
  10. }

3.实现类二

  1. package com.cn.reflect.FactoryPattern;
  3. public class Orange implements Fruit{
  5.     @Override
  6.     public void eat() {
  7.         System.out.println("吃橘子");
  8.     }
  9. }

4.工厂方法

  1. package com.cn.reflect.FactoryPattern;
  3. public class FruitFactory {
  4.     public static Fruit getInstance(String ClassName){
  5.         Fruit fruit = null;
  6.         try {
  7.             fruit = (Fruit) Class.forName(ClassName).newInstance();
  8.         } catch (InstantiationException e) {
  9.             e.printStackTrace();
  10.         } catch (IllegalAccessException e) {
  11.             e.printStackTrace();
  12.         } catch (ClassNotFoundException e) {
  13.             e.printStackTrace();
  14.         }
  15.         return fruit;
  16.     }
  17. }

5.测试类

  1. package com.cn.reflect.FactoryPattern;
  3. public class Test {
  4.     public static void main(String[] args) {
  5.         Fruit apple = FruitFactory.getInstance("com.cn.reflect.FactoryPattern.Apple");
  6.         apple.eat();
  7.     }
  8. }
添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注