JAVA之Class类与反射总结

       

文章来源：http://blog.csdn.net/u014496722/article/details/37809655

 

 JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为JAVA语言的反射机制。

 

1.取得Class类的对象的三种方法

      取得Class对象：public final Class<?> getClass()，反射之中的所有泛型都定义为？，返回值都是Object。

  • 通过Object类的getClass()方法取得
 <span style="color:#000000;">class Person{}  
  1.  public class TestDemo{  
  2.      public static void main(String[] args) throws Exception{  
  3.         Person per = new Person();  
  4.         Class<?> cls = per.getClass();  
  5.         System.out.println(cls.getName());  
  6.     }  
  7. }</span>  

 

  • 使用“类.Class”取得
[java] view plain copy
 
  1. <span style="font-size:12px;"> class Person{}  
  2.  public class TestDemo{  
  3.      public static void main(String[] args) throws Exception{  
  4.         Class<?> cls = Person.class;  
  5.         System.out.println(cls.getName());  
  6.     }  
  7. }</span>  

 

  • 使用Class类内部定义的一个static方法

    取得Class类对象：public static Class<?>forName(String className) throws ClassNotFoundException

[java] view plain copy
 
  1. class Person{}  
  2.  public class TestDemo{  
  3.      public static void main(String[] args) throws Exception{  
  4.     Class<?> cls = Class.forName("Person");//取得Class对象  
  5.         System.out.println(cls.getName());  
  6.     }  
  7. }  


2.通过反射实例化对象

    通过反射实例化对象：public T newInstance () throws InstantiationException,IllegalAccessException

[java] view plain copy
 
  1. class Person{  
  2.      public String toString(){  
  3.          return "Person Class Instance.";  
  4.      }  
  5.  }  
  6.  public class TestDemo{  
  7.      public static void main(String[] args) throws Exception{  
  8.     Class<?> cls = Class.forName("Person");//取得Class对象  
  9.         Object obj = cls.newInstance();  //实例化对象，和使用关键字new一样  
  10.         Person per = (Person) obj ; //向下转型  
  11.         System.out.println(per);  
  12.     }  
  13.  }  


范例：工厂模式

[java] view plain copy
 
  1. <span style="font-size:12px;">interface Fruit{  
  2.     public void eat();  
  3. }  
  4. class Apple implements Fruit{  
  5.     public void eat(){  
  6.         System.out.println("吃苹果。");  
  7.     }  
  8. }  
  9. class Factory{  
  10.     public static Fruit getInstance(String className){  
  11.         if("apple".equals(className)){  
  12.             return new Apple();  
  13.         }  
  14.         return null;  
  15.     }  
  16. }  
  17. public class FactoryDemo {  
  18.     public static void main(String[] args) {  
  19.         Fruit f = Factory.getInstance("apple");  
  20.         f.eat();  
  21.     }  
  22. }</span>  


    在这个工厂设计模式之中有一个最大的问题：如果现在接口的子类增加了，那么工厂类肯定需要修改，这是它所面临的最大问题，而这个最大问题造成的关键性病因是new，那么如果说现在不使用关键字new了，变为了反射机制呢？

 

[java] view plain copy
 
  1. interface Fruit{  
  2.     public void eat();  
  3. }  
  4. class Apple implements Fruit{  
  5.     public void eat(){  
  6.         System.out.println("吃苹果。");  
  7.     }  
  8. }  
  9. class Orange implements Fruit{  
  10.     public void eat(){  
  11.         System.out.println("吃橘子。");  
  12.     }  
  13. }  
  14. class Factory{  
  15.     public static Fruit getInstance(String className){  
  16.         Fruit f = null ;  
  17.         try {  
  18.             f = (Fruit)Class.forName(className).newInstance();  
  19.         } catch (Exception e) {  
  20.             e.printStackTrace();  
  21.         }   
  22.         return f ;  
  23.     }  
  24. }  
  25. public class FactoryDemo {  
  26.     public static void main(String[] args) {  
  27.         Fruit f = Factory.getInstance("Orange");  
  28.         f.eat();  
  29.     }  
  30. }  


