反射 复习

类的加载概述

    学习发射前先了解一下类是怎样加载的
     当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
     加载 
        就是指将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会建立一个Class对象。
     连接
         验证 是否有正确的内部结构，并和其他类协调一致
         准备 负责为类的静态成员分配内存，并设置默认初始化值，注意：在学习静态时所说的随着类的加载而加载就是在这里体现的
         解析 将类的二进制数据中的符号引用替换为直接引用
        
     初始化 就是我们以前讲过的初始化步骤
加载时机
     创建类的实例
     访问类的静态变量，或者为静态变量赋值
     调用类的静态方法
     使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
     初始化某个类的子类
     直接使用java.exe命令来运行某个主类

反射概述

       学习反射先要了解Class类，这里的Class是首字母大写的，Java程序中各个Java类属于同一类事物，描述这类事物的Java类名就是Class，这是反射的基石

       一位牛人总结的反射是这样的，他说反射就是把Java类中的各种成分映射成为相应的Java类，确实总结的很精辟

      JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

      对于任意一个对象，都能够调用它的任意一个方法和属性；
      这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
      要想解剖一个类,必须先要获取到该类的字节码文件对象。
      而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

      

获取字节码的三种方式

方式一：Object类的getClass()方法，判断两个对象是否是同一个字节码文件，对象.getClass()

方式二：静态属性class，锁对象。类名.class    是一种固定写法。源程序一看到就知道是字节码

方式三：Class类中静态方法forName()，读取配置文件     Class.forName()

public static void main(String[] args) throws ClassNotFoundException {
		Class clazz = Peason.class;//静态属性class,锁对象     获取字节码方式一
		
		Class clazz2 = Class.forName("cn.itcast.been.Peason");//Class类中静态方法forName(),读取配置文件   获取字节码方式二    
		
		
		Peason  z = new Peason();
		Class clazz3 = z.getClass();//Object类的getClass()方法,判断两个对象是否是同一个字节码文件     获取字节码方式三
		
		System.out.println(clazz==clazz2);
		System.out.println(clazz2==clazz3);
	}

反射作用    实现框架功能

配置文件的读取

对类的使用分两种一种是当做工具来使用它也可以说是工具功能，另一种是通过他来调用你的类，也可以说是框架功能

先创建一个配置文件xxx.properties里面包含一个全类名

public static void main(String[] args) throws IOException, ClassNotFoundException, InstantiationException, IllegalAccessException {
		Juicer j = new Juicer();
		//j.run(new Apple());
		//j.run(new Orange());
		
		BufferedReader br = new BufferedReader(new FileReader("config.properties"));	//读取配置文件
		Class<?> clazz = Class.forName(br.readLine());					//将配置文件的类名读取出来  
		Fruit f = (Fruit) clazz.newInstance();						//通过该类的字节码对象创建该类对象
		j.run(f);
	}

}

interface Fruit {
	public void squeeze();
}

class Apple implements Fruit {

	@Override
	public void squeeze() {
		System.out.println("榨出一杯苹果汁儿");
	}
	
}

class Orange implements Fruit {
	@Override
	public void squeeze() {
		System.out.println("榨出一杯桔子汁儿");
	}
}

class Juicer {
	public void run(Fruit f) {
		f.squeeze();
	}
}

通过反射获取构造方法

public static void main(String[] args) throws Exception {
		Class clazz = Class.forName("cn.itcast.been.Peason");
		
		Peason p = (Peason) clazz.newInstance();//调用空参构造
		System.out.println(p);               
		
		/*Constructor<?> c = clazz.getConstructor(String.class,int.class);//获取有参构造
		Peason p = (Peason) c.newInstance("haah",23);      //通过有参构造创建对象
				System.out.println(p);*/
		
	}

通过反射获取成员变量

public static void main(String[] args) throws Exception {
		Class<?> clazz = Class.forName("cn.itcast.been.Peason");//获取字节码对象
		Constructor<?> c = clazz.getConstructor(String.class,int.class);//获取有参构造
		Peason p = (Peason) c.newInstance("小明",24);     //通过有参构造创建对象
		//Field f = clazz.getField("name");
		//f.set(p, "大名");
		
		Field f = clazz.getDeclaredField("name");//暴力获取字段
		f.setAccessible(true);       //去掉访问权限
		f.set(p, "大名");
		System.out.println(p);
	}

练习

将任意一个对象中的所有String类型的成员变量所对应的字符串内容中的"b"改成"a"

