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

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

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

l 要想解剖一个类 , 必须先要获取到该类的字节码文件对象 。 而解剖使用的就是 Class 类中的方法 . 所以先要获取到每一个字节码文件对应的 Class 类型的对象 .

l 获取 构造方法

• 获取构造方法

- getConstructors

- getDeclaredConstructors

l 通过 配置文件运行类中的方法

l 绕过 ArrayList <Integer > 的一个 对象的泛型检查，在 这个集合中添加一个字符串 数据。只需要将 add 方法使用反射的方式调用即可。

l 原因： 泛型检查存在擦除泛型的 动作 ( 即编译器认识泛型，而虚拟机不认识泛型 ) ，真正在运行时，仍然是泛型位置使用的是 Object 。

• 代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。

- 举例：春季回家买票让人代买

• 动态代理：在程序运行过程中产生的这个对象

- 而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个 代理

• 在代理过程中，可以在本类基础上添加新的功能，使其功能更强大

(1)通过字节码文件对象去使用构造方法，成员变量，成员方法。
 (2)如何获取字节码文件对象:
  A:通过Object类的getClass()方法。
  B:通过数据类型的class静态属性。
  C:通过Class类的静态方法forName()。
 (3)反射获取操作：
  A:通过反射获取构造方法并使用。
   通过构造方法对象创建对象。
  B:通过反射获取成员变量并使用。
   通过成员变量对象给成员变量赋值。
  C:通过反射获取成员方法并使用。
   通过成员方法对象调用成员方法。
 (4)暴力反射：取消访问权限检查

 

 public static void main(String[] args) {

  // 创建被代理的对象
  MyProxyClass mpc = new MyProxyClass();

  // 创建InvocationHandler对象，负责具体的代理执行
  MyHandler mh = new MyHandler(mpc);
  
  // 创建代理对象，将代理对象转成被代理对象的类型。
  MyInterface newProxyInstance = (MyInterface)Proxy.newProxyInstance(mpc.getClass()
    .getClassLoader(), mpc.getClass().getInterfaces(), mh);
  
  
  // 代理对象   代理      被代理对象     执行的方法
  newProxyInstance.eat();
  int sleep = newProxyInstance.sleep(4);
  System.out.println(sleep);
  
  
  
  //1：创建被代理对象
  MyProxyClass mpc2 = new MyProxyClass();
  //2：创建代理对象
  //2-1：定义InvocationHandler类，实现invoke方法的过程
  //2-2 ： 创建InvocationHandler对象，负责具体的代理执行，将被代理对象作为构造方法参数传入
  MyHandler mh2 = new MyHandler(mpc2);
  //2-3：创建代理对象，将代理对象转成被代理对象的类型。注意强转成该实例对象实现的接口类型，从而具备该接口的方法
  MyInterface newProxyInstance2 = (MyInterface)Proxy.newProxyInstance(mpc.getClass()
    .getClassLoader(), mpc.getClass().getInterfaces(), mh2);
  
  //3：代理对象   代理      被代理对象     执行的方法
  newProxyInstance2.eat();
  int sleep2 = newProxyInstance2.sleep(4);
  System.out.println(sleep2);
  
 }

 

 

public abstract class Test {

 FileReader fr;
 
 
 public Test(FileReader fr) {
  super();
  this.fr = fr;
 }

 public static void main(String[] args) {
  
  Frame fram = new Frame();
  
  fram.addWindowListener(new WindowAdapter() {
   
  });
 }
 
 public void firstPart(){
  System.out.println("完成准备动作");
 }
 //真正执行的代码
 public abstract void middlePart();
 public void lastPart(){
  System.out.println("完成首尾动作");
 }
}

public interface MyInterface {

 public abstract void eat();
 public abstract int sleep(int number);
 
}

public class MyProxyClass implements MyInterface {

 @Override
 public void eat() {
  System.out.println("吃了");
 }

 @Override
 public int sleep(int number) {
  System.out.println("我睡了");
  return number;
 }

}

 

public class MyHandler implements InvocationHandler {

 //传入具体执行的被代理的对象
 MyInterface mi;
 public MyHandler(MyInterface mi) {
  super();
  this.mi = mi;
 }

 //method：动态代理的那个方法
 //args：方法的参数
 @Override
 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  
  System.out.println("我是加强的功能");
  //通过反射完成被代理对象，被代理方法的执行
  Object result = method.invoke(mi, args);
  
  System.out.println("我是加强的功能");
  
  //返回该方法的返回值
  return result;
 }

}