Java基础加强之反射机制

一、反射：框架设计的灵魂

什么是反射？

反射：就是将类的各个组成部分封装为对象，这就是反射机制。

好处: 1.可以在程序运行过程中，操作这些对象。

2.可以解耦，提高程序的可扩展性。

在真正学习反射之前我们需要了解java代码在计算机中执行的三个阶段（Source源代码阶段、Class类阶段、Runtime运行时阶段）大致过程如下图所示。

如图所示我们定义了一个Person类，在编译时把这个Person类分为三个部分即成员变量，构造方法，成员方法这三个部分存入计算机硬盘，再通过类加载器将字节码文件加载到内存中去操作以便第三步创建对象，这样就形成了第二个阶段，通过Class类对象来描述字节码文件的各个信息（通过Class类对象将成员变量封装为Filed[]对象，构造方法封装为Constructor[]对象，成员方法封装为Method[]对象）这一过程就称为反射机制（当然Class类对象不止如上三个，只是如上三个比较重要），然后就可以创建对象了。

获取Class类对象的方式：

1.Class.forName(“全类名”)：将字节码文件加载进入内存，返回Class对象。

2.类名.Class：通过类名的属性class获取 （多用于参数传递）

3.对象.getClass()：getClass()方法在Object类中定义着（多用于对象的获取字节码的方式）

注意：同一个字节码文件（*.class）在一次程序运行过程中，只会被执行一次，不论通过哪一种方式获取的Class对象都是同一个。

public class Demo01reflect {

    public static void main(String[] args) throws Exception {
    //Class.forName("全类名")
       Class cls1 = Class.forName("demo01.Person");
       //获取类对象
       System.out.println(cls1);
        //类名.class:通过类名的属性获取对象
        Class cls2 =Person.class;
        System.out.println(cls2);
    //对象.getClass()：getClass()方法在Object类中定义着
        Person p = new Person();
        Person p1 = new Person();
        Class cls3 = p.getClass();
        Class cls4 = p1.getClass();
        System.out.println(cls3);//同一个类生成的class类对象是一样的
        if(cls3==cls4)
            System.out.println(true);
    }
}
//结论：同一个字节码文件（*.class）在一次程序运行过程中
//只会被加载一次，不论通过哪一种方式获取的Class对象都是同一个对象
//不同类的类对象不同

结果如图所示：

Class对象的功能。

获取功能：

1.获取成员变量们：

Field[] getFields():获取所有public修饰的成员变量。

Field getField(String name):获取指定名称的public修饰的成员变量。

Field[] getDeclaredFields():获取所有的成员变量，不考虑修饰符。

Field getDeclaredFiled(String name):获取指定名称的成员变量，不考虑修饰符

2.获取构造方法们：

Constructor<?>[] getConstructors()

Constructor getConstructor(类<?>… parameterTypes)

Constructor getDeclaredConstructor(类<?>… parameterTypes)

Constructor<?>[] getDeclaredConstructors()

如上分别代表无参构造和有参构造以及是否得到private修饰的。

3.获取成员方法们：

Method[] getMethods()

Method getMethod(String name, 类<?>… parameterTypes)

Method[] getDeclaredMethods()

Method getDeclaredMethod(String nae, 类<?>… parameterTypes)

如上分别代表有参成员方法和无参成员方法。

获取全类名：

String getName()

关于上述的操作

Filed:成员变量

1.设置值： void set(Object obj,Object value)

2.获取值：get(Object obj)

忽略访问权限修饰符的安全检查： setAccessible(true):暴力反射

Constructor构造方法：

创建对象 ：T newInstance(Object… initargs),如果使用空参数构造方法创建对象，操作可以简化：Class对象的newInstance方法。

Method:方法对象

执行方法：Object invoke(Object obj,Object…args)

获取方法名称：String getName()

为了演示如上操作我们先创建一个Person类

package demo01;

public class Person {
    private  String name;
    private int age;
    public String a;
    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void eat()
    {
        System.out.println("eat1111");
    }

    public void eat(String food)
    {
        System.out.println(food);
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", a='" + a + '\'' +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

关于成员变量：

 Class personClass = Person.class;
    Field[] foeld = personClass.getFields();
    //获取所有public修饰的成员变量的
    Field a = personClass.getField("a");
        System.out.println(a);//获取pulic修饰的成员变量a
    //传一个真实的对象进去
    Person p = new Person();
    Object value = a.get(p);
    System.out.println(value);//null
    //设置a的值set(Object obj,Object value)
    a.set(p,"张三");
    System.out.println(p);
Field[] declaredFields = personClass.getDeclaredFields();
    //获取所有的成员变量，不考虑修饰符
    for(Field declaredField : declaredFields)
    {
        System.out.println(declaredField);
    }
    //反射我的是我的，你的是我的，我都可以用
     Field d = personClass.getDeclaredField("name");
        //私有的访问之前忽略访问权限修饰符的安全检查
        d.setAccessible(true);//暴力反射
        Object value2 = d.get(p);
        System.out.println(value2);
    

运行结果如下：

关于构造方法：

		Class personClass= Person.class;
        Constructor constructor =  personClass.getConstructor(String.class,int.class);//有参构造
        System.out.println(constructor);
        Object person=constructor.newInstance("张三",23);

        Constructor con = personClass.getConstructor();
        Person person1=(Person) con.newInstance();
        person1.setAge(12);
        person1.setName("赵六");
        System.out.println(person);
        System.out.println(person1);

结果如下：

关于成员方法

        //方法名、参数列表
       Class personClass = Person.class;
      Person p1 = new Person();
        Method eat_method = personClass.getMethod("eat");
            //执行方法invoke
        eat_method.invoke(p1);//放入对象

       Method eat_method1= personClass.getMethod("eat",String.class);//参数转为class
        eat_method1.invoke(p1,"i like");

        Method[] methods = personClass.getMethods();
        for(Method method:methods)
        {
            System.out.println(method);
            //Person没有继承父类，直接继承了Object
            //wait notifu notifyall
            String name =method.getName();
            System.out.println(name);
        }

输出结果：

**
eat1111
i like
public java.lang.String demo01.Person.toString()
toString
public java.lang.String demo01.Person.getName()
getName
public void demo01.Person.setName(java.lang.String)
setName
public int demo01.Person.getAge()
getAge
public void demo01.Person.eat(java.lang.String)
eat
public void demo01.Person.eat()
eat
public void demo01.Person.setAge(int)
setAge
public final void java.lang.Object.wait() throws java.lang.InterruptedException
wait
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
wait
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
wait
public boolean java.lang.Object.equals(java.lang.Object)
equals
public native int java.lang.Object.hashCode()
hashCode
public final native java.lang.Class java.lang.Object.getClass()
getClass
public final native void java.lang.Object.notify()
notify
public final native void java.lang.Object.notifyAll()
notifyAll
**

如上就是反射的基本演示了。