一个例子让你了解Java反射机制

Java反射机制：

通俗地说，反射机制就是可以把一个类、类的成员(函数、属性)，当成一个对象来操作，希望读者能理解，也就是说，类、类的成员，我们在运行的时候还可以动态地去操作他们.

理论的东东太多也没用，下面我们看看实践 Demo ～

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227

package  demo.reflect;   import  java.lang.reflect.*;   public  class  ReflectDemo {        /**       * 为了看清楚Java反射部分代码，所有异常我都最后抛出来给虚拟机处理       */      public  static  void  main(String[] args)  throws  ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException, NoSuchFieldException, NoSuchMethodException {            System.out.println( "demo1：通过Java反射机制得到类的包名和类名" );          demo1();            System.out.println( "" );          System.out.println( "demo2：验证所有的类都是Class类的实例对象" );          demo2();            System.out.println( "" );          System.out.println( "demo3：通过Java反射机制，用 Class 创建类对象，这也就是反射存在的意义所在" );          demo3();            System.out.println( "" );          System.out.println( "demo4：通过Java反射机制得到一个类的构造函数，并实现创建带参实例对象" );          demo4();            System.out.println( "" );          System.out.println( "demo5：通过Java反射机制操作成员变量, set 和 get" );          demo5();            System.out.println( "" );          System.out.println( "demo6：通过Java反射机制得到类的一些属性：继承的接口、父类、函数信息、成员信息、类型等" );          demo6();            System.out.println( "" );          System.out.println( "demo7：通过Java反射机制调用类方法" );          demo7();            System.out.println( "" );          System.out.println( "demo8：通过Java反射机制得到类加载器信息" );          demo8();      }        /**       * demo1：通过Java反射机制得到类的包名和类名       */      public  static  void  demo1() {          Person person =  new  Person();          System.out.println( "包名："  + person.getClass().getPackage().getName());          System.out.println( "完整类名："  + person.getClass().getName());      }        /**       * demo2：验证所有的类都是Class类的实例对象       */      public  static  void  demo2()  throws  ClassNotFoundException {          //定义两个类型都未知的Class，设置初值为null，看看如何给它们赋值成Person类          Class<?> class1 =  null ;          Class<?> class2 =  null ;          //写法1，可能抛出 ClassNotFoundException 异常，多用这个写法          class1 = Class.forName( "demo.reflect.Person" );          System.out.println( "写法1，包名："  + class1.getPackage().getName() +  " , 完整类名："  + class1.getName());          //写法2          class2 = Person. class ;          System.out.println( "写法2，包名："  + class2.getPackage().getName() +  " , 完整类名："  + class2.getName());      }        /**       * demo3：通过Java反射机制，用 Class 创建类对象，这也就是反射存在的意义所在       */      public  static  void  demo3()  throws  ClassNotFoundException, InstantiationException, IllegalAccessException {          Class<?> class1 =  null ;          class1 = Class.forName( "demo.reflect.Person" );          //由于这里不能带参数，所以你要实例化的这个类Person，一定要有无参构造函数          Person person = (Person) class1.newInstance();          person.setName( "xiaoming" );          person.setAge( 20 );          System.out.println(person.getName() +  " , "  + person.getAge());      }        /**       * demo4：通过Java反射机制得到一个类的构造函数，并实现创建带参实例对象       */      public  static  void  demo4()  throws  ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {          Class<?> class1 =  null ;          Person person1 =  null ;          Person person2 =  null ;            class1 = Class.forName( "demo.reflect.Person" );          Constructor<?>[] constructors = class1.getConstructors();            person1 = (Person) constructors[ 0 ].newInstance();          person1.setName( "xiaoming" );          person1.setAge( 20 );          System.out.println(person1.getName() +  " , "  + person1.getAge());          person2 = (Person) constructors[ 1 ].newInstance( 21 ,  "xiaohong" );          System.out.println(person2.getName() +  " , "  + person2.getAge());      }        /**       * demo5：通过Java反射机制操作成员变量, set 和 get       */      public  static  void  demo5()  throws  ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException, SecurityException {          Class<?> class1 = Class.forName( "demo.reflect.Person" );          Object obj = class1.newInstance();          Field personNameField = class1.getDeclaredField( "name" );          personNameField.setAccessible( true );  //取消访问检查          personNameField.set(obj,  "小虎" );          System.out.println( "修改属性之后得到属性变量的值："  + personNameField.get(obj));      }        /**       * demo6：通过Java反射机制得到类的一些属性：继承的接口、父类、函数信息、成员信息、类型等       */      public  static  void  demo6()  throws  ClassNotFoundException {          Class<?> class1 = Class.forName( "demo.reflect.SuperMan" );            //取得父类名称          Class<?> superclass = class1.getSuperclass();          System.out.println( "SuperMan类的父类名："  + superclass.getName());            Field[] fields = class1.getDeclaredFields();          for  ( int  i =  0 ; i < fields.length; i++) {              System.out.println( "类中的成员"  + i +  "： "  + fields[i]);          }            //取得类方法          Method[] methods = class1.getDeclaredMethods();          for  ( int  i =  0 ; i < methods.length; i++) {              System.out.println( "取得SuperMan类的方法"  + i +  "：" );              System.out.println( "函数名："  + methods[i].getName());              System.out.println( "函数返回类型："  + methods[i].getReturnType());              System.out.println( "函数访问修饰符："  + Modifier.toString(methods[i].getModifiers()));              System.out.println( "函数代码写法： "  + methods[i]);          }            //取得类实现的接口，因为接口类也属于Class，所以得到接口中的方法也是一样的方法得到哈          Class<?> interfaces[] = class1.getInterfaces();          for  ( int  i =  0 ; i < interfaces.length; i++) {              System.out.println( "实现的接口类名： "  + interfaces[i].getName());          }      }        /**       * demo7：通过Java反射机制调用类方法       */      public  static  void  demo7()  throws  ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {          Class<?> class1 = Class.forName( "demo.reflect.SuperMan" );            System.out.println( "调用无参方法fly()：" );          Method method = class1.getMethod( "fly" );          method.invoke(class1.newInstance());            System.out.println( "调用有参方法walk(int m)：" );          method = class1.getMethod( "walk" ,  int . class );          method.invoke(class1.newInstance(),  100 );      }        /**       * demo8：通过Java反射机制得到类加载器信息       * 在java中有三种类类加载器       * 1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。       * 2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类       * 3）AppClassLoader 加载classpath指定的类，是最常用的加载器，同时也是java中默认的加载器。       */      public  static  void  demo8()  throws  ClassNotFoundException {          Class<?> class1 = Class.forName( "demo.reflect.SuperMan" );          String name = class1.getClassLoader().getClass().getName();          System.out.println( "类加载器类名："  + name);      }   }   class  Person {      private  int  age;      private  String name;        public  Person() {        }        public  Person( int  age, String name) {          this .age = age;          this .name = name;      }        public  int  getAge() {          return  age;      }        public  void  setAge( int  age) {          this .age = age;      }        public  String getName() {          return  name;      }        public  void  setName(String name) {          this .name = name;      } }   interface  ActionInterface {      public  void  walk( int  m); }   class  SuperMan  extends  Person  implements  ActionInterface {      private  boolean  blueBriefs;        public  void  fly() {          System.out.println( "超人会飞耶～～" );      }        public  boolean  isBlueBriefs() {          return  blueBriefs;      }        public  void  setBlueBriefs( boolean  blueBriefs) {          this .blueBriefs = blueBriefs;      }        @Override      public  void  walk( int  m) {          System.out.println( "超人会走耶～～走了"  + m +  "米就走不动了！" );      } }

运行结果：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

demo1：通过Java反射机制得到类的包名和类名 包名：demo.reflect 完整类名：demo.reflect.Person   demo2：验证所有的类都是Class类的实例对象 写法1，包名：demo.reflect , 完整类名：demo.reflect.Person 写法2，包名：demo.reflect , 完整类名：demo.reflect.Person   demo3：通过Java反射机制，用 Class 创建类对象，这也就是反射存在的意义所在 xiaoming , 20   demo4：通过Java反射机制得到一个类的构造函数，并实现创建带参实例对象 xiaoming , 20 xiaohong , 21   demo5：通过Java反射机制操作成员变量, set 和 get 修改属性之后得到属性变量的值：小虎   demo6：通过Java反射机制得到类的一些属性：继承的接口、父类、函数信息、成员信息、类型等 SuperMan类的父类名：demo.reflect.Person 类中的成员0： private boolean demo.reflect.SuperMan.blueBriefs 取得SuperMan类的方法0： 函数名：fly 函数返回类型：void 函数访问修饰符：public 函数代码写法： public void demo.reflect.SuperMan.fly() 取得SuperMan类的方法1： 函数名：walk 函数返回类型：void 函数访问修饰符：public 函数代码写法： public void demo.reflect.SuperMan.walk(int) 取得SuperMan类的方法2： 函数名：isBlueBriefs 函数返回类型：boolean 函数访问修饰符：public 函数代码写法： public boolean demo.reflect.SuperMan.isBlueBriefs() 取得SuperMan类的方法3： 函数名：setBlueBriefs 函数返回类型：void 函数访问修饰符：public 函数代码写法： public void demo.reflect.SuperMan.setBlueBriefs(boolean) 实现的接口类名： demo.reflect.ActionInterface   demo7：通过Java反射机制调用类方法 调用无参方法fly()： 超人会飞耶～～ 调用有参方法walk(int m)： 超人会走耶～～走了100米就走不动了！   demo8：通过Java反射机制得到类加载器信息 类加载器类名：sun.misc.Launcher$AppClassLoader

个人觉得使用反射机制的一些地方：

1.工厂模式：Factory类中用反射的话，添加了一个新的类之后，就不需要再修改工厂类Factory了

2.数据库JDBC中通过 Class.forName(Driver) 来获得数据库连接驱动

3.分析类文件：毕竟能得到类中的方法等等

4.访问一些不能访问的变量或属性：破解别人代码