java反射学习

一、概述

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

二、可实现功能

1. 在运行时判断任意一个对象所属的类；
2. 在运行时构造任意一个类的对象；
3. 在运行时判断任意一个类所具有的成员变量和方法；
4. 在运行时调用任意一个对象的方法；
5. 生成动态代理
6. 动态获得类型信息（方法、字段、属性。。。）
7. 动态创建对象（可根据字符串创建对象）
8. 动态的调用对象或成员

三、class

  众所周知Java有个Object 类，是所有Java 类的继承根源，其内声明了数个应该在所有Java 类中被改写的方法：hashCode()、equals()、clone()、toString()、getClass()等。其中getClass()返回一个Class 对象。

  Class 类十分特殊。它和一般类一样继承自Object，其实体用以表达Java程序运行时的classes和interfaces，也用来表达enum、array、primitive Java types（boolean, byte, char, short, int, long, float, double）以及关键词void。当一个class被加载，或当加载器（class loader）的defineClass()被JVM调用，JVM 便自动产生一个Class 对象

获得Class对象的五种方法

package com.reflect;

public class Animal {
    public String name;
    public static void main(String[] args) throws ClassNotFoundException {
        Animal animal = new Dog();
        System.out.println("小名家里有一只" + animal.name);

        //方法一，通过对象获得
        Class<?> class1 = animal.getClass();
        //方法二，通过字符串获得（包名+类名，可动态创建对象）
        Class<?> class2 = Class.forName("com.reflect.Animal");
        //方法三，通过类的静态成员class获得
        Class<?> class3 = Cat.class;
        //方法四，获得父类型
        Class<?> class4 = class3.getSuperclass();

        //方法五，只能获得基本数据类型
        Class<?> class5 = Double.TYPE;


        System.out.println("class1类名:"+class1.getName());
        System.out.println("class2类名:"+class2.getName());
        System.out.println("class3类名:"+class3.getName());
        System.out.println("class4类名:"+class4.getName());
        System.out.println("class5类名:"+class5.getName());
    }
}

class Dog extends Animal {
    public Dog() {
        this.name = "狗狗";
    }
}

class Cat extends Animal {
    public Cat() {
        this.name = "猫咪";
    }
}

结果

通过Class对象，还可以访问该对象的主要的描述信息。

组成部分	访问方法	返回值类型	说明
包路径	getPackage()	Package对象	获得该类的存放路径
类名称	getName()	String对象	获得该类的名称
继承类	getSuperclass()	Class对象	获得该类继承的类
实现接口	getInterfaces()	Class型数组	获得该类实现的所有接口
构造方法	getConstructor()	Constructor型数组	获得所有权限为public的构造方法
	getConstructor(Class<?>…parameterTypes)	Constructor对象	获得权限为public的指定构造方法
	getDeclaredConstructors()	Constructor型数组	获得所有构造方法，按声明顺序返回
	getDeclaredConstructor(Class<?>…parameterTypes)	Constructor对象	获得指定构造方法
方法	getMethods()	Method型数组	获得所有权限为public的方法
	getMethod(String name, Class<?>…parameterTypes)	Method对象	获得权限为public的方法
	getDeclaredMethods()	Method型数组	获得所有方法，按声明顺序返回
	getDeclaredMethods(String name, Class<?>…parameterTypes)	Method对象	获得指定方法
成员变量	getFields()	Field型数组	获得所有权限为public的成员变量
	getField(String name)	Field对象	获得权限为public的指定成员变量
	getDeclaredFields()	Field型数组	获得所有成员变量，按声明顺序返回
	getDeclaredFields(String name)	Field对象	获得指定成员变量
内部类	getClasses()	Class型数组	获得所有权限为public的内部类
	getDeclaredClasses()	Class型数组	获得所有内部类
内部类的声明类	getDeclaringClass()	Class对象	如果该类为内部类，则返回它的成员类，否则返回null

 

注意：

  在通过getFields()和getMethods()方法依次获得权限为public的成员变量和方法时，将包含从超类中继承到的成员变量和方法；而通过方法getDeclaredFiedls()和getDeclareMethods()只是获得在本类中定义的所有成员变量和方法。

四、案例

这里我准备好了一个实体类，接下来的所有的测试都将根据这个实体类来实现
package com.reflect;

public class Fruit {
    String name;
    String color;
    String price;

    public String getName() {
        return name;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    public Fruit(String name, String color, String price) {
        this.name = name;
        this.color = color;
        this.price = price;
    }

    public Fruit(String name, String color) {
        this.name = name;
        this.color = color;
    }

    public Fruit() {
    }

    public void getInfo(){
        System.out.println(this.color+"的"+this.name+"，价钱是"+this.price+"元/斤");
    }

    public void outInfo(String name,int price){
        System.out.println("这种水果的名字是"+name+"，价钱是"+price+"元/斤");
    }

    public void outNull(){
        System.out.println("就是想输出一下。。。");
    }

    @Override
    public String toString() {
        return "Fruit{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", price='" + price + '\'' +
                '}';
    }
}

1、实例化一个对象

//通过反射实例化一个实体类对象
Class<?> demo=Class.forName("com.reflect.Fruit");
Constructor<?>[] con = demo.getConstructors();
Fruit fruit1= (Fruit) demo.newInstance();
//通过构造函数实例对象
Fruit fruit2= (Fruit) con[2].newInstance("苹果","红色","14.5");
Fruit fruit3= (Fruit) con[0].newInstance("橙子","黄色");

System.out.println(fruit1);
System.out.println(fruit2);
System.out.println(fruit3);

结果：

2、获得类所有的构造方法

//获得构造方法
Class<?> demo=Class.forName("com.reflect.Fruit");
//获得所有的构造方法
Constructor<?>[] constructors = demo.getConstructors();
for (int i = 0; i < constructors.length; i++) {
    System.out.println(constructors[i]);
}

结果：

3、获得方法信息

Class<?> demo=Class.forName("com.reflect.Fruit");
Method[] methods = demo.getMethods();
Method[] declaredMethods = demo.getDeclaredMethods();
System.out.println("=========本类所有的方法=========");
for (Method declaredMethod : declaredMethods) {
    System.out.println(declaredMethod);
}
System.out.println("=========父类及本类的所有方法=========");
for (Method method : methods) {
    System.out.println(method);
}

结果：

4、获取成员变量并赋值

Class<?> demo=Class.forName("com.reflect.Fruit");
Fruit fruit= (Fruit) demo.newInstance();
//获取成员变量
Field name=demo.getDeclaredField("name");
Field color=demo.getDeclaredField("color");
Field price=demo.getDeclaredField("price");
//给成员变量赋值
name.set(fruit, "苹果");
color.set(fruit,"红色");
price.set(fruit,"8.8");
fruit.getInfo();

结果：

5、动态调用方法

Class<?> demo=Class.forName("com.reflect.Fruit");
Fruit fruit= (Fruit) demo.newInstance();
//动态获得方法名称及参数类型
Method method=demo.getDeclaredMethod("outInfo", String.class, Integer.TYPE);
//动态实现方法
method.invoke(fruit,"榴莲",39);

结果：