3.调用构造方法 

编号

方法名称返回值类型说明

1

getConstructors()

Constructor数组

获取所有权限为public的构造方法

2

getConstructor(Class<?>…parameterTypes)

Constructor对象

获取权限为public的指定构造方法

3

getDeclaredConstructors()

Constructor数组

获得所有构造方法，按声明顺序返回

4

getDeclaredConstructor(Class<?>…parameterTypes)

Constructor对象

获得指定的构造方法
[java] view plain copy
 
  1. <span style="font-size:12px;">import java.lang.reflect.Constructor;  
  2.  class Person{  
  3.      public Person(){}  
  4.      public Person(String name){}  
  5.      public Person(String name , int age){}  
  6.  }  
  7.  public class TestDemo{  
  8.      public static void main(String[] args) throws Exception{  
  9.         Class<?> cls = Class.forName("Person");//取得Class对象  
  10.         Constructor<?> cons []  = cls.getConstructors();  //取得全部构造  
  11.         for(int x = 0 ; x < cons.length ; x ++){  
  12.             System.out.println(cons[x]);  
  13.         }  
  14.     }  
  15.  }</span>  


范例：调用有参数的构造方法

[java] view plain copy
 
  1. import java.lang.reflect.Constructor;  
  2.  class Person{  
  3.      private String name;  
  4.      private int age ;  
  5.      public Person(String name , int age){  
  6.          this.name = name ;  
  7.          this.age = age ;  
  8.      }  
  9.      public String toString(){  
  10.          return "Person [name="+name+",age="+age+"]" ;  
  11.      }  
  12.  }  
  13.  public class TestDemo{  
  14.      public static void main(String[] args) throws Exception{  
  15.     Class<?> cls = Class.forName("Person");//取得Class对象  
  16.         //取得指定参数类型的构造方法  
  17.     Constructor<?> cons = cls.getConstructor(String.class,int.class);  
  18.         Object obj = cons.newInstance("张三",20);//为构造方法传递参数  
  19.         System.out.println(obj);  
  20.      }  
  21.  }  


4.调用普通方法

编号

方法名称返回值类型说明

1

getMethods()

Method数组

获取所有权限为public的方法

2

getMethod(String name,Class<?>…parameterTypes)

Method对象

获取权限为public的指定方法

3

getDeclaredMethods()

Method数组

获得所有方法，按声明顺序返回

4

getDeclaredMethod(String name,Class<?>…parameterTypes)

Method对象

获得指定的方法

 

 

[java] view plain copy
 
  1. import java.lang.reflect.Constructor;  
  2. import java.lang.reflect.Method;  
  3.  class Person{  
  4.     private String name;  
  5.     public String getName() {  
  6.         return name;  
  7.     }  
  8.     public void setName(String name) {  
  9.         this.name = name;  
  10.     }  
  11.  }  
  12.  public class TestDemo{  
  13.      public static void main(String[] args) throws Exception{  
  14.     Class<?> cls = Class.forName("Person");//取得Class对象  
  15.         Method met [] = cls.getMethods();  
  16.         for(int x = 0 ; x < met.length ; x ++){  
  17.             System.out.println(met[x]);  
  18.         }  
  19.      }  
  20.  }  


    取得了Method类对象之后有一个最大的功能，就是可以利用反射调用类中的方法。调用方法：

public Object invoke(Object obj,Object…args) throws IllegalAccessException,IllegalArgumentException,InyocationTargetException

 

