java反射机制

反射机制

1.什么是反射

Everything is object!

这在java中可以说是一个公理，对象都可以抽象为类，那么类在java中应该也是一种对象，他其实是属于一个叫做Class类的字节码对象，它应该描述的是所有的类，具有所有的类的相同方法等。

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

简单理解：把类中的每一种成员,都描述成一个新的类.Class: 表示所有的类.Constructor: 表示所有的构造器.Method: 表示所有的方法.Field: 表示所有的字段.

2.Class类和Classd的实例

因为Class是对很多类的抽象，为了区分这些类的字节码对象，必须用泛型规范Class

2.1.获取Class实例的方法

• 方式一：使用class属性（所有的数据类型都具有）

Class<java.util.Date> clz1 = java.util.Date.class;

• 方式二：使用对象的getClass() 该方法是Object类中的，说明是任意类型的对象都可调

java.util.Date data = new java.util.Date();
Class<?> clz2 = data.getClass();

• 方式三：Class类中的静态方法forName(String className),className是类的权限定名称

Class<?> clz3 = Class.forName("java.util.Date");

注意：在同一个类中，JVM中只存在一个字节码对象，也就是上述三种方式所创建的字节码对象是一样的

2.2.内置的Class实例

基本数据类型没有类的概念，也没有对象，因此不能使用方式二和方式三。只能用第一种，也就是

Class clz = 数据类型.class	

八大基本数据类型加上一个void，有九大内置class实例.比如：

System.out.println(int.class);//int
System.out.println(double.class);//double
System.out.println(void.class);//void

在基本类型的包装类型中都存在一个TYPE的一个常量，返回该包装类型对应基本类型的字节码对象 static Class TYPE

Class<Integer> clz = Integer.TYPE;
System.out.println(clz);
System.out.println(clz == int.class);//true  

注意:Integer有自己的字节码对象，和int肯定不相同

2.3.数组的Class实例

数组也是数据类型，所以可以用方式一和方式二

int[] arr = {1,1,2,5};  //arr是数组对象
Class<int[]> clz3 = int[].class;
arr.getClass();//class [I

API中提到:所有具有相同维数的和相同数据类型的数组在JVM中只有一个字节码对象，也就是和数组中元素没有任何关系

int[] arr = {1,1,2,5};  //arr是数组对象
int[] arr2 = {1,1,2,3,4,5};  //arr2是数组对象
//方式二
System.out.println(arr.getClass());//class [I		System.out.println(arr2.getClass());//class [I
//方式一
Class<int[]> clz3 = int[].class;
System.out.println(clz3);
System.out.println(clz3 == arr2.getClass());//true

3.操作构造器

3.1.获取构造器

获取所有构造器：

Constructor<?>[] getConstructors() 返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
Constructor<?>[] getDeclaredConstructors()  返回所有的构造方法，没有权限限制

获取指定的一个构造器：

 Constructor<T> getConstructor(Class<?>... parameterTypes) 
 返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。 
 Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) 
 返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。 

Class<Person> clz = Person.class;
Constructor<?>[] con = clz.getConstructors();//获取类中所有的public构造器
con = clz.getDeclaredConstructors();//获取类中所有的构造器，没有权限限制

Constructor<?> con = clz.getConstructor();//获取类中的无参数构造器
con = clz.getConstructor(String.class,int.class);//带有String和int类型的构造器
con = clz.getDeclaredConstructor(String.class);//获取带有private修饰的有参数构造器

3.2.用构造器创建对象

对于public的构造器

构造器对象.newInstance(实参);

对于private的构造器

构造器对象.setAccessible(true)//设置当前构造器可访问，这是Constructor的父类AccessibleObject中方法
构造器对象.newInstance(实参);

