一、由内省IntroSpector引出JavaBean

1、概述：

1、IntroSpector：即内省，是对内部进行检查，了解更多的底层细节。

2、内省的作用：主要针对JavaBean进行操作。

2、JavaBean（存在于java.bean包中）

1、简述：

1）JavaBean是一种特殊的Java类，主要用于传递数据信息，这种Java类中的方法主要用于访问私有的字段，且方法都符合某种特殊的命名规则。

2）它是一种特殊的Java类，其中的方法名称等，都符合特殊的规则。只要一个类中含有get和set打头的方法，就可以将其当做JavaBean使用。

3）字段和属性：
字段就是我们定义的一些成员变量，如private String name; 等
而属性是具有某些功能，Bean属性，是含有get或set方法的那些属性的字段，即这个变量的get属性，set属性等。

2、作用：
如果要在两个模板之间传递多个信息，可将这些信息封装到一个JavaBean中，这种JavaBean的实例对象通常称之为值对象（Value Object，简称VO），这些信息在类中用私有字段来储存，如果读取或设置这些字段的值，则需要通过一些相应的方法来访问。

3、命名方式：
JavaBean的属性是根据其中的setter和getter方法来确定的，而不是依据其中的变量，如方法名为setId，则中文意思是设置Id，getId也是如此；去掉前缀，剩余部分就是属性名称，如果剩余部分的第二个字母小写，则把剩余部分改为小写。如：getAge/setAge-->age；gettime-->time；setTime-->time；getCPU-->CPU。

4、总之、一个类被当做JavaBean使用时，JavaBaan的属性是根据方法名推断出来的，它根本看不到Java类内部的成员变量。

5、JavaBean的好处：
一个符合JavaBean特点的类当做普通类一样可以使用，但是把它当做JavaBean类用肯定有好处的：

1）在JavaEE开发中，经常要使用JavaBean。很多环境就要求按JavaBean的方式进行操作，别人都这么用，那么就必须要求这么做。

2）JDK中提供了对JavaBean进行操作的API，这套API称为内省，若要自己通过getX的方式来访问私有x，可用内省这套API，操作JavaBean要比使用普通的方式更方便。

示例：

package cn.itcast.text1;  
  
import java.beans.BeanInfo;  
import java.beans.IntrospectionException;  
import java.beans.Introspector;  
import java.beans.PropertyDescriptor;  
import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
  
public class IntroSpectorTest {  
  
    /** 
     * @param args 
     */  
    /* 
     * public static void main(String[] args) throws Exception { 
     
        // TODO Auto-generated method stub 
        ReflectPoint pt1 = new ReflectPoint(3,5); 
        String propertyName = "x"; 
        //"x"-->"X"-->"getX"-->MethodGetX--> 
        //内省的方式: 
        //属性描述符：PropertyDescriptor 
        //get属性信息 
        PropertyDescriptor pd = 
                new PropertyDescriptor(propertyName,pt1.getClass()); 
        Method methodGetX = pd.getReadMethod(); 
        Object retVal = methodGetX.invoke(pt1); 
        System.out.println(retVal); 
        //set属性信息 
        Object value = 7; 
        PropertyDescriptor pd2 = 
                new PropertyDescriptor(propertyName,pt1.getClass()); 
        Method methodSetX = pd2.getWriteMethod(); 
        methodSetX.invoke(pt1,value); 
         
        System.out.println(pt1.getX()); 
     } 
     */  
    //上面的get或set代码分别通过选中要重构的代码，通过右击选重构获得get和set方法：  
    public static void main(String[] args) throws Exception {  
        // TODO Auto-generated method stub  
        ReflectPoint pt1 = new ReflectPoint(3,5);  
        String propertyName = "x";  
        //一般方式："x"-->"X"-->"getX"-->MethodGetX-->  
        //内省方式:  
        //通过get和set方法获取属性值  
        Object retVal = getProperty(pt1, propertyName);  
        System.out.println(retVal);  
          
        Object value = 7;  
        setProperty(pt1, propertyName, value);  
        System.out.println(pt1.getX());  
    }  
      
