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

 

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

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

• 通过Object类的getClass()方法取得

<span style="color:#000000;">class Person{}
 public class TestDemo{
     public static void main(String[] args) throws Exception{
        Person per = new Person();
        Class<?> cls = per.getClass();
        System.out.println(cls.getName());
    }
}</span>

 

• 使用“类.Class”取得

<span style="font-size:12px;"> class Person{}
 public class TestDemo{
     public static void main(String[] args) throws Exception{
        Class<?> cls = Person.class;
        System.out.println(cls.getName());
    }
}</span>

 

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

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

class Person{}
 public class TestDemo{
     public static void main(String[] args) throws Exception{
    Class<?> cls = Class.forName("Person");//取得Class对象
        System.out.println(cls.getName());
    }
}

2.通过反射实例化对象

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

class Person{
     public String toString(){
         return "Person Class Instance.";
     }
 }
 public class TestDemo{
     public static void main(String[] args) throws Exception{
    Class<?> cls = Class.forName("Person");//取得Class对象
        Object obj = cls.newInstance();  //实例化对象，和使用关键字new一样
        Person per = (Person) obj ; //向下转型
        System.out.println(per);
    }
 }

范例：工厂模式

<span style="font-size:12px;">interface Fruit{
    public void eat();
}
class Apple implements Fruit{
    public void eat(){
        System.out.println("吃苹果。");
    }
}
class Factory{
    public static Fruit getInstance(String className){
        if("apple".equals(className)){
            return new Apple();
        }
        return null;
    }
}
public class FactoryDemo {
    public static void main(String[] args) {
        Fruit f = Factory.getInstance("apple");
        f.eat();
    }
}</span>

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

 