class People{
	public People(){
		System.out.println("无参数构造方法");
	}
	public People(String name,int age){
		System.out.println(name + "," + age);
	}
	@SuppressWarnings("unused")
	private People(String name){
		System.out.println(name);
	}
}
public class CreateObjectDemo {
	public static void main(String[] args) throws Exception {
		//获取People类的字节码对象
		Class<People> clz = People.class;
		Constructor<?> con = clz.getConstructor();
		con.newInstance();
		System.out.println("===============");
		
		con = clz.getConstructor(String.class,int.class);
		con.newInstance("XXX",17);
	
		con = clz.getDeclaredConstructor(String.class);
		con.setAccessible(true);//设置当前构造器可访问，这是Constructor的父类AccessibleObject中方法
		con.newInstance("OOO");
	}
}

4.操作方法

4.1.获取方法

获取类中的所有方法：

Method[] getDeclaredMethods() 获取自身类中所有的方法(不包括继承的,和访问权限无关)
 
Method[] getMethods() 获取包括自身和继承过来的所有的public方法

获取类中的某一个方法

Method getDeclaredMethod(String name, Class<?>... parameterTypes) 
表示调用指定的一个本类中的方法(不包括继承的)
    
Method getMethod(String name, Class<?>... parameterTypes) 
表示调用指定的一个公共的方法(包括继承的)

Class<Person> clz = Person.class;
Method[] me = clz.getMethods();//获取类中所有方法，包括继承过来的public方法

Method m =clz.getMethod("doWork");//获取public的doWork方法

4.2.调用方法

• 1):获取方法所在类的字节码对象-

• 2):获取方法对象-

• 3):使用反射调用方法.

  public 修饰的方法：

  在Method类中有方法:public Object invoke(Object obj,Object... args):表示调用当前Method所表示的方法

  obj表示被调用方法所属的对象，args表示向方法传递的实参，返回也是方法返回的结果

  private修饰的方法

  Method对象.setAccessible(true);//设置当前方法可访问，这是Method的父类AccessibleObject中方法

class People{
	public void doWork(){
		System.out.println("我是无参数的doWork");
	}
	public String doWork(String name){
		System.out.println("我是带参数的doWork");
		return name;
	}
	@SuppressWarnings("unused")
	private void eat(){
		System.out.println("我是eat方法");
	}
}
public class MethodInvokeDemo {
	public static void main(String[] args) throws Exception {
		//获取类的字节码对象
		Class<People> clz = People.class;
		Method m =clz.getMethod("doWork");
		m.invoke(clz.newInstance());
		
		System.out.println("============");
		
		m = clz.getMethod("doWork", String.class);
		Object o = m.invoke(clz.newInstance(), "xxx");
		System.out.println(o);
		
		m = clz.getDeclaredMethod("eat");
		m.setAccessible(true);//设置方法可执行
		People p = clz.newInstance();
		m.invoke(p);
	}
}

对于静态方法

对于static方法，静态方法属于类本身，此时的invoke方法的参数就是incoike(null,Object... args),也就是不需要对象

对于形参中的可变参数

对于数组类型的引用类型的参数,底层会自动解包,为了解决该问题,我们使用Object的一维数组把实际参数包装起来.

Method对象.invoke(方法所属对象,new Object[]{所有的实参});

class Test{
	//基本类型可变参数
	public void doWork(int...arr){
		System.out.println("doWork方法被调用," + Arrays.toString(arr));
	}
	//引用类型可变参数
	public static void doWork2(String...arr){
		System.out.println("doWork2方法被调用," + Arrays.toString(arr));
	}
}
public class MethodArrayInvokeDemo {
	public static void main(String[] args) throws Exception {
		//获取类的字节码对象
		Class<Test> clz = Test.class;
	
		//基本类型的数组调用，第二个实参传的可以是新建一个int类型的数组。也可以用Object数组进行包装
		Method m = clz.getMethod("doWork", int[].class);
	//	m.invoke(clz.newInstance(), new int[]{1,2,3});
		m.invoke(clz.newInstance(), new Object[]{new int[]{1,2,3,3}});
		
		//引用类型的方法调用，第二个实参只能放在Objec类型的数组中
		m = clz.getMethod("doWork2", String[].class);
		m = clz.getMethod("doWork2", String[].class);
		//m.invoke(null, new String[]{"A","B"});//错误的写法
		m.invoke(null, new Object[]{new String[]{"A","B"}});
		
	}
}

