Java基础加强:
l 静态导入
l import语句可以导入一个类或某个包中的所有类
l import static语句导入一个类中的某个静态方法或所有静态方法
l 语法举例：
l import staticjava.lang.Math.sin;
l import static java.lang.Math.*;
System.out.println(min(3,9));
System.out.println(abs(3-9));
注意这种写法只是出现在JDK1.5以后的版本。
l 可变参数
l 可变参数的特点：
l 只能出现在参数列表的最后；这个要记住
l ...位于变量类型和变量名之间，前后有无空格都可以;
l 调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数。
l 增强for循环
l 语法：
l for ( type 变量名：集合变量名 ) { … }
l 注意事项：
l 迭代变量必须在( )中定义！
l 集合变量可以是数组或实现了Iterable接口的集合类
l 举例：
publicstatic int add(int x,int ...args) {
intsum = x;
for(intarg:args) {
sum+= arg;
}
returnsum;
}
l 基本数据类型的自动拆箱与装箱
l 自动装箱：
l Integer num1 = 12;
l 自动拆箱：
l System.out.println(num1+ 12);
l 基本数据类型的对象缓存：
Integer num1 = 12;
Integer num2 = 12; 这块相等，<=127都是真的
System.out.println(num1 == num2);
Integer num3 = 129; 这块不相等，因为是对象
Integer num4 = 129;
System.out.println(num3 == num4);
Integer num5 = Integer.valueOf(12);
Integer num6 = Integer.valueOf(12) ; 这块的道理同上
System.out.println(num5 == num6);
l 枚举
l 为什么要有枚举
l 枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标。
l 枚举的高级应用
l 枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。
l 枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。
l 带构造方法的枚举
l 构造方法必须定义成私有的
l 如果有多个构造方法，该如何选择哪个构造方法？
l 枚举元素MON和MON（）的效果一样，都是调用默认的构造方法。
l 带方法的枚举
l 定义枚举TrafficLamp
l 实现普通的next方法
l 实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义。
l 增加上表示时间的构造方法
l 枚举只有一个成员时，就可以作为一种单例的实现方式。
l 反射的基石àClass类
l 反射就是把Java类中的各种成分映射成相应的java类
l 对比提问： Person类代表人，它的实例对象就是张三，李四这样一个个具体的人， Java程序中的各个Java类属于同一类事物，描述这类事物的Java类名就是Class。对比提问：众多的人用一个什么类表示？众多的Java类用一个什么类表示？
l 人àPerson
l Java类àClass
l Class类代表Java类，它的各个实例对象又分别对应什么呢？
l 对应各个类在内存中的字节码，例如，Person类的字节码，ArrayList类的字节码，等等。
l 一个类被类加载器加载到内存中，占用一片存储空间，这个空间里面的内容就是类的字节码，不同的类的字节码是不同的，所以它们在内存中的内容是不同的，这一个个的空间可分别用一个个的对象来表示，这些对象显然具有相同的类型，这个类型是什么呢？
l 如何得到各个字节码对应的实例对象（ Class类型）
l 类名.class，例如，System.class
l 对象.getClass()，例如，new Date().getClass()
l Class.forName("类名")，例如，Class.forName("java.util.Date");
l 九个预定义Class实例对象：
l 参看Class.isPrimitive方法的帮助
l Int.class == Integer.TYPE
l 数组类型的Class实例对象
l Class.isArray()
l 总之，只要是在源程序中出现的类型，都有各自的Class实例对象，例如，int[]，void
l 反射
l 反射就是把Java类中的各种成分映射成相应的java类。例如，一个Java类中用一个Class类的对象来表示，一个类中的组成部分：成员变量，方法，构造方法，包等等信息也用一个个的Java类来表示，就像汽车是一个类，汽车中的发动机，变速箱等等也是一个个的类。表示java类的Class类显然要提供一系列的方法，来获得其中的变量，方法，构造方法，修饰符，包等信息，这些信息就是用相应类的实例对象来表示，它们是Field、Method、Contructor、Package等等。
l 一个类中的每个成员都可以用相应的反射API类的一个实例对象来表示，通过调用Class类的方法可以得到这些实例对象后，得到这些实例对象后有什么用呢？怎么用呢？这正是学习和应用反射的要点。
l Constructor类
l Constructor类代表某个类中的一个构造方法
l 得到某个类所有的构造方法：
Ø 例子：Constructor [] constructors=Class.forName("java.lang.String").getConstructors();
l 得到某一个构造方法：
Ø 例子： Constructor constructor = Class.forName(“java.lang.String”).getConstructor(StringBuffer.class);
//获得方法时要用到类型
l 创建实例对象：
Ø 通常方式：String str = new String(new StringBuffer("abc"));
Ø 反射方式： String str = (String)constructor.newInstance(newStringBuffer("abc"));
//调用获得的方法时要用到上面相同类型的实例对象
l Class.newInstance()方法：
Ø 例子：String obj =(String)Class.forName("java.lang.String").newInstance();
Ø 该方法内部先得到默认的构造方法，然后用该构造方法创建实例对象。
Ø 该方法内部的具体代码是怎样写的呢？用到了缓存机制来保存默认构造方法的实例对象。
l Field类
l Field类代表某个类中的一个成员变量
l 演示用eclipse自动生成Java类的构造方法
l 问题：得到的Field对象是对应到类上面的成员变量，还是对应到对象上的成员变量？类只有一个，而该类的实例对象有多个，如果是与对象关联，哪关联的是哪个对象呢？所以字段fieldX 代表的是x的定义，而不是具体的x变量。
l 示例代码：
ReflectPointpoint = new ReflectPoint(1,7);
Fieldy =Class.forName("cn.itcast.corejava.ReflectPoint").getField("y");
System.out.println(y.get(point));
//Fieldx = Class.forName("cn.itcast.corejava.ReflectPoint").getField("x");
Fieldx = Class.forName("cn.itcast.corejava.ReflectPoint").getDeclaredField("x");
x.setAccessible(true);
System.out.println(x.get(point));
l Method类
l Method类代表某个类中的一个成员方法
l 得到类中的某一个方法：
l 例子： Method charAt =Class.forName("java.lang.String").getMethod("charAt",int.class);
l 调用方法：
l 通常方式：System.out.println(str.charAt(1));
l 反射方式： System.out.println(charAt.invoke(str, 1));
l 如果传递给Method对象的invoke()方法的第一个参数为null，这有着什么样的意义呢？说明该Method对象对应的是一个静态方法！
l jdk1.4和jdk1.5的invoke方法的区别：
l Jdk1.5：public Object invoke(Objectobj,Object... args)
l Jdk1.4：public Object invoke(Objectobj,Object[] args)，即按jdk1.4的语法，需要将一个数组作为参数传递给invoke方法时，数组中的每个元素分别对应被调用方法中的一个参数，所以，调用charAt方法的代码也可以用Jdk1.4改写为 charAt.invoke(“str”, new Object[]{1})形式。
l 用反射方式执行某个类中的main方法
l 目标：
l 写一个程序，这个程序能够根据用户提供的类名，去执行该类中的main方法。用普通方式调完后，大家要明白为什么要用反射方式去调啊？
l 问题：
l 启动Java程序的main方法的参数是一个字符串数组，即public static voidmain(String[] args)，通过反射方式来调用这个main方法时，如何为invoke方法传递参数呢？按jdk1.5的语法，整个数组是一个参数，而按jdk1.4的语法，数组中的每个元素对应一个参数，当把一个字符串数组作为参数传递给invoke方法时，javac会到底按照哪种语法进行处理呢？jdk1.5肯定要兼容jdk1.4的语法，会按jdk1.4的语法进行处理，即把数组打散成为若干个单独的参数。所以，在给main方法传递参数时，不能使用代码mainMethod.invoke(null,newString[]{“xxx”})，javac只把它当作jdk1.4的语法进行理解，而不把它当作jdk1.5的语法解释，因此会出现参数类型不对的问题。
l 解决办法：
l mainMethod.invoke(null,newObject[]{new String[]{"xxx"}});
l mainMethod.invoke(null,(Object)newString[]{"xxx"}); ，编译器会作特殊处理，编译时不把参数当作数组看待，也就不会数组打散成若干个参数了
l 数组的反射
l 具有相同维数和元素类型的数组属于同一个类型，即具有相同的Class实例对象(此处比较与值无关)。
l 代表数组的Class实例对象的getSuperClass()方法返回的父类为Object类对应的Class。
l 基本类型的一维数组可以被当作Object类型使用，不能当作Object[]类型使用；非基本类型的一维数组，既可以当做Object类型使用，又可以当做Object[]类型使用。
l Arrays.asList()方法处理int[]和String[]时的差异。
l Array工具类用于完成对数组的反射操作。
l 反射的作用à实现框架功能
什么是框架，例如，我们要写程序扫描.java文件中的注解，要解决哪些问题：读取每一样，在每一个中查找@，找到的@再去查询一个列表，如果@后的内容出现在了列表中，就说明这是一个我能处理和想处理的注解，否则，就说明它不是一个注解或者说至少不是一个我感兴趣和能处理的注解。接着就编写处理这个注解的相关代码。现在sun提供了一个apt框架，它会完成所有前期工作，只需要我们提供能够处理的注解列表，以及处理这些注解的代码。Apt框找到我们感兴趣的注解后通知或调用我们的处理代码去处理。
你做的门调用锁，锁是工具，你做的门被房子调用，房子是框架，房子和锁都是别人提供的。
程序中不处理异常，而是main方法声明抛出异常，便于大家可以集中看主要的关键代码。
Class类也提供getResourceAsStream方法的比喻：如果你每次都找我给你商店买可乐，那我还不如直接向你买可乐，即直接提供一个买可乐的方法给你。
public staticvoid main(String[] args) throws Exception{
//应该先直接用ArrayList和HashSet，然后才引入从配置文件读，这样便于学员学习。
Properties props = new Properties();
//先演示相对路径的问题
//InputStream ips = newFileInputStream("config.properties");
/*一个类加载器能加载.class文件，那它当然也能加载classpath环境下的其他文件，既然它有如此能力，它没有理由不顺带提供这样一个方法。它也只能加载classpath环境下的那些文件。注意：直接使用类加载器时，不能以/打头。*/
//InputStream ips =ReflectTest2.class.getClassLoader().getResourceAsStream("cn/itcast/javaenhance/config.properties");
//Class提供了一个便利方法，用加载当前类的那个类加载器去加载相同包目录下的文件
//InputStream ips =ReflectTest2.class.getResourceAsStream("config.properties");
InputStream ips = ReflectTest2.class.getResourceAsStream("/cn/itcast/javaenhance/config.properties");
props.load(ips);
Ips.close();
String className = props.getProperty("className");
Class clazz = Class.forName(className);
Collection collection =(Collection)clazz.newInstance();
//Collection collection = new ArrayList();
ReflectPoint pt1 = newReflectPoint(3,3);
ReflectPoint pt2 = newReflectPoint(5,5);
ReflectPoint pt3 = newReflectPoint(3,3);
collection.add(pt1);
collection.add(pt2);
collection.add(pt3);
collection.add(pt1);
System.out.println(collection.size());
}
l 内省à了解JavaBean
l JavaBean是一种特殊的Java类，主要用于传递数据信息，这种java类中的方法主要用于访问私有的字段，且方法名符合某种命名规则。
l 如果要在两个模块之间传递多个信息，可以将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO）。这些信息在类中用私有字段来存储，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问，大家觉得这些方法的名称叫什么好呢？JavaBean的属性是根据其中的setter和getter方法来确定的，而不是根据其中的成员变量。如果方法名为setId，中文意思即为设置id，至于你把它存到哪个变量上，用管吗？如果方法名为getId，中文意思即为获取id，至于你从哪个变量上取，用管吗？去掉set前缀，剩余部分就是属性名，如果剩余部分的第二个字母是小写的，则把剩余部分的首字母改成小的。
Ø setId()的属性名àid
Ø isLast()的属性名àlast
Ø setCPU的属性名是什么?àCPU
Ø getUPS的属性名是什么？àUPS
总之，一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，它根本看不到java类内部的成员变量。
l 一个符合JavaBean特点的类可以当作普通类一样进行使用，但把它当JavaBean用肯定需要带来一些额外的好处，我们才会去了解和应用JavaBean！好处如下：
Ø 在Java EE开发中，经常要使用到JavaBean。很多环境就要求按JavaBean方式进行操作，别人都这么用和要求这么做，那你就没什么挑选的余地！
Ø JDK中提供了对JavaBean进行操作的一些API，这套API就称为内省。如果要你自己去通过getX方法来访问私有的x，怎么做，有一定难度吧？用内省这套api操作JavaBean比用普通类的方式更方便。
l 内省综合案例
l 演示用eclipse自动生成 ReflectPoint类的setter和getter方法。
l 直接new一个PropertyDescriptor对象的方式来让大家了解JavaBean API的价值，先用一段代码读取JavaBean的属性，然后再用一段代码设置JavaBean的属性。
l 演示用eclipse将读取属性和设置属性的流水帐代码分别抽取成方法：
Ø 只要调用这个方法，并给这个方法传递了一个对象、属性名和设置值，它就能完成属性修改的功能。
Ø 得到BeanInfo最好采用“obj.getClass()”方式，而不要采用“类名.class”方式，这样程序更通用。
l 采用遍历BeanInfo的所有属性方式来查找和设置某个RefectPoint对象的x属性。在程序中把一个类当作JavaBean来看，就是调用IntroSpector.getBeanInfo方法， 得到的BeanInfo对象封装了把这个类当作JavaBean看的结果信息。
public static void main(String[] args)throws Exception{
//TODO Auto-generated method stub
ReflectPointpt1 = new ReflectPoint(3,5);
ObjectretVal = getProperty(pt1);
System.out.println(retVal);
PropertyDescriptorpd2 = null;
StringpropertyName = "y";
Objectvalue = 7;
setProperty(pt1,propertyName, value);
//先通过调用普通java类的方法的方式获得结果，然后在这之前插入BeanUtil的get和set操作，见下面的代码。
//System.out.println(pt1.getY());
System.out.println(BeanUtils.getProperty(pt1,"y"));
BeanUtils.setProperty(pt1,"y", "99");
System.out.println(pt1.getY());
PropertyUtils.setProperty(pt1,"y", 999);
System.out.println(PropertyUtils.getProperty(pt1,"y").getClass().getName());
}
privatestatic Object getProperty(ReflectPoint pt1) {
ObjectretVal = null;
PropertyDescriptorpd = null;
try{
pd= new PropertyDescriptor("y",pt1.getClass());
retVal= pd.getReadMethod().invoke(pt1);
}catch (Exception e) {
e.printStackTrace();
}
returnretVal;
}
privatestatic void setProperty(Object pt1, String propertyName,
Objectvalue) {
/*PropertyDescriptorpd2;
try{
pd2= new PropertyDescriptor(propertyName,pt1.getClass());
pd2.getWriteMethod().invoke(pt1,value);
}catch (Exception e) {
e.printStackTrace();
}*/
try{
BeanInfobeanInfo = Introspector.getBeanInfo(pt1.getClass());
PropertyDescriptor[]pds = beanInfo.getPropertyDescriptors();
for(PropertyDescriptorpd :pds){
if(pd.getName().equals(propertyName)){
pd.getWriteMethod().invoke(pt1,value);
break;
}
}
}catch (IllegalArgumentException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}catch (IntrospectionException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}catch (IllegalAccessException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}catch (InvocationTargetException e) {
//TODO Auto-generated catch block
e.printStackTrace();
}
}
l 类加载器
l 简要介绍什么是类加载器和类加载器的作用
l Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：BootStrap,ExtClassLoader,AppClassLoader
l 类加载器也是Java类，因为其他是java类的类加载器本身也要被类加载器加载，显然必须有第一个类加载器不是不是java类，这正是BootStrap。
l Java虚拟机中的所有类装载器采用具有父子关系的树形结构进行组织，在实例化每个类装载器对象时，需要为其指定一个父级类装载器对象或者默认采用系统类装载器为其父级类加载。
1. 逐一编写如下代码来说明放置在不同位置的类确实由不同的类加载器加载的：
System.out.println(ClassLoaderTest.class.getClassLoader().getClass().getName());
//将上面语句的测试类改为System则抛NullPointerException，这两个类存放位置不同
System.out.println(System.class.getClassLoader().getClass().getName());
改为System.out.println(System.class.getClassLoader());打印的结果为null。
2.用下面的代码让查看类加载器的层次结构关系
ClassLoaderloader = ClassLoaderTest.class.getClassLoader();
//打印出当前的类装载器，及该类装载器的各级父类装载器
while(loader!= null)
{
System.out.println(loader.getClass().getName());
loader= loader.getParent();
}
l 类加载器的委托机制
l 当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
l 首先当前线程的类加载器去加载线程中的第一个类。
l 如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。
l 还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。
l 每个类加载器加载类时，又先委托给其上级类加载器。
l 当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那有多个儿子，找哪一个呢？
l 对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。
l 编写自己的类加载器
l 知识讲解：
l 自定义的类加载器的必须继承ClassLoader
l loadClass方法与findClass方法
l defineClass方法
l 编程步骤：
l 编写一个对文件内容进行简单加密的程序。
l 编写了一个自己的类装载器，可实现对加密过的类进行装载和解密。
l 编写一个程序调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类。程序中可以除了使用ClassLoader.load方法之外，还可以使用设置线程的上下文类加载器或者系统类加载器，然后再使用Class.forName。
l 实验步骤：
l 对不带包名的class文件进行加密，加密结果存放到另外一个目录，例如： java MyClassLoader MyTest.class F:\itcast
l 运行加载类的程序，结果能够被正常加载，但打印出来的类装载器名称为AppClassLoader：java MyClassLoader MyTest F:\itcast
l 用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类装载器装载失败。
l 删除CLASSPATH环境下的类文件，再执行上一步操作就没问题了。
import java.io.*;
import java.lang.reflect.*;
public class MyClassLoader extendsClassLoader
{
privateString path = null;
publicMyClassLoader(String path) throws Exception//检查文件是否存在
{
Filef = new File(path);
if(!f.isDirectory())
{
thrownew RuntimeException(path + " is not a directory");
}
this.path= path;
}
publicClass findClass(String name) //throws Exception //为什么不能抛出
{
try
{
Filef = new File(path,name.substring(name.lastIndexOf('.')+1) +".class");
FileInputStreamfis = new FileInputStream(f);
ByteArrayOutputStreambos = new ByteArrayOutputStream();
cypher(fis,bos);
byte[] buf = bos.toByteArray();
fis.close();
bos.close();
returndefineClass(name,buf,0,buf.length);
}catch(Exceptione)
{
thrownew ClassNotFoundException(name + " is not found!");
}
returnnull;
}
publicstatic void cypher(InputStream istream,OutputStream ostream) throws Exception
{
//下面这段代码可能遇到255的字节，当成byte就成了-1
/*byteb = 0;
while((b= (byte)istream.read()) != -1)
{
ostream.write(b^ 0xff);
}*/
intb = 0;
while((b= istream.read()) != -1)
{
ostream.write(((byte)b)^ 0xff);
}
}
publicstatic void main(String [] args) throws Exception
{
//下面省略了错误检查
if(!args[0].endsWith("class"))
{
ClassLoaderloader = new MyClassLoader(args[1]);
Classcls = loader.loadClass(args[0]);
/*
让自定义类继承Date类
System.out.println(cls.getClassLoader().getClass().getName());
java.util.Dated = (java.util.Date)cls.newInstance();
System.out.println(d.toString());
*/
//Methodm = cls.getMethod("test",null);//在jdk1.5中报警告，为什么？
Methodm = cls.getMethod("test");
//m.invoke(cls.newInstance(),null);
m.invoke(cls.newInstance());
//((Test)cls.newInstance()).test();
return;
}
else
{
FileInputStreamfis = new FileInputStream(args[0]);
Filef = new File(args[1], new File(args[0]).getName());//不用检查目录最后是否有目录分割符
FileOutputStreamfos = new FileOutputStream(f);
cypher(fis,fos);
fis.close();
fos.close();
}
}
}
//类加载器不能加载这种非public的类
/*
Exception in thread "main"java.lang.IllegalAccessException: Class MyClassLoader
cannot access a member of class MyTest with modifiers ""
*/
/*
class MyTest
{
publicvoid test()
{
System.out.println("hello,www.it315.org");
}
}
*/
l 代理的概念与作用
l 生活中的代理
l 武汉人从武汉的代理商手中买联想电脑和直接跑到北京传智播客旁边来找联想总部买电脑，你觉得最终的主体业务目标有什么区别吗？基本上一样吧，都解决了核心问题，但是，一点区别都没有吗？从代理商那里买真的一点好处都没有吗？
l 程序中的代理
l 要为已存在的多个具有相同接口的目标类的各个方法增加一些系统功能，例如，异常处理、日志、计算方法的运行时间、事务管理、等等，你准备如何做？
l 编写一个与目标类具有相同接口的代理类，代理类的每个方法调用目标类的相同方法，并在调用方法时加上系统功能的代码。（参看下页的原理图）
l 如果采用工厂模式和配置文件的方式进行管理，则不需要修改客户端程序，在配置文件中配置是使用目标类、还是代理类，这样以后很容易切换，譬如，想要日志功能时就配置代理类，否则配置目标类，这样，增加系统功能很容易，以后运行一段时间后，又想去掉系统功能也很容易。
l 动态代理技术
l 要为系统中的各种接口的类增加代理功能，那将需要太多的代理类，全部采用静态代理方式，将是一件非常麻烦的事情！写成百上千个代理类，是不是太累！
l JVM可以在运行期动态生成出类的字节码，这种动态生成的类往往被用作代理类，即动态代理类。
l JVM生成的动态类必须实现一个或多个接口，所以，JVM生成的动态类只能用作具有相同接口的目标类的代理。
l CGLIB库可以动态生成一个类的子类，一个类的子类也可以用作该类的代理，所以，如果要为一个没有实现接口的类生成动态代理类，那么可以使用CGLIB库。
l 代理类的各个方法中通常除了要调用目标的相应方法和对外返回目标返回的结果外，还可以在代理方法中的如下四个位置加上系统功能代码：
l 1.在调用目标方法之前
l 2.在调用目标方法之后
l 3.在调用目标方法前后
l 4.在处理目标方法异常的catch块中
l 分析JVM动态生成的类
l 创建实现了Collection接口的动态类和查看其名称，分析Proxy.getProxyClass方法的各个参数。
l 编码列出动态类中的所有构造方法和参数签名
l 编码列出动态类中的所有方法和参数签名
l 创建动态类的实例对象
l 用反射获得构造方法
l 编写一个最简单的InvocationHandler类
l 调用构造方法创建动态类的实例对象，并将编写的InvocationHandler类的实例对象传进去
l 打印创建的对象和调用对象的没有返回值的方法和getClass方法，演示调用其他有返回值的方法报告了异常。
l 将创建动态类的实例对象的代理改成匿名内部类的形式编写，锻炼大家习惯匿名内部类。
l 总结思考：让jvm创建动态类及其实例对象，需要给它提供哪些信息?
l 三个方面：
l 生成的类中有哪些方法，通过让其实现哪些接口的方式进行告知；
l 产生的类字节码必须有个一个关联的类加载器对象；
l 生成的类中的方法的代码是怎样的，也得由我们提供。把我们的代码写在一个约定好了接口对象的方法中，把对象传给它，它调用我的方法，即相当于插入了我的代码。提供执行代码的对象就是那个InvocationHandler对象，它是在创建动态类的实例对象的构造方法时传递进去的。在上面的InvocationHandler对象的invoke方法中加一点代码，就可以看到这些代码被调用运行了。
l 用Proxy.newInstance方法直接一步就创建出代理对象。
450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
