JAVA反射

什么是反射机制

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制（注意关键词：运行状态）换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体、或对其fields设值、或唤起其methods

反射机制主要提供的功能

• 在运行时判断任意一个对象所属的类；
• 在运行时构造任意一个类的对象；
• 在运行时判断任意一个类所具有的成员变量和方法；
• 在运行时调用任意一个对象的方法；

java Reflection API简介

• Class类：代表一个类，位于java.lang包下
• Field类：代表类的成员变量（成员变量也称为类的属性）
• Method类：代表类的方法
• Constructor类：代表类的构造方法
• Array类：提供了动态创建数组，以及访问数组的元素的静态方法

java中的Class介绍

Class 类十分特殊，它没有共有的构造方法，被jvm调用的（简单的理解：new对象或者被类加载器加载的时候），在Java中，每个class都有一个相应的Class对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个Class对象，用于表示这个类的类型信息。

java中的Class三种获取方式

• 利用对象调用getClass()方法获取该对象的Class实例；
• 使用Class类的静态方法forName()，用类的名字获取一个Class实例 ；
• 运用.class的方式来获取Class实例，对于基本数据类型的封装类，还可以采用.TYPE来获取相对应的基本数据类型的Class实例；

说明：在运行期间，如果我们要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到.class文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象

public static void main(String[] args) throws Exception {
//		获取类对象有3种方式
		String className = "com.lsz.java.classs.Hero";
		try {
			Class class1 =  Class.forName(className);
			
			Class<Hero>	class2 = Hero.class;
			
			Class class3 = new Hero().getClass();
			
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}

三种方式中，常用第一种，第二种需要导入类的包，依赖太强，不导包就抛编译错误。第三种对象都有了还要反射干什么。一般都第一种，一个字符串可以传入也可写在配置文件中等多种方法。

java中的Class中一些重要的方法

• public Annotation[] getAnnotations () 获取这个类中所有注解

• getClassLoader() 获取加载这个类的类加载器

• getDeclaredMethods() 获取这个类中的所有方法

• getReturnType() 获取方法的返回类型

• getParameterTypes() 获取方法的传入参数类型

• isAnnotation() 测试这类是否是一个注解类

• getDeclaredConstructors() 获取所有的构造方法

• getDeclaredMethod(String name, Class… parameterTypes) 获取指定的构造方法（参数：参数类型.class）

• getSuperclass() 获取这个类的父类

• getInterfaces() 获取这个类实现的所有接口

• getFields() 获取这个类中所有被public修饰的成员变量

• getField(String name) 获取指定名字的被public修饰的成员变量

• newInstance() 返回此Class所表示的类，通过调用默认的（即无参数）构造函数创建的一个新实例

等等方法

 

• 被反射类Book.java

public class Book {
	private final static String  tag = "TAG";
	
	private String name;
    private String author;

    @Override
    public String toString() {
        return "Book{" +
                "name='" + name + '\'' +
                ", author='" + author + '\'' +
                '}';
    }

    public Book() {
    }

    private Book(String name, String author) {
        this.name = name;
        this.author = author;
    }

    public String getName() {
        return name;
    }

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

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    private String declaredMethod(int index) {
        String string = null;
        switch (index) {
            case 0:
                string = "I am declaredMethod 1 !";
                break;
            case 1:
                string = "I am declaredMethod 2 !";
                break;
            default:
                string = "I am declaredMethod 1 !";
        }

        return string;
    }
}

 

• 反射逻辑封装在ReflectClass.java

// 创建对象
	public static void reflectNewInstance() {
		try {
            Class classBook = Class.forName("com.lsz.java.classs.Book");
            
//            Book book = (Book)classBook.newInstance();			//	JDK9以后不推荐使用这种方式
            
            Book book = (Book) classBook.getConstructor().newInstance();
            book.setName("三国");
            book.setAuthor("罗贯中");
            System.out.println(book);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
	}
	
	// 反射私有的构造方法
    public static void reflectPrivateConstructor() {
        try {
            Class<?> classBook = Class.forName("com.lsz.java.classs.Book");
            Constructor<?> declaredConstructorBook = classBook.getDeclaredConstructor(String.class,String.class);
            declaredConstructorBook.setAccessible(true);
            Object objectBook = declaredConstructorBook.newInstance("西游记","罗贯中");
            Book book = (Book) objectBook;
            System.out.println(book.toString());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
    
    // 反射私有属性
    public static void reflectPrivateField() {
        try {
            Class<?> classBook = Class.forName("com.lsz.java.classs.Book");
            Object objectBook = classBook.newInstance();
            Field fieldTag = classBook.getDeclaredField("tag");
            fieldTag.setAccessible(true);
            String tag = (String) fieldTag.get(objectBook);
            System.out.println(tag);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    // 反射私有方法
    public static void reflectPrivateMethod() {
        try {
            Class<?> classBook = Class.forName("com.lsz.java.classs.Book");
            Method methodBook = classBook.getDeclaredMethod("declaredMethod",int.class);
            methodBook.setAccessible(true);
            Object objectBook = classBook.newInstance();
            String string = (String) methodBook.invoke(objectBook,0);
            System.out.println(string);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

 

• 调用相应反射逻辑方法

try {
            // 创建对象
            ReflectClass.reflectNewInstance();

            // 反射私有的构造方法
            ReflectClass.reflectPrivateConstructor();

            // 反射私有属性
            ReflectClass.reflectPrivateField();

            // 反射私有方法
            ReflectClass.reflectPrivateMethod();
        } catch (Exception ex) {
            ex.printStackTrace();
        }

 

带有Declared修饰的方法可以反射到私有的方法，没有Declared修饰的只能用来反射公有的方法。其他的Annotation、Field、Constructor也是如此。