黑马程序员----反射

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

一、反射概述

1，类的加载：当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化散步来实现对这个类进行初始化。

加载：将class文件读入内存，并为之创建一个Class对象。任何类被使用时系统都会创建一个Class对象。

连接：

a，验证：类的内部是否有正确的内部结构，并和其他类协调一致。（编译不出错，类的关系，继承实现等等没问题）

b，准备：负责为类的静态成员分配内存（静态随着类的加载而加载），并设置默认初始化值。

c，解析：将类的二进制数据中的符号引用替换为直接引用。

2，加载时机：

a，创建类的实例。

b，访问类的静态变量，或者为静态变量赋值。

c，调用类的静态方法。

d，使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。

e，初始化某个类的子类（先初始化的是父类）。

f，直接使用java.exe命令来运行某个主类。

3，类加载器：负责将.class文件加载到内存中，并为之生成对应的Class对象。

4，类加载器的分类：

a，Bootstrap ClassLoader---> 根类加载器。

b，Extension ClassLoader---> 扩展类加载器。

c，System ClassLoader--->     系统类加载器。

5，类加载器的作用

a，Bootstrap ClassLoader 根类加载器

b，Extension ClassLoader 扩展类加载器

c，Sysetm ClassLoader 系统类加载器

6，,类加载器的作用

a，Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载
 比如System,String等。在JDK中JRE的lib目录下rt.jar文件中

b，Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载。
在JDK中JRE的lib目录下ext目录

c，Sysetm ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径

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

8，反射的原理：解剖一个类,先获取到该类的字节码文件对象。使用Class类中的方法，获取到每一个字节码文件对应的Class类型的对象。

9，获取字节码文件对象的三种方式：



二、反射的简单应用

1，通过反射获取构造方法

a，获取无参数的构造函数的方法：通过Class类的newInstance（）方法即可。

b，获取有参数的构造函数的方法：先通过Class类的getConstructor（成员变量类型.class）方法获取指定的构造函数，再通过调用Constructor类的newInstance（成员变量）方法创建对象。

import java.lang.*;

import reflect.Person;

public class 获取构造函数Demo
{
public static void main(String[] args) throws Exception
{
Class clazz = Class.forName("com.heima.bean.Person");
//通过无参构造创建对象
//Person p = (Person) clazz.newInstance();

<span style="white-space:pre">		</span>//System.out.println(p);
//通过有参构造创建对象
Constructor c = clazz.getConstructor(String.class,int.class)

<span style="white-space:pre">		</span>Person p = (Person) c.newInstance("张三",23);
System.out.println(p);
}

}

2，通过反射获取成员变量并使用。
package 博客10_反射;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import 博客10_反射.Person_Reflect;
public class 反射获取成员变量并使用 {

/**
* @param args
* @throws NoSuchMethodException
* @throws SecurityException
*/
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("博客10_反射.Person_Reflect");
//Person p = (Person) clazz.newInstance(); 通过无餐构造创建对象
//System.out.println(p);
Constructor c = clazz.getConstructor(String.class,int.class); //获取有参构造
Person_Reflect p = (Person_Reflect) c.newInstance("张三",23); //通过有参构造创建对象
System.out.println(p);
//Field f = clazz.getField("name"); //获取姓名字段
//f.set(p, "李四"); //修改姓名的值
Field f = clazz.getDeclaredField("name"); //暴力反射获取字段
f.setAccessible(true); //去除私有权限
f.set(p, "李四");

System.out.println(p);

}

}3，通过反射获取方法并使用。
package 博客10_反射;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
pub
4000
lic class 通过反射获取方法并使用 {
public static void main(String[] args) throws Exception {
Class clazz = Class.forName("博客10_反射.Person_Reflect");
Constructor c = clazz.getConstructor(String.class,int.class); <span style="white-space:pre"> </span>//获取有参构造
Person_Reflect p = (Person_Reflect) c.newInstance("张三",23); //通过有参构造创建对象
Method m = clazz.getMethod("eat"); //获取eat方法
m.invoke(p);
Method m2 = clazz.getMethod("eat", int.class); //获取有参的eat方法
m2.invoke(p, 10);
}
}
4，通过反射越过泛型。
原理：泛型只在编译期有效，在运行期会被擦除，所以可以通过反射的方式越过泛型。

package 博客10_反射;

import java.lang.reflect.Method;
import java.util.ArrayList;

public class 通过反射越过泛型 {
public static void main(String[] args) throws Exception {
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(111);
list.add(222);
Class clazz = Class.forName("java.util.ArrayList"); //获取字节码对象
Method m = clazz.getMethod("add", Object.class); //获取add方法
m.invoke(list, "abc");
System.out.println(list);
}
}
三、反射的动态代理
动态代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象。动态代理是在程序运行过程中产生的对象,通过反射来生成一个代理。在java中，java.lang.reflect包中提供了一个Proxy类和一个InvocationHandler接口，可以通过使用这个类和接口就生成动态代理对象。package 博客10_反射;
import java.lang.*;
public class 反射的动态代理 {
/**
* @param args
*/
public static void main(String[] args) {
/*UserImp ui = new UserImp(); //创建实现User接口的子类UserImp对象ui
ui.add();
ui.delete();

System.out.println("-------------------------------");*/
/*MyInvocationHandler m = new MyInvocationHandler(ui);//将ui传入实现的InvocationHandler接口的子类对象中
User u = (User)Proxy.newProxyInstance(ui.getClass().getClassLoader(), ui.getClass().getInterfaces(), m);//实现动态代理
u.add();
u.delete();*/

StudentImp si = new StudentImp();
si.login();
si.submit();

System.out.println("-------------------------------");
MyInvocationHandler m = new MyInvocationHandler(si);
Student s = (Student)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), m);

s.login();
s.submit();
}

}