反射

Class类

所有的类都是数据类型Type,每一次加载一个类,jvm就会将这个类加载进内存.

每一次加载类,jvm就会创建一个Clas类的实例,并且关联起来.这是Class,不是普通的类,类似于:

public final class Class {
    private Class() {}
}

比如,创建一个String实例,就首先读取String.class文件加载道内存,然后创建一个Class实例关联起来:

Class cls = new Class(String);

这个Class实例是jvm内部创造的,构造方法都是私有的,自己是无法创建这个Class实例的.而且每个JVM创建的Class实例都是指向一个数据类型:

而且一个Class实例都包含了一个完整的类信息:

如何获取Class实例,Class实例是唯一的,以下都是获取的同一个实例:

Class cls = String.class;		// class是类中的静态变量
String s = "Hello";
Class cls = s.getClass();		// 有一个实例变量,通过getClass()方法获取
Class cls = Class.forName("java.lang.String");		// 有一个完整的类名,可以通过Class的静态方法forName(String)获取

instance of和Calss实例用==比较,instance of 不仅包括自身,还包括父类都是正确的,而Class实例每一个类都有唯一确定的关系:

Integer n = new Integer(123);

boolean b1 = n instanceof Integer; // true，因为n是Integer类型
boolean b2 = n instanceof Number; // true，因为n是Number类型的子类

boolean b3 = n.getClass() == Integer.class; // true，因为n.getClass()返回Integer.class
boolean b4 = n.getClass() == Number.class; // false，因为Integer.class!=Number.class

反射

反射的目的就是获得某个实例的具体信息,每一个对象实例,都可以反射获取该对象的类信息,通过Class的类方法可以获取具体信息:

public class Main {
    public static void main(String[] args) {
	printClassInfo("".getClass());
	printClassInfo(Runnable.class);
	printClassInfo(java.time.Month.class);
	printClassInfo(String[].class);
	printClassInfo(int.class);
    }

    static void printClassInfo(Class cls) {
	System.out.println("Class name: " + cls.getName());		// 获取该实例的具体类名
	System.out.println("Simple name: " + cls.getSimpleName());		// 获取该实例的具体类名
	if (cls.getPackage() != null) {
	    System.out.println("Package name: " + cls.getPackage().getName());		// 获取该实例所在的包名称
	}
	System.out.println("is interface: " + cls.isInterface());		// 获取该实例是否是接口
	System.out.println("is enum: " + cls.isEnum());		// 获取该实例是否为枚举
	System.out.println("is array: " + cls.isArray());		// 获取该实例是否为数组
	System.out.println("is primitive: " + cls.isPrimitive());		// 获取该实例是否是基本类型
    }
}

JVM为每一种基本类型也创建了Class实例,通过基本类型.class访问;

动态加载

JVM在执行java程序的时候,并不是一次性把所有的类加载道内存,而是第一使用的时候才会加载到内存.

例如:

public class Main {
	    public static void main(String[] args) {
		if (1> 0) {
		    create("linux");
		}
	    }

	    static void create(String name) {
	    	Person p = new Person(name);
	    	Logger logger = Logger.getGlobal();
	    	logger.info("success");
	    }
	    
	    static class Person{
	    	private String name;
			public Person(String name) {
				this.name = name;
			}
	    	
	    }
	    
	}

由于用到了Main，因此，JVM首先会把Main.class加载到内存。然而，并不会加载Person.class，除非程序执行到create()方法，JVM发现需要加载Person类时，才会首次加载Person.class。如果没有执行create()方法，那么Person.class根本就不会被加载。这就是动态加载.

访问字段

通过Class类的一些方法可以访问类中的字段:

import java.lang.reflect.Field;
	public class Main {
	    public static void main(String[] args) throws Exception {
		Class stdClass = Student.class;
		
		// 获取public字段"score":
		System.out.println(stdClass.getField("score"));
		// 获取继承的public字段"name":
		System.out.println(stdClass.getField("name"));
		// 获取private字段"grade":
		System.out.println(stdClass.getDeclaredField("grade"));
		
		// Field[] getFields()：获取所有public的field（包括父类）
		Field[] field1 = Student.class.getFields();
		for(Field field : field1) {
			System.out.print(field + " ");
		}
		
		System.out.print("\n");
		
		// Field[] getDeclaredFields()：获取当前类的所有field（不包括父类）
		Field[] field2 = stdClass.getDeclaredFields();
		for(Field field : field2) {
			System.out.print(field + " ");
		}
	    }
	}

	class Student extends Person {
	    public int score;
	    private int grade;
	}

	class Person {
	    public String name;
	}

