黑马程序员——Java基础——反射

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

一、概述

反射就是把Java类中的各种成分映射成一个个的java对象。例如，一个类有：成员变量，方法，构造方法，包等等信息，利用反射技术可以对一个类进行解剖，把各个组成部分映射成一个个对象，对类进行解剖。

二、Class

一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型就是Class。基本的 Java 类型（boolean、byte、char、short、int、long、float 和 double）和关键字 void 也表示为 Class 对象。

如何得到各个字节码对应的实例对象（Class类型）？

public class ReflectDemo1 {

	public static void main(String[] args) throws Exception {
		//加载类字节码的三种方法
		//1.Object类的getClass方法
		Class clazz1 = new ReflectClass().getClass();
		//2.数据类型的静态的class属性
		Class clazz2 = ReflectClass.class;
		//3.通过Class类的静态方法forName
		Class clazz3 = Class.forName("test.day4.ReflectClass");
		
		System.out.println(clazz1.getName());
		System.out.println(clazz2.getName());
		System.out.println(clazz3.getName());
				
		
	}

}

三、构造函数——Constructor

public class ReflectClass {

	public ReflectClass() 
	{
		System.out.println("无参的公有构造函数");	
	}
	
	public ReflectClass(String str) 
	{
		System.out.println("有参的公有构造函数:"+str);	
	}
	private  ReflectClass(int num ) 
	{
		System.out.println("有参的私有构造函数:"+num);	
	}

}

import java.lang.reflect.Constructor;


public class ReflectDemo2 {

	public static void main(String[] args) throws Exception {
		
		Class clazz = Class.forName("test.day4.ReflectClass");
		
		//通过反射无参的公有构造函数创建对象
		Constructor c1 = clazz.getConstructor(null);
		ReflectClass rc1 = (ReflectClass)c1.newInstance(null);
		
		//通过反射有参的公有构造函数创建对象
		Constructor c2 = clazz.getConstructor(String.class);
		ReflectClass rc2 = (ReflectClass)c2.newInstance("java");
		
		//通过反射有参的私有构造函数创建对象，私有需要暴力反射
		Constructor c3 = clazz.getDeclaredConstructor(int.class);
		c3.setAccessible(true);
		ReflectClass rc3 = (ReflectClass)c3.newInstance(1);
		
		
	}

}

四、成员方法——Method

类中有一个特殊的方法，就是主函数

public class ReflectClass {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		System.out.println("反射类的主函数:"+args);
	}
	public void show()
	{
		System.out.println("无参的公有成员函数");
	}	
	public void show(String str)
	{
		System.out.println("有参的公有成员函数："+str);
	}

	public void show(String[] strs,int num)
	{
		System.out.println("多个参数（包含数组）的公有成员函数："+strs+":"+num);
	}	

	public String function(String str)
	{
		return "带返回值的有参公有成员函数:"+str;
	}	
	private String function(int num)
	{
		return "带返回值的有参私有成员函数:"+num;
	}
	public static String function(boolean b)
	{
		return "静态的有返回值的有参公有成员函数:"+b;
	}
}

import java.lang.reflect.Method;

public class ReflectDemo3 {

	public static void main(String[] args) throws Exception {
		
		Class clazz = Class.forName("test.day4.ReflectClass");
		ReflectClass rc = new ReflectClass();
		
		//反射获取类的主函数
		Method method1 = clazz.getMethod("main", String[].class);
		method1.invoke(null, (Object)new String[]{"java01","java02"});
		
		//反射无参的公有成员函数
		Method method2 = clazz.getMethod("show", null);
		method2.invoke(rc, null);
		
		//反射有参的公有成员函数
		Method method3 = clazz.getMethod("show", String.class);
		method3.invoke(rc, "java01");
		
		//反射多个参数（包含数组）的公有成员函数
		Method method4 = clazz.getMethod("show", String[].class,int.class);
		method4.invoke(rc,new String[]{"java01","java02"},123);
		
		//反射带返回值的有参公有成员函数
		Method method5 = clazz.getMethod("function", String.class);
		String s1 = (String)method5.invoke(rc, "java01");
		System.out.println(s1);
		
		//反射带返回值的有参私有成员函数
		Method method6 = clazz.getDeclaredMethod("function", int.class);
		method6.setAccessible(true);
		String s2 = (String)method6.invoke(rc, 2);
		System.out.println(s2);
		
		//反射无参的公有成员函数
		Method method7 = clazz.getMethod("function", boolean.class);
		String s3 = (String)method7.invoke(null, true);
		System.out.println(s3);
	}

}

五、成员变量——Field

public class ReflectClass {

	public String str;
	private int num;
	public static int count;
	public final String s = "reflectclass";
	
	public String getStr() {
		return str;
	}
	public int getNum() {
		return num;
	}
	public static int getCount() {
		return count;
	}
	public String getS() {
		return s;
	}

}

import java.lang.reflect.Field;

public class ReflectDemo4 {

	public static void main(String[] args) throws Exception {

		Class clazz = Class.forName("test.day4.ReflectClass");
		ReflectClass rc = new ReflectClass();

		// 反射获取公有的成员变量
		Field f1 = clazz.getField("str");
		f1.set(rc, "java01");
		System.out.println("公有成员变量：" + rc.getStr());


		// 反射获取私有的成员变量
		Field f2 = clazz.getDeclaredField("num");
		f2.setAccessible(true);
		f2.set(rc, 1020);
		System.out.println("私有成员变量:" + rc.getNum());

		// 反射获取公有的静态成员变量
		Field f3 = clazz.getField("count");
		f3.set(null, 20);
		System.out.println("公有成员变量：" + ReflectClass.getCount());

		// 反射获取公有的最终类型成员变量
		Field f4 = clazz.getField("s");
		String s = (String) f4.get(rc);
		System.out.println("公有最终类型的成员变量："+s);


	}

}