反射 复习

类的加载概述

    学习发射前先了解一下类是怎样加载的
     当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
     加载 
        就是指将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 {@Overridepublic void squeeze() {System.out.println("榨出一杯苹果汁儿");}}class Orange implements Fruit {@Overridepublic 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";@Overridepublic 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 {@Overridepublic void add() {//System.out.println("权限校验");//通过输出类模拟System.out.println("添加功能");//System.out.println("日志记录");//<span style="font-family: Arial, Helvetica, sans-serif;">通过输出类模拟</span>}@Overridepublic void delete() {//System.out.println("权限校验");System.out.println("删除功能");//System.out.println("日志记录");}