</pre><pre name="code" class="java">public static void main(String[] args) throws IllegalAccessException, Exception {
		ReflectPoint rp = new ReflectPoint();//创建对象
		changeStringValue(rp);//调用方法
		System.out.println(rp);
	}
	public static void changeStringValue(Object obj) throws Exception, IllegalAccessException{
		//写一个方法并传入一个对象
		Field[] fields = obj.getClass().getFields();//通过字节码获取所有的字段
		for (Field field : fields) {   //对字段进行遍历
			if(field.getType()==String.class){//将获取字段的属性与字符串类型比较。记住这里比较的是字节码要用==好更好些
				String oldValue = (String)field.get(obj);//获取旧的字段
				String newValue = oldValue.replace('b', 'a');//将旧字段替换为新字段
				field.set(obj, newValue);     //获取替换后的型字段
			}
		}
	} 
}
class ReflectPoint{
	public String s1 = "ball";
	public String s2 = "basketball";
	
	public String s3 = "itheima";

	@Override
	public String toString() {//重写toString方法
		return "ReflectPoint [s1=" + s1 + ", s2=" + s2 + ", s3=" + s3 + "]";
	}
	
}

通过反射获取方法

public static void main(String[] args) throws Exception {
		Class<?> clazz = Class.forName("cn.itcast.been.Peason");//获取字节码对象
		Constructor<?> c = clazz.getConstructor(String.class,int.class);//获取有参构造
		Peason p = (Peason) c.newInstance("小明",24);     //通过有参构造创建对象
		
		//Method m = clazz.getMethod("play");   //获取空参方法
		//m.invoke(p);         //调用方法
		
		Method m = clazz.getDeclaredMethod("play", int.class);//暴力获取有参方法
		m.invoke(p,6 );          //调用方法并给方法赋值
		
	}

反射与数组的关系

public static void main(String[] args) {
		int[] a1 = new int[]{1,2,3,4}; 
		String[] a2 = new String[]{"a","b","c"};
		printObject(a1);
		printObject(a2);
		printObject("abc");
		}
      private static void printObject(Object obj){
    	  Class clazz = obj.getClass();//获取对象的字节码
    	  if(clazz.isArray()){      //判断是否是数组
    		  int len = Array.getLength(obj);//获取数组的长度
    		  for (int i = 0;i < len;i++) { //遍历打印数组内元素
				System.out.println(Array.get(obj,i));
			}
    	  }else{
    		  System.out.println(obj);//如果不是数组就直接打印
    	  }
      }
}

反射通过泛型检查

ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据，如何实现呢？

public static void main(String[] args) throws Exception {
		ArrayList<Integer> list = new ArrayList<>();
		list.add(111);
		list.add(222);
		
		Class<?> clazz = Class.forName("java.util.ArrayList");//获取集合的字节码对象
		
		Method m = clazz.getMethod("add", Object.class);//通过字节码获取方法
		Object s =  m.invoke(list,"abc");          //调用方法
		System.out.println(s);                //打印方法的返回值
		System.out.println(list);

通过反射写一个通用的设置某个对象的某个属性为指定的值

public static void setProperty(Object obj, String propertyName, Object value) throws Exception{
		Class<?> clazz = obj.getClass();//获取字节码对象
		Field f = clazz.getDeclaredField(propertyName);//暴力获取给字段的名字
		f.setAccessible(true);             //去除权限
		f.set(obj, value);   //修改属性

public static void main(String[] args) throws Exception {
		Student s = new Student();     //创建对象
		Test3.setProperty(s, "name", "浩浩");//调用方法
		Test3.setProperty(s, "age", 45);
		
		System.out.println(s);
	}
}
class Student{
	private String name;//将属性私有。并且不给提供访问方法
	private int age;
	
	public String toString(){
		return name +","+age;
	}
	}

动态代理
动态代理：在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理
代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象。

public static void main(String[] args) {
		UserImp ui = new UserImp();
		ui.add();
		ui.delete();
		System.out.println("-----------------------");
		
		 
		MyInvocationHandler m = new MyInvocationHandler(ui);
		User u = (User) Proxy.newProxyInstance(ui.getClass().getClassLoader(), ui.getClass().getInterfaces(), m);
		u.add();
		u.delete();

public interface User {
	public void add();
	
	public void delete();
}

public class UserImp implements User {

	@Override
	public void add() {
		//System.out.println("权限校验");//通过输出类模拟
		System.out.println("添加功能");
		//System.out.println("日志记录");//<span style="font-family: Arial, Helvetica, sans-serif;">通过输出类模拟</span>

	}

	@Override
	public void delete() {
		//System.out.println("权限校验");
		System.out.println("删除功能");
		//System.out.println("日志记录");
	}