------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------
类的加载
当程序要使用某个类时，如果该类还未被加载到内存中，则系统会通过加载，连接，初始化三步来实现对这个类进行初始化。
加载
就是指将class文件读入内存，并为之创建一个Class对象。
任何类被使用时系统都会建立一个Class对象。
连接
验证 是否有正确的内部结构，并和其他类协调一致
准备 负责为类的静态成员分配内存，并设置默认初始化值
解析 将类的二进制数据中的符号引用替换为直接引用
初始化 就是我们以前讲过的初始化步骤
类初始化时机
创建类的实例
类的静态变量，或者为静态变量赋值
类的静态方法
使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
初始化某个类的子类
直接使用java.exe命令来运行某个主类
类加载器
类加载器
负责将.class文件加载到内在中，并为之生成对应的Class对象。
虽然我们不需要关心类加载机制，但是了解这个机制我们就能更好的理解程序的运行。
类加载器的组成
Bootstrap ClassLoader 根类加载器
也被称为引导类加载器，负责Java核心类的加载
比如System,String等。在JDK中JRE的lib目录下rt.jar文件中
Extension ClassLoader 扩展类加载器
负责JRE的扩展目录中jar包的加载。
在JDK中JRE的lib目录下ext目录
Sysetm ClassLoader 系统类加载器
负责在JVM启动时加载来自java命令的class文件，以及classpath环境变量所指定的jar包和类路径
反射
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.
三种获取Class对象的方式
1:Person p = new Person();
Class c = p.getClass();
2:Class c2 = Person.class;
任意数据类型都具备一个class静态属性,看上去要比第一种方式简单.
3:将类名作为字符串传递给Class类中的静态方法forName即可
Class c3 = Class.forName("Person");
4:第三种和前两种的区别
前两种你必须明确Person类型.
后面是你我这种类型的字符串就行.这种扩展更强.我不需要知道你的类.我只提供字符串,按照配置文件加载就可以了
代码实现：
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException {
//方式1：
Person p = new Person();
Class c = p.getClass();
System.out.println(c);
//方式2：
// Integer.class;
// int.class;
// String.class;
// char.class
//
Class c2 = Person.class;
System.out.println(c2);
//方式3
Class c3 = Class.forName("cn.itcast_01_Reflect.Person");
//Class c3 = Class.forName("cn.itcast_01_Reflect.Personashfkafsalihgewli");
System.out.println(c3);
}
}
通过反射获取构造方法并使用
获取构造方法
getConstructors
getDeclaredConstructors
创建对象
newInstance()
con.newInstance(“zhangsan", 20);
代码实现：
public class ReflectDemo2 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//获取Person类的字节码文件对象
Class c = Class.forName("cn.itcast_01_Reflect.Person");
//获取有参数的构造方法
Constructor con = c.getConstructor(String.class, int.class, String.class);
//通过构造方法，创建对象
Object obj = con.newInstance("小明", 20, "北京");
System.out.println(obj);
}
}
public class ReflectDemo3 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//获取Person 类的字节码文件
Class c = Class.forName("cn.itcast_01_Reflect.Person");
//获取私有的构造方法
//多个构造方法：
//public Constructor<?>[] getDeclaredConstructors() ： 获取所有的构造方法， 包含私有的
// Constructor[] cons = c.getDeclaredConstructors();
// for (Constructor con : cons) {
// System.out.println(con);
// }
//指定的构造方法
Constructor con = c.getDeclaredConstructor(String.class);
//System.out.println(con);
//IllegalAccessException 非法的访问异常
//暴力 访问
//AccessibleObject
//public void setAccessible(boolean flag) 取消java中 权限修饰符的检测
con.setAccessible(true);
//创建对象
Object obj = con.newInstance("小明");
System.out.println(obj);
}
}
通过反射获取成员方法并使用
获取所有方法
getMethods
getDeclaredMethods
获取单个方法
getMethod
getDeclaredMethod
暴力访问
method.setAccessible(true);
代码实现：
public class ReflectDemo2 {
public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
//获取Person类字节码文件对象
Class c = Class.forName("cn.itcast_01_Reflect.Person");
//通过构造方法， 创建对象
Object obj = c.getConstructor(null).newInstance(null);
//获取所有的方法
// Method[] methods = c.getMethods();
// for (Method method : methods) {
// System.out.println(method);
// }
//获取指定的方法
Method method = c.getMethod("method4", String.class);
//执行方法
Object result = method.invoke(obj, "itcast0322");
System.out.println(result);
}
}
public class ReflectDemo3 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
//获取字节码文件对象
Class c = Class.forName("cn.itcast_01_Reflect.Person");
//通过构造方法，创建对象
Constructor con = c.getConstructor(null);
Object obj = con.newInstance(null);
//获取指定的私有方法
//多个方法： public Method[] getDeclaredMethods() 包含私有方法的获取
// Method[] methods = c.getDeclaredMethods();
// for (Method method : methods) {
// System.out.println(method);
// }
//private void method5(){}
Method method = c.getDeclaredMethod("method5", null);
//暴力 访问
method.setAccessible(true);
//调用私有方法
method.invoke(obj, null);
}
}
获取成员变量
多个成员变量
public Field[] getFields() 获取到所有的public 修饰的成员变量
public Field[] getDeclaredFields() 可以获取所有的成员变量， 包含私有的
某一个成员变量
public Field getField(String name) 获取public 指定的成员变量
public Field getDeclaredField(String name) 获取指定的成员变量，包含私有的
Field类中的方法：
public void set(Object obj, Object value) 为 指定对象中当前成员变量进行赋值
public Object get(Object obj) 返回指定对象中 当前的成员变量值
代码实现：
public class ReflectDemo {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchFieldException {
// 获取Person字节码文件
Class c = Class.forName("cn.itcast_01_Reflect.Person");
// 通过构造方法，创建对象
Constructor con = c.getConstructor(null);
Object obj = con.newInstance(null);
// 获取指定的成员变量 name
//多个成员变量 public Field[] getFields()
// Field[] fields = c.getFields();
// for (Field field : fields) {
// System.out.println(field);
// }
//某一个成员变量 public Field getField(String name)
//public String name;
Field fieldName = c.getField("name");
Field fieldAge = c.getField("age");
//System.out.println(fieldName);
//获取私有的成员变量
//private String address
Field fieldAddress = c.getDeclaredField("address");
System.out.println(obj);
// 使用成员变量
fieldName.set(obj, "小明");
fieldAge.set(obj, 20);
//使用私有的成员变量
fieldAddress.setAccessible(true);//开启暴力访问
fieldAddress.set(obj, "上海");
System.out.println(obj);
}
}
反射 在现实开发中的使用
泛型的擦除技术:
泛型的约束它只能够在编译器有效，当编译通过后，产生了一个.class字节码文件，
该字节码文件中，没有泛型
注意： 那么，当我们使用反射技术的时候，所有的类中都是没有泛型约束的
案例：
public class ReflectTest {
public static void main(String[] args) throws NoSuchMethodException, SecurityException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
ArrayList<Integer> list =new ArrayList<Integer>();
list.add(20);
list.add(30);
list.add(40);
//由于集合中的泛型为Integer类型，所以我们不能存储其他类型
//list.add("哈哈");
//获取字节码文件对象
//Class c = Class.forName("java.util.ArrayList");
Class c = ArrayList.class;
//通过构造方法，创建对象
//list 对象有了， 不需要创建
//获取指定的方法
//public boolean add(E e)
Method methodAdd = c.getMethod("add", Object.class);
//执行方法
methodAdd.invoke(list, "哈哈");
System.out.println(list);
}
}
动态代理
代理：本来应该自己做的事情，却请了别人来做，被请的人就是代理对象。
举例：春季回家买票让人代买
动态代理：在程序运行过程中产生的这个对象
而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，所以，动态代理其实就是通过反射来生成一个代理
在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过使用这个类和接口就可以生成动态代理对象。JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib
Proxy类中的方法创建动态代理类对象
public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
最终会调用InvocationHandler的方法
InvocationHandler
Object invoke(Object proxy,Method method,Object[] args)
Proxy类中创建动态代理对象的方法的三个参数；
ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载
Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上
每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的invoke 方法来进行调用。
InvocationHandler接口中invoke方法的三个参数：
proxy:代表动态代理对象
method:代表正在执行的方法
args:代表调用目标方法时传入的实参
Proxy.newProxyInstance
创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，
也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，
以$开头，proxy为中，最后一个数字表示对象的标号。
System.out.println(u.getClass().getName());
624
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