        //设置属性值的方法             //此处的类型为Object，通用，下同  
    private static void setProperty(Object rf, String propertyName,  
            Object value) throws IntrospectionException,  
            IllegalAccessException, InvocationTargetException {  
        //创建属性描述符对象，将属性名称和加载文件等信息写入其中  
        PropertyDescriptor pd =  
                new PropertyDescriptor(propertyName,rf.getClass());  
        //通过反射的方法类Method，获取属性所对应的set方法  
        Method methodSetX = pd.getWriteMethod();  
        methodSetX.invoke(rf, value);  
    }  
    //获取属性值的方法  
    private static Object getProperty(Object rf, String propertyName)  
            throws IntrospectionException, IllegalAccessException,  
            InvocationTargetException {  
        //创建属性描述符对象，获取属性所对应的名称和加载文件等信息  
        PropertyDescriptor pd =  
                new PropertyDescriptor(propertyName,rf.getClass());  
        //通过反射的方法类Method，获取属性所对应的get方法  
        Method methodGetX = pd.getReadMethod();  
        Object retVal = methodGetX.invoke(rf);  
        return retVal;  
    }  
}

3、对JavaBean的复杂内省操作：

1、在IntroSpector类中有getBeanInfo(Class cls)的方法。

2、获取Class对象的Bean信息，返回的是BeanInfo类型。

3、BeanInfo类中有getPropertyDescriptors()的方法，可获取所有的BeanInfo的属性信息，返回一个PropertyDescriptor[]。

4、在通过遍历的形式，找出与自己想要的那个属性信息。
如：改写get方法：

…  
BeanInfo beanInfo = Introspector.getBeanInfo(pt1.getClass());  
        PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();  
        Object value = null;  
        for(PropertyDescriptor pd : pds){  
            if(pd.getName().equals(propertyName)){  
                Method methodGetX = pd.getReadMethod();  
                value = methodGetX.invoke(pt1);  
                break;  
            }  
        }  
…  

这种方式要比上面的方法复杂些。

4、BeanUtils工具包：

1、BeanUtils等工具包都是由阿帕奇提供的，为了便于开发。

2、BeanUtils可以将8种基本数据类型进行自动的转换，因此对于非基本数据类型，就需要注册转换器Converter，这就需要ConverUtils包，

2、好处：

1）提供的set或get方法中，传入的是字符串，返回的还是字符串，因为在浏览器中，用户输入到文本框的都是以字符串的形式发送至服务器上的，所以操作的都是字符串。也就是说这个工具包的内部有自动将整数转换为字符串的操作。

2）支持属性的级联操作，即支持属性链。如可以设置：人的脑袋上的眼镜的眼珠的颜色。这种级联属性的属性连如果自己用反射，那就很困难了，通过这个工具包就可以轻松调用。

3、可以和Map集合进行相互转换：可将属性信息通过键值对的形式作为Map集合存储（通过staticjava.util.Map describe(java.lang.Object bean)的方法），也可以将Map集合转换为JavaBean中的属性信息（通过static voidpopulate(java.lang.Object bean, java.util.Map properties)的方法）。

4、示例：
1）设置和获取属性值：

import java.lang.reflect.InvocationTargetException;  
import java.text.ParseException;  
import java.text.SimpleDateFormat;  
import java.util.Date;  
import java.util.Map;  
import java.util.TreeMap;  
  
import org.apache.commons.beanutils.BeanUtils;  
import org.apache.commons.beanutils.ConversionException;  
import org.apache.commons.beanutils.ConvertUtils;  
import org.apache.commons.beanutils.Converter;  
import org.apache.commons.beanutils.PropertyUtils;  
import org.apache.commons.beanutils.locale.converters.DateLocaleConverter;  
import org.junit.Test;  
  
public class BeanUtilDemo {  
  
    /** 
     * BeanUtils使用 
     */  
  