5.操作字段

5.1.获取字段

使用反射获取字段:

• 找到字段所在类的字节码
• 获取字段

public Field[] getFields():获取当前Class所表示类中所有的public的字段,包括继承的字段.

public Field getField(String fieldName):获取当前Class所表示类中该fieldName名字的public字段,包括继承的字段.

public Field[] getDeclaredFields():获取当前Class所表示类中所有的字段,不包括继承的字段.

public Field[] getDeclaredField(String name):获取当前Class所表示类中该fieldName名字的字段,不包括继承的字段.

5.2.操作字段

给某个类中的字段设置值和获取值:

• 找到被操作字段所在类的字节码
• 获取到该被操作的字段对象
• 设置值/获取值

void setXX(Object obj, XX value) :为基本类型字段设置值,XX表示基本数据类型
void set(Object obj, Object value) :表示为引用类型字段设置值

XX getXX(Object obj) :获取基本类型字段的值,XX表示基本数据类型
Object get(Object obj) :表示获取引用类型字段的值

6.其他API

public class Demo {
	public static void main(String[] args){
		String name = Demo.class.getName();//getName()返回该类的权限的权限的名称
		System.out.println(name);
		
		String packagename = Demo.class.getPackage().getName();//getPackage()返回该类所在的包名
		System.out.println(packagename);
		
		int mod = Demo.class.getModifiers();//返回该类的修饰符
		String type = Modifier.toString(mod);
		System.out.println(type);
		
		String supername = Demo.class.getSuperclass().getName();//返回父类的名称
		System.out.println(supername);
		
		Object arr = new int[]{1,2,2};//判断该字节码对象是否是数组类，也就是实际类型是不是数组
		System.out.println(arr.getClass().isArray());
	}
}

Class类中有方法getClassLoader()可以返回一个类加载器对象,用来加载资源文件。加载资源文件 db.properties文件,只能使用Properties类的load方法.

对于加载资源文件，这里有三种方式：

• 使用绝对路径加载,可以加载到bin目录中，这种做法实际不可行

  public static void test1() throws Exception{
  	Properties p = new Properties();
  	InputStream inStream = new FileInputStream("resource/db.properties");			p.load(inStream);
  	System.out.println(p);
      test1();
  }
  

• 使用相对于classpath根路径加载，用到ClassLoader类加载器加载

  public static void test2() throws Exception{
  		/**
  		 * 这里有两种方式获得类加载器对象
  		 * 1.Class类中有方法getClassLoader()可以返回一个类加载器对象
  		 * 2.Thread类中有方法getContextLoader()也可以返回一个类加载器对象
  		 */
  		Properties p = new Properties();
  		//ClassLoader loader = LoadeResourceDemo.class.getClassLoader();
  		ClassLoader loader = Thread.currentThread().getContextClassLoader();
  		InputStream inStream = loader.getResourceAsStream("db.properties");//返回读取指定资源的输入流
  		p.load(inStream);//记载资源文件
  		System.out.println(p);
  	}
  

• 相对于当前文件的字节码路径加载

  public static void test3() throws Exception{
      Properties p = new Properties();
      InputStream inStream = 					       
     LoadeResourceDemo.class.getResourceAsStream("db.properties");
  		p.load(inStream);
  		System.out.println(p);
  }
  

  注意第二种和第三种是不一样的，区别是第二种加载的是classpath根路径的也或者是bin目录下的，而第三种加载的文件和当前程序的字节码在一个路径下面