15--黑马程序员--基础加强之反射机制

我干阿衰

于 2015-05-12 14:00:59 发布

阅读量326

点赞数

本文链接：https://blog.csdn.net/qq_27963753/article/details/45668771

版权

----------------------ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

一.反射的相关概念
        1.什么是反射？
        Java 反射是Java语言的一个很重要的特征，它使得Java具体了“动态性”。
        在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。
        Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Serializable），也包括fields和methods的所有信息，并可于运行时改变fields内容或调用methods。
        一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。从这个观点看，Perl，Python，Ruby是动态语言，C++，Java，C#不是动态语言。
        尽管在这样的定义与分类下Java不是动态语言，它却有着一个非常突出的动态相关机制：Reflection。这个字的意思是“反射、映象、倒影”，用在Java身上指的是我们可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods。这种“看透class”的能力（the ability of the program to examine itself）被称为introspection（内省、内观、反省）。Reflection和introspection是常被并提的两个术语。
        2.Java反射机制提供的功能
        1）在运行时判断任意一个对象所属的类。
        2）在运行时构造任意一个类的对象。
        3）在运行时判断任意一个类所具有的成员变量和方法。
        4）在运行时调用任意一个对象的方法。
        3.反射的利弊
        1）反射机制可以使人们可以在运行时查看方法和域，让人编写出更具通用性的程序（提高程序的扩展性）。这种功能对编写系统程序来说极为有用，但通常不适用于编写应用程序。
        2）反射很脆弱，编译器很难帮助人发现程序中的错误，任何错误只能在运行时发现，并导致异常。通常比较大的项目中，能不用反射就尽量不用反射。
二.反射的具体应用

         我们先来看看应用反射我们需要用到哪些类：
        Class类：代表一个类。
        Field 类：代表类的成员变量（成员变量也称为类的属性）。
        Method类：代表类的方法。
        Constructor 类：代表类的构造方法。
        Array类：提供了动态创建数组，以及访问数组的元素的静态方法。
        这些类都位于Java.lang.reflect包中。
        1.通过Class类获取成员变量、成员方法、接口、超类、构造方法等
        在java.lang.Object 类中定义了getClass()方法，因此对于任意一个Java对象，都可以通过此方法获得对象的类型。Class类是Reflection API 中的核心类，它有以下方法
        getName()：获得类的完整名字。
        getFields()：获得类的public类型的属性。
        getDeclaredFields()：获得类的所有属性。
        getMethods()：获得类的public类型的方法。
        getDeclaredMethods()：获得类的所有方法。
        getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes 参数指定方法的参数类型。
        getConstructors()：获得类的public类型的构造方法。
        getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型。
        newInstance()：通过类的不带参数的构造方法创建这个类的一个对象。
代码示例：

[html]view plaincopy 
   
  /** 创建一个Person类，供反射机制的使用  
   *  @黑马 ZWF  
   */  
 public class Person {  
     private String name;            //设置字符串私有变量  
     public int age;                 //设置数字型私有变量  
     public Person() {               //创建空参数构造方法，权限为公有         
         System.out.println("控参数构造方法");  
     }  
     public Person(String s) {       //创建含参数构造方法，权限为公有  
         System.out.println("含参数构造方法" + s);  
     }  
     private Person(String name, int age){   //创建含参数构造方法，权限为私有  
         this.name = name;  
         this.age = age;  
     }  
     public void show() {                    //创建无参方法，权限为公有  
         System.out.println("public·····show");  
     }  
     public void run(String s) {             //创建含参方法，权限为公有  
         System.out.println("public·····run" + s);  
     }  
     private void function() {               //创建含参方法，权限为私有有  
         System.out.println("public·····function");  
     }  
     public String toString(){               //覆盖toString方法  
        return name + " : " + age;  
     }  
 }  