    @Test   
    public void test1() throws Exception{  
        //创建对象，设置属性值  
        Person p = new Person();  
        BeanUtils.setProperty(p, "name", "zzz");  
        String name = BeanUtils.getProperty(p, "name");  
        System.out.println(name);  
    }  
      
    @Test   
    public void test2() throws Exception{  
        //创建对象，传入属性值  
        Person p = new Person();  
        String name = "wangwu";  
        String age = "23";  
        String hight = "173.5";  
        //设置属性值  
        BeanUtils.setProperty(p, "name", name);  
        BeanUtils.setProperty(p, "age", age);  
        BeanUtils.setProperty(p, "hight", hight);  
        //获取属性值  
        System.out.println(BeanUtils.getProperty(p, "name"));  
        System.out.println(BeanUtils.getProperty(p, "age"));  
        System.out.println(BeanUtils.getProperty(p, "hight"));  
    }

2）未注册的属性值的获取和设置

//获取未注册的属性，即非八种基本数据类型的引用类型  
//private Date birthday  
@Test   
public void test3() throws Exception{  
    Person p = new Person();  
    String name = "wangwu";  
    String age = "23";  
    String hight = "173.5";  
    String birthday = "1990-09-09";  
    ConvertUtils.register(new Converter() {  
        //注册器Converter接口中方法的重写  
        @Override  
        public Object convert(Class type, Object value) {  
            if(value == null)  
                return null;  
            if(!(value instanceof String))  
                throw new ConversionException("只支持String类型的转换");  
            String str = (String) value;  
            if(value.equals(""))  
                return null;  
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");  
            try{  
                return sdf.parse(str);  
            }catch(ParseException e){  
                throw new RuntimeException(e);//异常链不能掉，这里必须写上e  
            }  
        }},  
        Date.class);  
      
    //测试  
    BeanUtils.setProperty(p, "name", name);  
    BeanUtils.setProperty(p, "age", age);  
    BeanUtils.setProperty(p, "hight", hight);  
    BeanUtils.setProperty(p, "birthday", birthday);  
    System.out.println(BeanUtils.getProperty(p, "name"));  
    System.out.println(BeanUtils.getProperty(p, "age"));  
    System.out.println(BeanUtils.getProperty(p, "hight"));  
    System.out.println(BeanUtils.getProperty(p, "birthday"));  
}  
  
//使用已经写好的注册器DateLocaleConverter  
@Test   
public void test4() throws Exception{  
    Person p = new Person();  
    String name = "wangwu";  
    String age = "23";  
    String hight = "173.5";  
    String birthday = "1990-09-09";  
    //将日期注册到BeanUtils上  
    ConvertUtils.register(new DateLocaleConverter(), Date.class);//提供的注册器不健壮，因为传入空字符串，就会报错  
                                                                //所以，当没有提供注册器或需要加强注册器的时候，可以自己写  
    //测试  
    BeanUtils.setProperty(p, "name", name);  
    BeanUtils.setProperty(p, "age", age);  
    BeanUtils.setProperty(p, "hight", hight);  
    BeanUtils.setProperty(p, "birthday", birthday);  
    System.out.println(BeanUtils.getProperty(p, "name"));  
    System.out.println(BeanUtils.getProperty(p, "age"));  
    System.out.println(BeanUtils.getProperty(p, "hight"));  
    System.out.println(BeanUtils.getProperty(p, "birthday"));  
    Date date = p.getBirthday();  
    System.out.println(date.toLocaleString());  
}  

3）Map集合在BeanUtils中的应用：

//Map集合在BeanUtils中的应用  
@Test  
public void test5() throws Exception {  
    /* 
     * JDK 7.0新特性：  
     * Map map = {"name" : "zs", "age" : 22, "hight" : 176.5}; 
     */  
    //将数据存入集合  
    Map map = new TreeMap();  
    map.put("name", "zhangsan");  
    map.put("age", "20");  
    map.put("hight", "172.5");  
    map.put("birthday", "1999-10-02");  
      
    //注册器  
    ConvertUtils.register(new DateLocaleConverter(), Date.class);  
    //获取属性  
    Person p = new Person();  
    BeanUtils.populate(p, map);  
      
    System.out.println(BeanUtils.getProperty(p, "name"));  
    System.out.println(BeanUtils.getProperty(p, "age"));  
    System.out.println(BeanUtils.getProperty(p, "hight"));  
    System.out.println(BeanUtils.getProperty(p, "birthday"));  
      
}  
  
//属性链  
@Test  
public void test6() throws Exception {  
    Person p = new Person();  
    BeanUtils.setProperty(p, "birthday.time", "111212");  
    System.out.println(BeanUtils.getProperty(p, "birthday.time"));  
}  

二、注解 【JDK1.5】

1、概述：

1、注解相当于一种标记，在程序中加了注解就等于为程序打上了某种标记，没加，则没有某种标记。

2、以后，java编译器、开发工具和其他应用程序就可以用反射来了解自己的类及各种元素上有无何种标记，有什么标记，就会做出相应的处理。

3、标记可以加在包、类、字段、方法、方法参数，以及局部变量上等等。

4、在java.lang包中提供了最基本的annotation，即注解。

5、格式：@注解类名()。如果有属性，则在括号中加上属性名（可省略）和属性值。

2、本的注解：

1、@SuppressWarning(”deprecation”) 压制警告
SupressWarning是告知编译器或开发工具等提示指定的编译器警告；
”deprecation”是告知具体的信息即方法已过时。

2、@Deprecated 提示成员等已经过时，不再推荐使用。
源代码标记@Deprecated是在JDK1.5中作为内置的annotation引入的，用于表明类(class)、方法(method)、字段(field)已经不再推荐使用，并且在以后的JDK版本中可能将其删除，编译器在默认情况下检测到有此标记的时候会提示警告信息。
例如：假定之前的某个类升级了，其中的某个方法已经过时了，不能够将过时的方法删除，因为可能会影响到调用此类的这个方法的某些程序，这是就可以通过在方法上加这个注解。

3、@Override 提示覆盖（父类方法）
加上此注解，，可对自己类中的方法判断是否是要覆盖的父类的方法，典型的例子即在集合中覆盖equals(Object obj)方法，其中的参数类型必须是Object，才能被覆盖，若不是，加上此注解就会提示警告。

3、注释的应用--->注解类：

1、定义格式：@interface 名称{statement}

2、元注解（注解的注解）
一个注解有其生命周期（Retetion）和存放的位置（Taget），这就可以通过元注解说明。

1）Retetion：用于说明注解保留在哪个时期，加载定义的注解之上。
①一个注解的声明周期包含：
java源程序--(javac)-->class文件--(类加载器)-->内存中的字节码

第一、当再源程序上加了注解，javac将java源程序编译为class文件，可能会把源程序中的一些注解去掉，进行相应的处理操作，当我们拿到源程序的时候，就看不到这些注解了。

第二、假设javac把这些注解留在了源程序中（或者说留在了class文件中），当运行此class文件的时候，用类加载器将class文件调入内存中，此时有转换的过程，即把class文件中的注解是否保留下来也不一定。

注意：
class文件中不是字节码，只有把class文件中的内部加载进内存，用类加载器加载处理后（进行完整的检查等处理），最终得到的二进制内容才是字节码。

②Reteton（枚举类）取值：
Retetion.Policy.SOURSE：java源文件时期，如@Overried和@SuppressWarning
Retetion.Policy.CLASS： class文件时期（默认阶段）
Retetion.Policy.RUNTIME：运行时期，如@Deprecated

2）Taget：用于说明注解存放在哪些成分上，默认值是任何元素
其值可设置为枚举类ElementType类中的任何一个，包括：包、字段、方法、方法参数、构造器、类等值。
取值为：
PACKAGE(包声明)
FIELD(字段声明)
ANNOTATION_TYPE(注释类型声明)
CONSIRUCTOR(构造器声明)
METHOD(方法声明)
PARAMETER(参数声明)
TYPE(类、接口（包含注释类型）或枚举声明)
LOCAL_VARIABLE(局部变量声明)

注意：
其中代表类的值是TYPE。因为class、enum、interface和@interface等都是属于Type的。不可用CLASS表示。

3、通过反射查看其它类中的注释：

过程：
第一、注解类：@interfaceA{}
第二、应用了“注释类”的类：@Aclass B{}
第三、对“应用注释类的类”进行反射操作的类：class{...}，操作如下：

B.class.isAnnotionPresent(A.class);//判断是否存在此注解类
A a = B.class.getAnnotation(a.class);//存在的话则得到这个注释类的对象

示例：

@Retention(RetentionPolicy.RUNTIME)  
@Target({ElementType.TYPE,ElementType.METHOD})  
public @interface ItcastAnnotation {}  
  
@ItcastAnnotation()  
public class AnnotionTest {  
    @SuppressWarnings("deprecation")//表示压制警告的注解  
    @ItcastAnnotation()  
    public static void main(String[] args) {  
        System.runFinalizersOnExit(true);  
        //反射方式查看注解  
        //检查类上是否有注解  
        if(AnnotionTest.class.isAnnotationPresent(ItcastAnnotation.class)){  
            //通过反射获取到注解  
            ItcastAnnotation annotation = AnnotionTest.class.getAnnotation(ItcastAnnotation.class);  
            System.out.println(annotation);  
        }  
    }

4、为注解增加基本属性

1、属性：
一个注解相当于一个胸牌，但仅通过胸牌还不足以区别带胸牌的两个人，这时就需要给胸牌增加一个属性来区分，如颜色等。

2、定义格式：同接口中的方法一样：String color();
定义缺省格式：Stringvalue() default ”ignal”;

3、应用：直接在注解的括号中添加自身的属性，如：

@ItcastAnnotation(color=”red”)

这个和上面的@SuppressWarnings("deprecation")是一样的，其中的"deprecation"就是属性值

1）当只有一个属性时，可直接传入属性值。如”red”
2）当含有其他属性值的时候，如果那个属性值是缺省的（default），也可以直接传入这个属性值。

5、为注解增加高级属性

1、可以为注解增加的高级属性的返回值类型有：
1）八种基本数据类型
2）String类型
3）Class类型
4）枚举类型
5）注解类型
6）前五种类型的数组

2、数组类型的属性：
定义：int[]arrayArr() default {1,2,3}; -->可不定义默认值
应用：@MyAnnotation(arrayArr={2,3,4}) -->可重新赋值

注：若数组属性中只有一个元素（或重新赋值为一个元素），这时属性值部分可省略大括号。

3、枚举类型的属性：
假设定义了一个枚举类TraffLamp，它是EnumTest的内部类，其值是交通灯的三色。
定义：EnumTest.TrafficLamplamp();
应用：@MyAnnotation(lamp=EnumTestTrafficLamp.GREEN)

4、注解类型的属性：
假定有个注解类：MetaAnnotation，其中定义了一个属性：String value()
定义：MetaAnnotationannotation() default @MetaAnnotation(”xxx”);
应用：@MyAnnotation(annotation=@MetaAnnotation(”yyy”)) -->可重新赋值

可认为上面的@MetaAnnotation是MyAnnotation类的一个实例对象，同样可以认为上面的@MetaAnnotation是MetaAnnotation类的一个实例对象，调用：

MetaAnnotation ma =MyAnnotation.annotation();
System.out.println(ma.value());

5、Class类型的属性：
定义：Class cls();
应用：@MyAnnotation(cls=ItcastAnnotion.class)

注：这里的.class必须是已定义的类，或是已有的字节码对象

7、基本数据类型的属性（以int为例）：
定义：int val()default 3; -->可不定义默认值
应用：@MyAnnotation(val=7) --> 可重新赋值

8、注解的详细语法可通过查看java语言规范了解即javaLanguage Specification

示例：

//自定义注解类  
package cn.itcast.text2;  
import java.lang.annotation.ElementType;  
import java.lang.annotation.Retention;  
import java.lang.annotation.RetentionPolicy;  
import java.lang.annotation.Target;  
  
import cn.itcast.text1.EnumText;  
//将定义的注解的生命周期设置在运行时期  
@Retention(RetentionPolicy.RUNTIME)  
//定义注解的放置位置  
@Target({ElementType.TYPE,ElementType.METHOD})  
//自定义注解  
public @interface ItcastAnnotation {  
    //定义属性  
    String str();  
    int val() default 1;  
    int[] arr() default {2,3,4};  
    Class cls() default AnnotionTest.class;  
    EnumText.TrafficLamp lamp() default EnumText.TrafficLamp.YELLOW;  
    MetaAnnotation annotation() default @MetaAnnotation("sss");  
}  
  
//测试注解类，用反射查看其属性  
package cn.itcast.text2;  
import cn.itcast.text1.EnumText;  
@ItcastAnnotation(annotation=@MetaAnnotation("anntation"),  
                Lamp=EnumText.TrafficLamp.RED,  
                arr=7,val=5,str="String",  
                cls=ItcastAnnotation.class)  
public class AnnotionTest {  
    @SuppressWarnings("deprecation")//表示压制警告的注解  
    @ItcastAnnotation(str = "yyy")//有缺省值可不用写缺省部分  
    public static void main(String[] args) {  
        //反射方式查看注解  
        //检查类上是否有注解  
        if(AnnotionTest.class.isAnnotationPresent(ItcastAnnotation.class)){  
            //通过反射获取到注解  
            ItcastAnnotation annotation = AnnotionTest.class.getAnnotation(ItcastAnnotation.class);  
            //打印查看属性值  
            System.out.println(annotation);  
            System.out.println(annotation.str());  
            System.out.println(annotation.val());  
            System.out.println(annotation.arr().length);  
            System.out.println(annotation.cls().getName());  
            System.out.println(annotation.lamp().nextLamp());  
            System.out.println(annotation.annotation().value());  
        }  
    }  
}  
  
//定义枚举类，交通灯  
package cn.itcast.text1;  
public class EnumText {  
    public static void main(String[] args) {}  
    //定义交通灯  
    public enum TrafficLamp{  
        //定义3个元素，即此类的子类，覆写抽象方法  
        RED(30){  
            @Override  
            public TrafficLamp nextLamp() {return GREEN;}},  
        GREEN(45){  
            @Override  
            public TrafficLamp nextLamp() {return YELLOW;}},  
        YELLOW(5) {  
            @Override  
            public TrafficLamp nextLamp() {return RED;}};  
        private int time;  
        //构造方法  
        private TrafficLamp(int time){this.time = time;}  
        //抽象方法，转为下个灯  
        public abstract TrafficLamp nextLamp();  
    }  
}  

三、类加载器

1、概述：

1、定义：简单说，类加载器就是加载类的工具。
当出现一个类，用到此类的时候，Java虚拟机首先将类字节码加载进内存，通常字节码的原始信息放在硬盘上的classpath指定的目录下。

2、类加载器作用：将.class文件中的内容加载进内存进行处理，处理完后的结果就是字节码。

3、默认类加载器：
1）Java虚拟机中可安装多个类加载器，系统默认的有三个主要的，每个类负责加载特定位置的类：BootStrap、ExtClassLoader、AppClassLoader

2）BootStrap--顶级类加载器：
类加载器本身也是Java类，因为它是Java类，本身也需要加载器加载，显然必须有第一个类加载器而不是java类的，这正是BootStrap。它是嵌套在Java虚拟机内核中的，已启动即出现在虚拟机中，是用c++写的一段二进制代码。所以不能通过java程序获取其名字，获得的只能是null。

4、Java虚拟机中的所有类加载器采用子父关系的树形结构进行组织，在实例化每个类加载器对象或默认采用系统类加载器作为其父级类加载器。

示意图

示例：

package cn.itcast.text2;  
import java.util.Date;  
public class ClassLoadTest{  
    public static void main(String[] args) throws Exception{  
        System.out.println(  
                ClassLoadTest.class.getClassLoader().  
                getClass().getName());//为AppClassLoader  
        System.out.println(  
                System.class.getClassLoader());//为null  
    }  
}

2、类加载器的委托机制：

1、加载类的方式
当Java虚拟机要加载一个类时，到底要用哪个类加载器加载呢？

1）首先，当前线程的类加载器去加载线程中的第一个类。
2）若A引用类B（继承或者使用了B），Java虚拟机将使用加载类的类加载器来加载类B。
3）还可直接调用ClassLoader的LoaderClass()方法，来制定某个类加载器去加载某个类。

2、加载器的委托机制：每个类加载器加载类时，又先委托给上级类加载器。
每个ClassLoader本身只能分别加载特定位置和目录中的类，但他们可以委托其他类的加载器去加载，这就是类加载器的委托模式，类加载器一级级委托到BootStrap类加载器，当BootStrap在指定目录中没有找到要加载的类时，无法加载当前所要加载的类，就会一级级返回子孙类加载器，进行真正的加载，每级都会先到自己相应指定的目录中去找，有没有当前的类；直到退回到最初的类装载器的发起者时，如果它自身还未找到，未完成类的加载，那就报告ClassNoFoundException的异常。

简单说，就是先由发起者将类一级级委托为BootStrap，从父级开始找，找到了直接返回，没找到再返回给其子级找，直到发起者，再没找到就报异常。

3、委托机制的优点：可以集中管理，不会产生多字节码重复的现象。
补充：
面试题：可不可以自己写个类为：java.lang.System呢？

回答：
第一、通常是不可以的，由于类加载器的委托机制，会先将System这个类一级级委托给最顶级的BootStrap，由于BootStrap在其指定的目录中加载的是rt.jar中的类，且其中有System这个类，那么就会直接加载自己目录中的，也就是Java已经定义好的System这个类，而不会加载自定义的这个System。
第二、但是还是有办法加载这个自定义的System类的，此时就不能交给上级加载了，需要用自定义的类加载器加载，这就需要有特殊的写法才能去加载这个自定义的System类的。

3、自定义类加载器

1、自定义的类加载器必须继承抽象类ClassLoader，要覆写其中的findClass(String name)方法，而不用覆写loadClass()方法。

2、覆写findClass(String name)方法的原因：
1）是要保留loadClass()方法中的流程，因为loadClass()中调用了findClass(String name)这个方法，此方法返回的就是去寻找父级的类加载器。

2）在loadClass()内部是会先委托给父级，当父级找到后就会调用findClass(String name)方法，而找不到时就会用子级的类加载器，再找不到就报异常了，所以只需要覆写findClass方法，那么就具有了实现用自定义的类加载器加载类的目的。

流程：
父级-->loadClass-->findClass-->得到Class文件后转化成字节码-->defind()。

3、编程步骤：
1）编写一个对文件内容进行简单加盟的程序
2）编写好了一个自己的类加载器，可实现对加密过来的类进行装载和解密。
3）编写一个程序，调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类，程序中除了可使用ClassLoader的load方法外，还能使用放置线程的上线文类加载器加载或系统类加载器，然后在使用forName得到字节码文件。

示例：

package cn.itcast.text2;  
import java.util.Date;  
  
public class ClassLoaderAttachment extends Date {  
    //对此类进行加密  
        public String toString(){  
            return "hello world";  
        }  
        public static void main(String [] args){  
              
        }  
}  
  
//自定义类加载器  
package cn.itcast.text2;  
  
import java.io.*;  
//继承抽象类ClassLoader  
public class MyClassLoader  extends ClassLoader {  
    public static void main(String[] args) throws Exception {  
        //传入两个参数，源和目标  
        String scrPath = args[0];  
        String destDir = args[1];  
        //将数据读取到输入流中，并写入到输出流中  
        FileInputStream fis = new FileInputStream(scrPath);  
        String destFileName =   
                scrPath.substring(scrPath.lastIndexOf('\\')+1);  
        String destPath = destDir + "\\" + destFileName;  
        FileOutputStream fos = new FileOutputStream(destPath);  
        //加密数据  
        cypher(fis,fos);  
        fis.close();  
        fos.close();  
    }  
    //定义加密数据的方法  
    private static void cypher(InputStream ips,OutputStream ops)throws Exception{  
        int b = 0;  
        while((b=ips.read())!=-1){  
            ops.write(b ^ 0xff);  
        }  
    }  
    //定义全局变量  
    private String classDir;  
    @Override//覆写findClass方法，自定义类加载器  
    protected Class<?> findClass(String name) throws ClassNotFoundException {  
        String classFileName = classDir + "\\" + name + ".class";   
        try {  
            //将要加载的文件读取到流中，并写入字节流中  
            FileInputStream fis = new FileInputStream(classFileName);  
            ByteArrayOutputStream bos = new ByteArrayOutputStream();  
            cypher(fis,bos);  
            fis.close();  
            byte[] bytes = bos.toByteArray();  
            return defineClass(bytes, 0, bytes.length);  
              
        } catch (Exception e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
        //如果没找到类，则用父级类加载器加载  
        return super.findClass(name);  
    }  
    //构造函数  
    public MyClassLoader(){}  
    public MyClassLoader(String classDir){  
        this.classDir = classDir;  
    }  
}

类加载器与内省结合的小程序

下面是内省和类加载器综合使用的一个小程序

package cn.itcast.text1;  
  
import java.beans.IntrospectionException;  
import java.beans.PropertyDescriptor;  
import java.io.IOException;  
import java.io.InputStream;  
import java.lang.reflect.InvocationTargetException;  
import java.lang.reflect.Method;  
import java.util.Properties;  
  
public class LoaderToJavaBean {  
        public static void main(String [] args)throws Exception {  
                //创建ReflectPoint对象，并赋值  
                ReflectPoint rf = new ReflectPoint(3,7);  
                //通过get方法获取属性名称  
                String propertyName = getPropertyName();  
                //通过get方法获取属性值  
                Object retVal = getProperty(rf, propertyName);  
                System.out.println(retVal);  
                //通过set方法设置属性值  
                Object value = 7;  
                setProperty(rf, propertyName, value);  
                System.out.println(rf.getX());  
        }  
        //设置属性值的方法  
        private static void setProperty(Object rf, String propertyName,  
                        Object value) throws IntrospectionException,  
                        IllegalAccessException, InvocationTargetException {  
                //创建属性描述符对象，将属性名称和加载文件等信息写入其中  
                PropertyDescriptor pd =  
                                new PropertyDescriptor(propertyName,rf.getClass());  
                //通过反射的方法类Method，获取属性所对应的set方法  
                Method methodSetX = pd.getWriteMethod();  
                methodSetX.invoke(rf, value);  
        }  
        //获取属性值的方法  
        private static Object getProperty(Object rf, String propertyName)  
                        throws IntrospectionException, IllegalAccessException,  
                        InvocationTargetException {  
                //创建属性描述符对象，获取属性所对应的名称和加载文件等信息  
                PropertyDescriptor pd =  
                                new PropertyDescriptor(propertyName,rf.getClass());  
                //通过反射的方法类Method，获取属性所对应的get方法  
                Method methodGetX = pd.getReadMethod();  
                Object retVal = methodGetX.invoke(rf);  
                return retVal;  
        }  
        //获取属性名称的方法  
        private static String getPropertyName() throws IOException {  
                //创建读取流对象，将文件中的信息读取到流中  
                InputStream in =  
                        LoaderToJavaBean.class.getResourceAsStream("config.propert");//这里可以用任何你程序中存在的类加载  
                //创建Propertie对象，将流中信息加载进内存  
                Properties props = new Properties();  
                props.load(in);  
                in.close();  
                //获取文件中的属性名称，并作为返回值返回  
                String propertyName = props.getProperty("propertyName");  
                return propertyName;  
        }  
}