[java] view plain copy
 
  1. import java.lang.reflect.Method;  
  2.  class Person{  
  3.     private String name;  
  4.     public String getName() {  
  5.         return name;  
  6.     }  
  7.     public void setName(String name) {  
  8.         this.name = name;  
  9.     }  
  10.  }  
  11.  public class TestDemo{  
  12.      public static void main(String[] args) throws Exception{  
  13.     Class<?> cls = Class.forName("Person");//取得Class对象  
  14.         Object obj = cls.newInstance();  
  15.         String attribute = "name"; //要调用类之中的属性  
  16. Method setMet = cls.getMethod("set"+initcap(attribute),String.class);  
  17.         //setName()  
  18.         Method getMet = cls.getMethod("get"+initcap(attribute));  
  19.         //getName()  
  20.         setMet.invoke(obj, "张三");//等价于：Person对象.setName("张三");  
  21.         System.out.println(getMet.invoke(obj));  
  22.            //等价于：Person对象.getName()  
  23.      }  
  24.      public static String initcap(String str){  
  25.      return str.substring(0,1).toUpperCase().concat(str.substring(1));  
  26.      }  
  27.  }  


5.调用成员

编号

方法名称返回值类型说明

1

getFields()

Field数组

获取所有权限为public的成员变量

2

getField(String name)

Field对象

获取权限为public的指定成员变量

3

getDeclaredFields()

Field数组

获得所有成员变量，按声明顺序返回

4

getDeclaredField(String name)

Field对象

获得指定的构造方法
[java] view plain copy
 
  1. <span style="font-size:12px;">import java.lang.reflect.Field;  
  2. import java.lang.reflect.Method;  
  3.  class Person{  
  4.     private String name;  
  5.  }  
  6.  public class TestDemo{  
  7.      public static void main(String[] args) throws Exception{  
  8.         Class<?> cls = Class.forName("Person");//取得Class对象  
  9.         Field field [] = cls.getDeclaredFields();  
  10.         for(int x = 0 ; x < field.length ; x++) {  
  11.             System.out.println(field[x]);  
  12.             }  
  13.         }  
  14.      }</span>  


在Field类之中提供了两个方法：

  • 设置属性内容（类似于：对象.属性 = 内容）：
    public void set(Object obj,Object value) throws IllegalArgumentExcepiton,IllegalAccessException ；
  • 取得属性内容（类似于：对象.属性）：
    public Object get(Object obj) throws IllegalArgumentException，IllegalAccessException

从类的开发要求而言，一直都强调之中类之中的属性必须封装，所以现在调用之前要想尽一切方法解除封装。

  • 解除封装：public void setAccessible(boolean flag)throws SecurityException；
[java] view plain copy
 
  1. <span style="font-size:12px;">import java.lang.reflect.Field;  
  2.  class Person{  
  3.     private String name;  
  4.  }  
  5.  public class TestDemo{  
  6.      public static void main(String[] args) throws Exception{  
  7.     Class<?> cls = Class.forName("Person");//取得Class对象  
  8.         Object obj = cls.newInstance();  //对象实例化属性才会分配空间  
  9.         Field nameField  = cls.getDeclaredField("name"); //找到name属性  
  10.         nameField.setAccessible(true);  
  11.         nameField.set(obj,"张三");//Person对象.name = "张三"  
  12.         System.out.println(nameField.get(obj));  
  13.      }  
  14.  }</span>  


6.其他可以通过反射访问的主要描述信息

组成部分

访问方法返回值类型说明

包路径

getPackage()

Package对象

获得该类的存放路径

类名称

getName()

String对象

获得该类的名称

继承类

getSuperclass()

Class对象

获得该类的继承的类

实现接口

getInterfaces()

Class数组

获得该类实现的所有接口

内部类

getClasses()

getDeclaredClasses()

Class数组

获得所有权限为public的内部类

获得所有内部类

内部类的声明类

getDeclaringClass()

Class对象

如果该类为内部类，则返回它的成员类，否则返回null

 

 
 
posted @ 2017-09-18 15:37  不缺重头再来的勇气  阅读(204)  评论(0)  编辑  收藏  举报