[html]view plaincopy 
   
 public class ReflectDemo1 {  
   
     /**通过Class类获取成员变量、成员方法、接口、超类、构造方法等  
      * @黑马ZWF  
      */  
     public static void main(String[] args) throws Exception {  
         // TODO Auto-generated method stub  
         Person p = new Person();    //创建对象  
         Class c1 = p.getClass();    //第一种方法，通过对象获取  
         System.out.println(c1);  
         Class c2 = Person.class;    //第二种方法，通过类的静态属性获取  
         System.out.println(c2);  
         Class c3 = Class.forName("反射.Person");  //第三种方法，通过Class类的静态方法forName,如果定义了包名，则用包名.类名  
         System.out.println(c3);       
         System.out.println("················");  
         Constructor[] con1 = c3.getConstructors();      //利用getConstructor()方法获取Person类的公有方法  
         for(Constructor c : con1) {  
             System.out.println(c);  
         }     
         System.out.println("················");  
         Constructor[] con2 = c3.getDeclaredConstructors();  //利用getDeclaredConstructor()方法获取Person类的所有方法 包括私有的  
         for(Constructor c : con2) {  
             System.out.println(c);  
         }     
         System.out.println("················");  
         Constructor conprivate = c3.getDeclaredConstructor(String.class,int.class);  //获取私有的构造方法并运行  
         System.out.println(conprivate);  
         System.out.println("················");  
         conprivate.setAccessible(true);       //获取私有方法并为之创建实例  
         Object objprivate = conprivate.newInstance("zhangsan",18);  
           
         System.out.println(objprivate);       
         System.out.println("················");  
         Object obj = c3.newInstance();  
         System.out.println(obj+"   没有获取构造，直接建立的对象");  //不获取构造方法，直接创建对象。适合有空参数的，权限是public的情况  
     }  

         2.Field类
        可以通过反射机制得到某个类的某个属性，然后改变对应于这个类的某个实例的该属性值。JAVA 的Class<T>类提供了几个方法获取类的属性。
        public Field getField(String name)   返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。。
        public Field[] getFields() 返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
        public Field getDeclaredField(Stringname) 返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
        public Field[] getDeclaredFields() 返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。

代码示例：

[html]view plaincopy 
   
 public class FieldDemo1 {  
   
     /**Field类方法的应用  
      * @param args  
      */  
     public static void main(String[] args) throws Exception{  
         // TODO Auto-generated method stub  
    
         Person p = new Person();  
         Class c1 = Class.forName("反射.Person");  
         Field[] field = c1.getFields();  //public Field[] getFields()  返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段  
         for(Field f : field) {  
             System.out.println(f);  
         }  
         System.out.println("··················");  
         Field field1 = c1.getField("age");//public Field  getField(String name)   返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段  
         System.out.println(field1);  
         System.out.println("··················");  
         Field[] field2 = c1.getDeclaredFields();  //获取所有的成员变量，返回数组，全部的，包含私有  
         for(Field f : field2) {  
             System.out.println(f);  
         }  
         System.out.println("··················");  
         Field field3 = c1.getDeclaredField("name"); // public Field  getDeclaredField(Stringname)  返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段  
         System.out.println(field3);       
     }  
   
 }  

输出结果：

3.method类

        通过反射机制得到某个类的某个方法，然后调用对应于这个类的某个实例的该方法
        Class<T>类提供了几个方法获取类的方法。
        public Method　getMethod(String name,Class<?>... parameterTypes) 返回一个Method对象，它反映此Class对象所表示的类或接口的指定公共成员方法
        public Method[] 　getMethods() 返回一个包含某些 Method 对象的数组，这些对象反映此Class对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法
        public Method　getDeclaredMethod(Stringname,Class<?>... parameterTypes) 返回一个Method对象，该对象反映此Class对象所表示的类或接口的指定已声明方法
        public Method[] getDeclaredMethods() 返回Method对象的一个数组，这些对象反映此Class对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。

代码示例：

[html]view plaincopy 
   
 public class MethodDemo {  
   
     /**利用Method类获取成员方法，并运行  
      * @黑马ZWF  
      */  
     public static void main(String[] args) throws Exception{  
         // TODO Auto-generated method stub  
         Class c = Class.forName("反射.Person");  
         Method m1 = c.getMethod("run",String.class);   //public Method　getMethod(String name,Class<?>... parameterTypes) 返回一个Method对象，它反映此Class对象所表示的类或接口的指定公共成员方法  
         System.out.println(m1);  
         System.out.println("··············");  
         Object obj = c.newInstance();    //调用Method方法中的invoke运行方法  
         m1.invoke(obj,"你好吗？");  
         System.out.println("··············");  
         Method[] m2 = c.getMethods();    //public Method[] 　getMethods() 返回一个包含某些 Method 对象的数组，这些对象反映此Class对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法  
         for(Method m:m2) {  
             System.out.println(m);  
         }  
     }  
 }  

        4.新建类的实例
        通过反射机制创建新类的实例，有几种方法可以创建
        调用无自变量ctor
        1）调用类的Class对象的newInstance方法，该方法会调用对象的默认构造器，如果没有默认构造器，会调用失败.

代码示例：

[html]view plaincopy 
   
 public class InstanceDemo {  
   
     /**调用类的Class对象的newInstance方法创建实例  
      * @黑马ZWF 
      */  
     public static void main(String[] args) throws Exception{  
         // TODO Auto-generated method stub  
         Class<?> classType = Person.class;  
         Object inst = classType.newInstance();  
         System.out.println(inst);     //输出结果为：空参数构造方法        zz : 0  
     }  
 }  

2.调用默认Constructor对象的newInstance方法

代码示例

[html]view plaincopy 
   
 <span style="font-size:12px;">public class InstanceDemo2 {  
   
     /**调用默认Constructor对象的newInstance方法创建实例  
      * @黑马ZWF  
      */  
     public static void main(String[] args) throws Exception{  
         // TODO Auto-generated method stub  
         Class<?> classType = Person.class;  
         Constructor<?> constructor1 = classType.getConstructor();  
         Object inst = constructor1.newInstance();  
         System.out.println(inst);    //输出结果为：空参数构造方法        zz : 0  
     }  
 }</span>  

3.调用带参数Constructor对象的newInstance方法

代码示例：

[html]view plaincopy 
   
 public class InstanceDemo3 {  
   
     /**调用带参数Constructor对象的newInstance方法创建实例  
      * @黑马ZWF  
      */  
     public static void main(String[] args) throws Exception{  
         // TODO Auto-generated method stub  
         Class<?> classType = Person.class;  
         Constructor<?> constructor2 = classType.getDeclaredConstructor(String.class,int.class);  
         Object inst = constructor2.newInstance("张三", 20);  
         System.out.println(inst);     //输出结果为：张三 : 20  
     }  
   
 }  