访问结果包含字段的所有信息,字段具体名称,字段类型,字段修饰符:

还可以获得字段的值,但是一般类中的数据是封装的,不让外界访问,反射是一种非常规做法:

import java.lang.reflect.Field;
	public class Main {

	    public static void main(String[] args) throws Exception {
		Object p = new Person("Xiao Ming");		// 利用根类初始化创建对象
		Class c = p.getClass();
		Field f = c.getDeclaredField("name");
		f.setAccessible(true);		// 因为类中数据为private,需要用setAccessible得到允许
		Object value = f.get(p);
		System.out.println(value); // "Xiao Ming"
	    }
	}

	class Person {
	    private String name;

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

访问数据之后,自然可以设置字段值,利用Field类方法:

public class Main {

	    public static void main(String[] args) throws Exception {
		Person p = new Person("Xiao Ming");
		System.out.println(p.getName()); // "Xiao Ming"
		Class c = p.getClass();
		Field f = c.getDeclaredField("name");
		f.setAccessible(true);		// 需要获得允许
		f.set(p, "Xiao Hong");		// 利用FIeld类,设置字段值
		System.out.println(p.getName()); // "Xiao Hong"
	    }
	}

	class Person {
	    private String name;

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

	    public String getName() {
		return this.name;
	    }
	}

调用方法

可以通过每个类在JVM创建的Class对象来获取类中的所有字段,也可以获取类中的方法信息,和获取字段的方法类似:

Method getMethod(name, Class...)：获取某个public的Method（包括父类）
	Method getDeclaredMethod(name, Class...)：获取当前类的某个Method（不包括父类）
	Method[] getMethods()：获取所有public的Method（包括父类）
	Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类）

	import java.lang.reflect.Method;
	public class Main {
	    public static void main(String[] args) throws Exception {
		Class stdClass = Student.class;
		// 获取public方法getScore，参数为String:
		System.out.println(stdClass.getMethod("getScore", String.class));
		// 获取继承的public方法getName，无参数:
		System.out.println(stdClass.getMethod("getName"));
		// 获取private方法getGrade，参数为int:
		System.out.println(stdClass.getDeclaredMethod("getGrade", int.class));
		
		
		System.out.println("Method[] getMethods()：获取所有public的Method（包括父类）");
		// 
		Method[] method1 = stdClass.getMethods();
		for(Method method : method1) {
			System.out.println(method);
		}
		
		System.out.println("// Method[] getDeclaredMethods()：获取当前类的所有Method（不包括父类）");
		
		
		
		Method[] method2 = stdClass.getDeclaredMethods();
		for(Method method : method2) {
			System.out.println(method);
		}
		
	    }
	}

	class Student extends Person {
	    public int getScore(String type) {
		return 99;
	    }
	    private int getGrade(int year) {
		return 1;
	    }
	}

	class Person {
	    public String getName() {
		return "Person";
	    }
	}

获取结果就是函数修饰符,返回值类型,具体在哪个类的方法名称,参数类型:

和访问字段类四,也可以调用方法,获取了该方法的实例之后,在用invoke方法调用:

比如:

String s = "Hello world";
String r = s.substring(6); // "world"

用反射原理实现上述表达:

import java.lang.reflect.Method;
	public class Main {
	    public static void main(String[] args) throws Exception {
		// String对象:
		String s = "Hello world";
		// 获取String substring(int)方法，参数为int,subString是获取子串:
		Method m = String.class.getMethod("substring", int.class);
		// 在s对象上调用该方法并获取结果:
		String r = (String) m.invoke(s, 6);
		// 打印调用结果:
		System.out.println(r);
	    }
	}

invoke方法第一个参数是代表该方法的实例对象,后面的参数是传入函数的参数.

调用静态方法就是将invoke第一个参数传入null,Integer.parseInt(String)用反射原理实现:

import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) throws Exception {
	// 获取Integer.parseInt(String)方法，参数为String,parseInt是将字符串解析为十进制的数:
	Method m = Integer.class.getMethod("parseInt", String.class);
	// 调用该静态方法并获取结果:
	Integer n = (Integer) m.invoke(null, "12345");
	// 打印调用结果:
	System.out.println(n);
    }
}

调用非public方法,和设置字段类似,需要加上setAccessible(true)来通过:

public class Main {
	    public static void main(String[] args) throws Exception {
		Person p = new Person();
		Method m = p.getClass().getDeclaredMethod("setName", String.class);
		m.setAccessible(true);		// 用来允许通过调用非public方法
		m.invoke(p, "Bob");
		System.out.println(p.name);
	    }
	}

	class Person {
	    String name;
	    private void setName(String name) {
		this.name = name;
	    }
	}

而且invoke总是调用实际类型的方法,满足多态原则:

import java.lang.reflect.Method;
	public class Main {
	    public static void main(String[] args) throws Exception {
		// 获取Person的hello方法:
		Method h = Person.class.getMethod("hello");
		// 对Student实例调用hello方法:
		h.invoke(new Student());
	    }
	}

	class Person {
	    public void hello() {
		System.out.println("Person:hello");
	    }
	}

	class Student extends Person {
	    public void hello() {
		System.out.println("Student:hello");
	    }
	}

最后打印的是Student:hello.证明满足多态原则,实际上就相当于:

Person p = new Student();
	p.hello();

调用构造方法

可以通过反射原理来调用无参数的构造函数:

例如:

Person p = new Person();

转换成:

Person p = Person.class.newInstance();		// 通过jvm创建的Class类对象,来创建Person对象.

如果要调用有参数的构造函数,就要通过Constructor对象来调用,和获取Method对象类似:

import java.lang.reflect.Constructor;
	public class Main {
	    public static void main(String[] args) throws Exception {
		// 获取构造方法Integer(int):
		Constructor cons1 = Integer.class.getConstructor(int.class);
		// 调用构造方法:
		Integer n1 = (Integer) cons1.newInstance(123);
		System.out.println(n1);

		// 获取构造方法Integer(String)
		Constructor cons2 = Integer.class.getConstructor(String.class);
		Integer n2 = (Integer) cons2.newInstance("456");
		System.out.println(n2);
	    }
	}

通过Class实例获取Constructor的方法如下：

getConstructor(Class...)：获取某个public的Constructor；
	getDeclaredConstructor(Class...)：获取某个Constructor；
	getConstructors()：获取所有public的Constructor；
	getDeclaredConstructors()：获取所有Constructor。
	

Constructor总是当前类定义的构造方法，和父类无关，因此不存在多态的问题.调用非public的Constructor时，必须首先通过setAccessible(true)设置允许访问.

获取继承关系

其实获取到某个Class对象的时候,就相当于获取了一个类的类型:

Class cls = String.class; 	// 获取到String的Class,并且可以做到可能的操作
String s = "";
Class cls = s.getClass();
Class s = Class.forName("java.lang.String");

这是获取Class对象的三种方法.而且实际上就是同一个实例.

获取了该类的Class实例,还可以获取该类的父类:

public class Main {
    public static void main(String[] args) throws Exception {
	Class i = Integer.class;
	Class n = i.getSuperclass();
	System.out.println(n);		// class java.lang.Number
	Class o = n.getSuperclass();
	System.out.println(o);		// class java.lang.Object
	System.out.println(o.getSuperclass());		// null
    }
}

还可以获取接口,一个类可以实现一个或多个接口,通过Class还可以查询实现的接口类型,例如查询Integer类型的接口:

import java.lang.reflect.Method;
public class Main {
    public static void main(String[] args) throws Exception {
	Class s = Integer.class;
	Class[] is = s.getInterfaces();
	for (Class i : is) {
	    System.out.println(i);	
	    //	getInterfaces()只返回当前类直接实现的接口类型，并不包括其父类实现的接口类型	
	    // 	 interface java.lang.Comparable
	   //		interface java.lang.constant.Constable
	   //		interface java.lang.constant.ConstantDesc
	}
    }
}

对所有interface的Class调用getSuperclass()返回的是null，获取接口的父接口要用getInterfaces().

通过调用isAssignableFrom()可以判断向上转型是否成功:

// Integer i = ?
Integer.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Integer
// Number n = ?
Number.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Number
// Object o = ?
Object.class.isAssignableFrom(Integer.class); // true，因为Integer可以赋值给Object
// Integer i = ?
Integer.class.isAssignableFrom(Number.class); // false，因为Number不能赋值给Integer

动态代理

所有的接口不能直接实例化,而是通过向上转型实例化:

CharSequence cs = new StringBuilder();		// StringBuilder的接口就有CharSequence

省略…