【类反射】类反射原理和获取Class对象的三种方式

什么是类反射—原理？

☆什么是反射

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

（2）反射(Reflection)是Java程序开发语言的特征之一，它允许运行中的Java程序对自身进行检查， 也称自审，并能直接操作程序的内部属性。例如，使用它能获得Java类中各成员的名称并显示出来。

（3）Java的这一能力在实际应用中应用得很多，在其它的程序语言中根本就不存在这一特性。例如，Pascal、C或者C++中就没有办法在程序中获得函数定义相关的信息。

（4）JavaBean是类反射的实际应用之一，它能让一些工具可视化的操作软件组件。这些工具通过类反射动态的载入并取得Java组件(类)的属性。后面学习的各种框架，基本上都会有反射的使用。

☆反射引例(HelloWorld、USB)

反射最大的好处就是解耦

1. 最简单的类反射：（相当于HelloWorld）

   一个ReflectionHelloWorld类演示：

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
 * 1、类反射使用的步骤：<br>
 *      (1)Class c=Class.forName("类全名：包名[.子包名].类名");<br>
 *      (2)调用c对象中的成员方法：Field(字段)、Method(方法)、Constructor(构造方法)、Modifier(静态方法和常量)<br>
 *      (3)遍历出所有信息<br>
 */
public class ReflectionHelloWorld {
    public static void main(String[] args) {
        try {
            Class c=Class.forName("cn.yu.reflect.test.UserModel");
            /*
             * 提供有关类或接口的单个字段信息，以及对他的动态访问权限
             */
            Field[] flds=c.getDeclaredFields();
            for(Field fild:flds){
                System.out.println(fild);
            }
            System.out.println("------------------------");
            /*
             *  提供关于类的单个构造方法的信息以及对它的访问权限。得到的构造方法只能是public类型的。
             */
            Constructor[] cons=c.getConstructors();
            for(Constructor con:cons){
                System.out.println(con);
            }
            System.out.println("------------------------");
            /*
             * 返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，
             * 包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
             */
            Method[] ms=c.getDeclaredMethods();
            for(Method m:ms){
                System.out.println(m);
            }
            System.out.println("------------------------");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

UserModel类：

import java.io.Serializable;

/**
 * 用户uuid,name
 */
interface Intera{
    public void aa();
}
public class UserModel implements Serializable{
    private static final long serialVersionUID = 1L;
    private String uuid;
    private String name;
    private int type;
    private String pwd;

    public UserModel(String uuid, String name, int type, String pwd) {
        super();
        this.uuid = uuid;
        this.name = name;
        this.type = type;
        this.pwd = pwd;
    }

    public UserModel(String uuid, String name, int type) {
        super();
        this.uuid = uuid;
        this.name = name;
        this.type = type;
    }

    public UserModel(){

    }
    public void a(){
        System.out.println("我是接口的抽象方法");
    }
    public String getUuid() {
        return uuid;
    }
    public void setUuid(String uuid) {
        this.uuid = uuid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getType() {
        return type;
    }
    public void setType(int type) {
        this.type = type;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    public static long getSerialversionuid() {
        return serialVersionUID;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((uuid == null) ? 0 : uuid.hashCode());
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        UserModel other = (UserModel) obj;
        if (uuid == null) {
            if (other.uuid != null)
                return false;
        } else if (!uuid.equals(other.uuid))
            return false;
        return true;
    }
    @Override
    public String toString() {
        return "ID：	" + uuid + "  , 	" + name + "	 , " + (type);
    }
}

运行结果：

private static final long cn.yu.reflect.test.UserModel.serialVersionUID
private java.lang.String cn.yu.reflect.test.UserModel.uuid
private java.lang.String cn.yu.reflect.test.UserModel.name
private int cn.yu.reflect.test.UserModel.type
private java.lang.String cn.yu.reflect.test.UserModel.pwd
------------------------
public cn.yu.reflect.test.UserModel()
public cn.yu.reflect.test.UserModel(java.lang.String,java.lang.String,int)
public cn.yu.reflect.test.UserModel(java.lang.String,java.lang.String,int,java.lang.String)
------------------------
public java.lang.String cn.yu.reflect.test.UserModel.toString()
public int cn.yu.reflect.test.UserModel.hashCode()
public boolean cn.yu.reflect.test.UserModel.equals(java.lang.Object)
public java.lang.String cn.yu.reflect.test.UserModel.getName()
public int cn.yu.reflect.test.UserModel.getType()
public void cn.yu.reflect.test.UserModel.setName(java.lang.String)
public static long cn.yu.reflect.test.UserModel.getSerialversionuid()
public java.lang.String cn.yu.reflect.test.UserModel.getUuid()
public void cn.yu.reflect.test.UserModel.setType(int)
public void cn.yu.reflect.test.UserModel.setPwd(java.lang.String)
public void cn.yu.reflect.test.UserModel.a()
public java.lang.String cn.yu.reflect.test.UserModel.getPwd()
public void cn.yu.reflect.test.UserModel.setUuid(java.lang.String)
------------------------

反射使用的三个步骤

用于反射的类，如Method，可以在java.lang.reflect包中找到。使用这些类的时候必须要遵循三个步骤：

1. 第一步：获得你想操作的类的java.lang.Class对象。在运行中的Java程序中，用java.lang.Class类来描述类和接口等。
2. 第二步：调用诸如getDeclaredMethods的方法，取得该类中定义的所有方法的列表。
3. 第三步：使用反射的API来操作这些信息。

如下面这段代码：

Class c = Class.forName("java.lang.String");
Method ms[] = c.getDeclaredMethods();
System.out.println(ms[0].toString());

它将以文本方式打印出String中定义的第一个方法的原型。

获取Class对象的三种方式：

★ 方式一

通过对象的getClass方法进行获取。这种方式需要具体的类和该类的对象，以及调用getClass方法。

★ 方式二

任何数据类型(包括基本数据类型)都具备着一个静态的属性class，通过它可直接获取到该类型对应的Class对象。这种方式要使用具体的类，然后调用类中的静态属性class完成，无需调用方法，性能更好。

★ 方式三

通过Class.forName()方法获取。这种方式仅需使用类名，就可以获取该类的Class对象，更有利于扩展。

代码演示：

import org.junit.Test;
/**
 * 1、演示获取Class c对象的三种方法
 */
public class ReflectGetClass {

    /**
     * 法1：通过对象---对象.getClass()来获取c(一个Class对象)
     */
    @Test
    public void get1(){
        Person p=new Person("Jack", 23);
        Class c=p.getClass();//来自Object方法
    }

    /**
     * 法2：通过类(类型)---任何数据类型包括(基本数据类型)都有一个静态的属性class ，他就是c 一个Class对象
     */
    @Test
    public void get2(){
        Class c=Person.class;
        Class c2=int.class;
    }

    /**
     * 法3：通过字符串(类全名 )---能够实现解耦：Class.forName(str)
     */
    @Test
    public void get3(){
        try {
            Class c=Class.forName("cn.hncu.reflect.test.Person");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }

}