Class文件加载流程
类的加载条件：
当创建一个类的实例时，如 通过new创建对象，或者通过反射、克隆、反序列化
调用类方法时，即使用了字节码的invokestatic指令
当使用类或接口的类字段（除final常量外），比如使用了getstatic或pushstatic指令
当使用了java.lang.reflect包中的方法反射类的方法时
当初始化子类时，要求先初始化父类
作为启动虚拟机，含有main方法的哪个类
类加载器
类加载器（CLassLoader）用于加载类，在Java中主要有以下四种类加载器：
Bootstrap ClassLoader：此加载器采用C++编写，一般开发中是看不到的，加载系统核心类，如String类；
Extension ClassLoader：用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类；
AppClassLoader：加载classpath指定的类，即加载用户类，也就是应用程序的类。
自定义类加载器
Class类型获取
public class Class_test { public static void main(String[] args) throws ClassNotFoundException { 1 Class class_testClass = Class_test.class; System.out.println(class_testClass); //class com.zym.com.zym.Class_test 2 Class_test class_test = new Class_test(); Class aClass = class_test.getClass(); System.out.println(aClass); //class com.zym.com.zym.Class_test 3 Class aClass1 = Class.forName("com.zym.com.zym.Class_test"); System.out.println(aClass1); //class com.zym.com.zym.Class_test }} 反射
public class fanshe { public static void main(String[] args) { //获得一个类 Class cls = Student1.class; //获取类所在的包 Package apackage = cls.getPackage(); System.out.println(apackage); //获得属性(公开) System.out.println("获得属性(公开)"); Field[] attr_Student1 = cls.getFields(); for (Field s : attr_Student1 ) { System.out.println(s); } //获得属性(所有) System.out.println("------------------"); System.out.println("获得属性(所有)"); Field[] fileds_all_stu1 = cls.getDeclaredFields(); for (Field f : fileds_all_stu1 ) { System.out.println(f); } //获得构造方法(公开的),一般加Declared的都是所有 System.out.println("-----------"); Constructor [] constructors = cls.getConstructors(); for (Constructor con:constructors ) { System.out.println(con); } //获得普通的犯法，公开的方法，包括继承的方法 System.out.println("-----------"); Method[] methods = cls.getMethods(); for (Method m:methods ) {// System.out.println(m); } //获得普通方法，所有本类的所有方法，不包括继承方法 System.out.println("-----------"); Method[] declaredMethods = cls.getDeclaredMethods(); for (Method s : declaredMethods ) { System.out.println(s); } }} 执行类中的方法，普通方法，构造方法
public class TestPropertyDescriptor { public static void main(String[] args) { Person person = new Person(); person.setName("zhangsan"); person.setAge(18); getFiled(person, "name");//结果输出 zhangsan } // 通过反射得到name // 通过得到属性的get方法（pd.getReadMethod()）再调用invole方法取出对应的属性值 // 调用set方法（） private static void getField(Object object, String field) { Class clazz = object.getClass(); PropertyDescriptor pd = null; Method getMethod = null; Method setMethod = null; try { pd = new PropertyDescriptor(field, clazz); if (null != pd) { // 获取field属性的get方法 getMethod = pd.getReadMethod(); Object getInvoke = getMethod.invoke(object); // 获取field属性的set方法 setMethod= pd.getWriteMethod(); Object setInvoke = setMethod.invoke(object,"123"); System.out.println(setInvoke+ getInvoke); } } catch (Exception e) { e.printStackTrace(); } }} public static void main(String[] args) throws Exception { //给对象赋值 /*Person p = new Person(); p.setAge(20); p.setAddress("北京"); p.setName("张三");*/ //获得Person的Class类型 Class cls = Person.class; //实例化Person /*Person p = cls.newInstance();//通过Person无参构造方法实例化 p.setAge(20); p.setAddress("北京"); p.setName("张三"); System.out.println(p);*/ Constructor con = cls.getConstructor(String.class,int.class,String.class); Person p=con.newInstance("张三",23,"昌平"); //获得set方法 Field field = cls.getDeclaredField("age");// System.out.println(field.getName()); String mname="set"+field.getName().substring(0, 1).toUpperCase()+field.getName().substring(1); System.out.println(mname); Method m = cls.getMethod(mname, int.class); //执行方法 m.invoke(p,21); System.out.println(p); //调用show Method show = cls.getMethod("show", String.class); // obj 实例对象，args 参数 show.invoke(p, "测试"); } 反射缺点
破坏了类的封装；
平时开发不会使用反射机制！！！
设计模式
静态代理
一个接口一个功能，也可以在代理类中写功能
对其他对象提供一种代理以控制对这个对象的访问。
对已经存在的类，添加功能，不能修改原有类的任何功能！！！
public class compute implements PublicObject { @Override public void Info(String name, double price) { System.out.println("电脑名称:"+name+"价格:"+price); }} public class proxy implements PublicObject{ public PublicObject po; public proxy(PublicObject po) { this.po = po; } @Override public void Info(String name, double price) { po.Info(name,price); } public void gift(){ System.out.println("反现金"); }} public interface PublicObject{ public void Info(String name,double price);} public class proxy_test { public static void main(String[] args) { compute c = new compute(); proxy p = new proxy(c); p.Info("zzzz", 123); p.gift(); }} 动态代理
之前曾为读者讲解过代理机制的操作，但是之前所讲解的代理设计，属于静态代理，因为每一个代理类只能为一个接口服务，这样一来程序开发中必然会产生过多的代理了，最好的做法是可以通过一个代理类完成全部的代理功能，那么此时就必须使用动态代理完成。
在Java中要想实现动态代理机制，则需要java.lang.reflect.InvocationHandler接口和java.lang.reflect.Proxy类的支持。
public class MyProxy implements InvocationHandler{ //动态代理 private Object obj; //绑定的对象 public Object bind(Object o){ this.obj=o;// ClassLoader loader：类加载器 // Class [] interfaces：得到全部的接口 // InvocationHandler h：得到InvocationHandler接口的子类实例 return Proxy.newProxyInstance(o.getClass().getClassLoader(), o.getClass().getInterfaces(), this); } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// System.out.println("参数:"+Arrays.toString(args));// System.out.println(method.getName()); return method.invoke(obj, args); //执行目标对象的方法 } } //目标对象public class Computer implements PublicObj { @Override public void Info(String name, double price) { System.out.println(name+"系列电脑！"+price); }} //抽象对象public interface PublicObj { //电脑系列 public void Info(String name,double price);} public class Test { public static void main(String[] args) { MyProxy handler = new MyProxy(); PublicObj po =new Computer();//真实目标对象 PublicObj o = (PublicObj) handler.bind(po); o.Info("IBM", 9999.99); }}