interface Fruit{
    public void eat();
}
class Apple implements Fruit{
    public void eat(){
        System.out.println("吃苹果。");
    }
}
class Orange implements Fruit{
    public void eat(){
        System.out.println("吃橘子。");
    }
}
class Factory{
    public static Fruit getInstance(String className){
        Fruit f = null ;
        try {
            f = (Fruit)Class.forName(className).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f ;
    }
}
public class FactoryDemo {
    public static void main(String[] args) {
        Fruit f = Factory.getInstance("Orange");
        f.eat();
    }
}

3.调用构造方法

 

 

 

 

 

 

编号	方法名称	返回值类型	说明
1	getConstructors()	Constructor数组	获取所有权限为public的构造方法
2	getConstructor(Class<?>…parameterTypes)	Constructor对象	获取权限为public的指定构造方法
3	getDeclaredConstructors()	Constructor数组	获得所有构造方法，按声明顺序返回
4	getDeclaredConstructor(Class<?>…parameterTypes)	Constructor对象	获得指定的构造方法

<span style="font-size:12px;">import java.lang.reflect.Constructor;
 class Person{
     public Person(){}
     public Person(String name){}
     public Person(String name , int age){}
 }
 public class TestDemo{
     public static void main(String[] args) throws Exception{
        Class<?> cls = Class.forName("Person");//取得Class对象
        Constructor<?> cons []  = cls.getConstructors();  //取得全部构造
        for(int x = 0 ; x < cons.length ; x ++){
            System.out.println(cons[x]);
        }
    }
 }</span>

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

import java.lang.reflect.Constructor;
 class Person{
     private String name;
     private int age ;
     public Person(String name , int age){
         this.name = name ;
         this.age = age ;
     }
     public String toString(){
         return "Person [name="+name+",age="+age+"]" ;
     }
 }
 public class TestDemo{
     public static void main(String[] args) throws Exception{
    Class<?> cls = Class.forName("Person");//取得Class对象
        //取得指定参数类型的构造方法
    Constructor<?> cons = cls.getConstructor(String.class,int.class);
        Object obj = cons.newInstance("张三",20);//为构造方法传递参数
        System.out.println(obj);
     }
 }

4.调用普通方法

 

 

 

 

 

编号	方法名称	返回值类型	说明
1	getMethods()	Method数组	获取所有权限为public的方法
2	getMethod(String name,Class<?>…parameterTypes)	Method对象	获取权限为public的指定方法
3	getDeclaredMethods()	Method数组	获得所有方法，按声明顺序返回
4	getDeclaredMethod(String name,Class<?>…parameterTypes)	Method对象	获得指定的方法

 

 

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
 class Person{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
 }
 public class TestDemo{
     public static void main(String[] args) throws Exception{
    Class<?> cls = Class.forName("Person");//取得Class对象
        Method met [] = cls.getMethods();
        for(int x = 0 ; x < met.length ; x ++){
            System.out.println(met[x]);
        }
     }
 }

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

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

 

import java.lang.reflect.Method;
 class Person{
    private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
 }
 public class TestDemo{
     public static void main(String[] args) throws Exception{
    Class<?> cls = Class.forName("Person");//取得Class对象
        Object obj = cls.newInstance();
        String attribute = "name"; //要调用类之中的属性
Method setMet = cls.getMethod("set"+initcap(attribute),String.class);
        //setName()
        Method getMet = cls.getMethod("get"+initcap(attribute));
        //getName()
        setMet.invoke(obj, "张三");//等价于：Person对象.setName("张三");
        System.out.println(getMet.invoke(obj));
           //等价于：Person对象.getName()
     }
     public static String initcap(String str){
     return str.substring(0,1).toUpperCase().concat(str.substring(1));
     }
 }

5.调用成员

 

 

 

 

 

编号	方法名称	返回值类型	说明
1	getFields()	Field数组	获取所有权限为public的成员变量
2	getField(String name)	Field对象	获取权限为public的指定成员变量
3	getDeclaredFields()	Field数组	获得所有成员变量，按声明顺序返回
4	getDeclaredField(String name)	Field对象	获得指定的构造方法

<span style="font-size:12px;">import java.lang.reflect.Field;
import java.lang.reflect.Method;
 class Person{
    private String name;
 }
 public class TestDemo{
     public static void main(String[] args) throws Exception{
        Class<?> cls = Class.forName("Person");//取得Class对象
        Field field [] = cls.getDeclaredFields();
        for(int x = 0 ; x < field.length ; x++) {
            System.out.println(field[x]);
            }
        }
     }</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；

<span style="font-size:12px;">import java.lang.reflect.Field;
 class Person{
    private String name;
 }
 public class TestDemo{
     public static void main(String[] args) throws Exception{
    Class<?> cls = Class.forName("Person");//取得Class对象
        Object obj = cls.newInstance();  //对象实例化属性才会分配空间
        Field nameField  = cls.getDeclaredField("name"); //找到name属性
        nameField.setAccessible(true);
        nameField.set(obj,"张三");//Person对象.name = "张三"
        System.out.println(nameField.get(obj));
     }
 }</span>

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

 

 

 

 

 

 

 

 

组成部分	访问方法	返回值类型	说明
包路径	getPackage()	Package对象	获得该类的存放路径
类名称	getName()	String对象	获得该类的名称
继承类	getSuperclass()	Class对象	获得该类的继承的类
实现接口	getInterfaces()	Class数组	获得该类实现的所有接口
内部类	getClasses() getDeclaredClasses()	Class数组	获得所有权限为public的内部类 获得所有内部类
内部类的声明类	getDeclaringClass()	Class对象	如果该类为内部类，则返回它的成员类，否则返回null

 

 

 

 

java的Class类是java反射机制的基础,通过Class类我们可以获得关于一个类的相关信息,下面我们来了解一下有关java中Class类的相关知识!

java.lang.Class是一个比较特殊的类，它用于封装被装入到JVM中的类（包括类和接口）的信息。

当一个类或接口被装入的JVM时便会产生一个与之关联的java.lang.Class对象，可以通过这个Class对象对被装入类的详细信息进行访问。

简单的说，获取某一个类所对应的Class对象可以通过如下三种途径：

1. Object的getClass方法

java.lang.Object中定义有getClass方法：

public final Class getClass()

所有Java对象都具备这个方法。该方法用于返回与调用该方法对象所属类关联的Class对象，例如：

Date date1 = new Date();

Date date2 = new Date();

Class c1 = date1.getClass();

Class c2 = date2.getClass();

System.out.println(c1.getName()); // java.util.Date

System.out.println(c1 == c2); // true

上面的代码中，调用Date对象date1的getClass方法将返回用于封装Date类信息的Class对象。这里调用了Class类的getName方法：

public String getName()

这个方法的含义很直观，即返回所封装的类的名称。

需要注意的是，代码中的date1和date2的getClass方法返回了相同的Class对象（c1==c2的值为true）。这是因为，对于相同的类，JVM只会载入一次，而与该类对应的Class对象也只会存在一个，无论该类实例化了多少对象。

另外，需要强调的是，当一个对象被其父类的引用或其实现的接口类型的引用所指向的时，getClass方法返回的是与对象实际所属类关联的Class对象。例如：

List list = new ArrayList();

System.out.println(list.getClass().getName()); // java.util.ArrayList

上面的代码中，语句list.getClass()方法返回的是list所指向对象实际所属类java.util.ArrayList对应的 Class对象而并未java.util.List所对应的Class对象。有些时候可以通过这个方法了解一个对象的运行时类型，例如：

HashSet set = new HashSet();

Iterator it = set.iterator();

System.out.println(it.getClass().getName()); //java.util.HashMap$KeyIterator

从代码可以看出，HashSet的iterator方法返回的是实现了Iterator接口的HashMap内部类（KeyIterator）对象。

因为抽象类和接口不可能实例化对象，因此不能通过Object的getClass方法获得与抽象类和接口关联的Class对象。

2. 使用.class的方式

使用类名加“.class”的方式即会返回与该类对应的Class对象。例如：

Class clazz = String.class;

System.out.println(clazz.getName()); // java.lang.String

这个方法可以直接获得与指定类关联的Class对象，而并不需要有该类的对象存在。

3. 使用Class.forName方法

Class有一个著名的static方法forName：

public static Class forName(String className) throws ClassNotFoundException

该方法可以根据字符串参数所指定的类名获取与该类关联的Class对象。如果该类还没有被装入，该方法会将该类装入JVM。

该方法声明抛出ClassNotFoundException异常。顾名思义，当该方法无法获取需要装入的类时（例如，在当前类路径中不存在这个类），就会抛出这个异常。

例如，如果当前类路径中存在Foo类：

package org.whatisjava.reflect;

public class Foo {

public Foo() {

System.out.println("Foo()");

}

static {

System.out.println("Foo is initialized");

}

}

运行下面的代码：

Class clazz = Class.forName("org.whatisjava.reflect.Foo");

控制台会有如下输出：

Foo is initialized

Class.forName("org.whatisjava.reflect.Foo")首先会将reflection.Foo类装入JVM，并 返回与之关联的Class对象。JVM装入Foo类后对其进行初始化，调用了其static块中的代码。需要注意的是：forName方法的参数是类的完 整限定名（即包含包名）。

区别于前面两种获取Class对象的方法。使用Class.forName方法所要获取的与之对应的Class对象的类可以通过字符串的方式给定。该方法通常用于在程序运行时根据类名动态的载入该类并获得与之对应的Class对象。

 

通过上面的文章相信你对java的反射机制有了一定的认识,同时也对java中Class类的用法有了比较清晰的理解,在我们实际工作的过程中,我们不断的运用java知识来解决实际生湖中的问题的时候我们就能对java反射机制有一个更深入的理解!