黑马程序员 Java自学总结十九 Java高新技术第二天

------ ASP.Net+Android+IO开发.Net培训期待与您交流！ ------

总结内容来源于张孝祥老师的Java高新技术

内省IntroSpector→JavaBean

• 内省（Introspector）是java语言对Bean类属性、事件的一种缺省处理方法。
• JavaBean主要用于传递数据信息，其方法用于访问私有变量，且方法名符合某种规则。

       例如 : 类A中有属性name,那我们可以通过getName,setName来得到其值或者设置新的值。通过getName/setName来访问name 属性，这就是JavaBean默认的规则。

• 内省主要是对JavaBean进行操作。JavaBean内部的方法要按照某种规则命名，JavaBean可以作为普通类进行操作；普通类如果内部有set()、get()方法，也可以当做JavaBean使用。

       JavaBean的属性是通过get()和set()方法推断出来的，即去掉get、set后的字母，例如，一个类有方法getAge( )和setAge( ) , 那么bean的属性为age，而不是成员变量，因为成员变量是private看不见的。

       获得属性名的规则：如果属性名的第二个字母是小写，则把第一个字母小写。例如，gettime—>time，setTime—>time，getCPU—>CPU。

PropertyDescriptor类
PropertyDescriptor类表示JavaBean类通过存储器导出一个属性。主要方法：
1、getPropertyType( )，获得属性的Class对象。
2、getReadMethod( )，获得用于读取属性值的方法；getWriteMethod( )，获得用于写入属性值的方法。
3、hashCode( )，获取对象的哈希值。
4、setReadMethod( )，设置用于读取属性值的方法；setWriteMethod( )，设置用于写入属性值的方法；

通过属性名获取对应的值，利用反射方法 ;

ElementBean e = new ElementBean(3,7);

String pn = "x";

PropertyDescriptor pd = new PropertyDescriptor(pn, e.getClass());

Method methodGet = pd.getReadMethod();//getReadMethod()对应get方法

Object retValX = methodGet.invoke(e);

System.out.println(retVal)

给某个属性设置值 :

ElementBean e = new ElementBean(3,7);

String propertyName = "x";

PropertyDescriptor pd = new PropertyDescriptor(pn,e.getClass());

Method methodSetX = pd.getWriteMethod();//getWriteMethod()对应set方法

Object value = 7;

methodSetX.invoke(e, value);

eclipse快速创建get()和set()方法:

右键→Source→Generate Geters and Setters，创建get()和set()方法。

eclipse把一些代码生成方法,提高复用性

选择一些代码，右键→Refactor→Extract Method

Introspector类
将JavaBean中的属性封装起来进行操作。在程序把一个类当做JavaBean来看，就是调用Introspector.getBeanInfo() 方法，得到的BeanInfo对象封装了把这个类当做JavaBean看的结果信息，即属性的信息。需要导包java.beans.*。
getPropertyDescriptors()，获得属性的描述，可以采用遍历BeanInfo的方法，来查找、设置类的属性。

代码

[java]  view plain copy

1. private static Object getProperties_2(ElementBean e, String propertyName)throws IntrospectionException, IllegalAccessException,  
2.                   InvocationTargetException {  
3.       BeanInfo beanInfo = Introspector. getBeanInfo(e.getClass());  
4.       PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();  
5.       Object retVal =  null;  
6.       for(PropertyDescriptor p : pds){  
7.             if(p.getName().equals(propertyName)){  
8.                   Method methodGet = p.getReadMethod();  
9.                   retVal = methodGet.invoke(e);                     
10.             }                   
11.       }  
12.       return retVal;  
13. }  

通过这PropertyDescriptor类和Introspector类的比较可以看出，都是需要获得PropertyDescriptor，只是方式不一样：前者通过创建对象直接获得，后者需要遍历，所以使用PropertyDescriptor类更加方便。

BeanUtils工具包 , 为JavaBean提供更多、放方便的功能 . 

使用时需要配合acpche提供的日志包logging一起使用 .

可以通过BuildPath，添加额外的jar包，或者工程下建立lib目录，将jar包复制进来，再加载这个jar包：右键→add to BuildPath。使用时需要导包：org.apache.commons.beanutils.BeanUtils。

下载的BeanUtils

beanutils.jar = beanutils-core.jar + beanutils-bean-collections.jar

获得属性的值，例如，BeanUtils.getProperty(pt1,"x")，返回字符串
设置属性的值，例如，BeanUtils.setProperty(pt1,"y",22)

将一个对象的属性值复制到另一个对象的属性 , copyProperties(Object dest, Object orig)，需要保证属性一致。

 BeanUtils的特点：
1、对基本数据类型的属性的操作：在WEB开发、使用中，录入和显示时，值会被转换成字符串，但底层运算用的是基本类型，这些类型转到动作由BeanUtils自动完成。
2、对引用数据类型的属性的操作：

首先在类中必须有对象，不能是null，

     例如 : private Date birthday=new Date();。

操作的是对象的属性而不是整个对象

     例如 : BeanUtils.setProperty(pt1,"birthday.time",121);

Java7的新特性：

1、Map和JavaBean之间可以进行相互转换，key是属性，value是属性的值。
     方法describe( bean )：把JavaBean转换成Map；

     方法populate( bean , map )：把Map封装成JavaBean ;

2、Map的简化书写形式 , 如下
Map map = (name:Kim,age:18);

BeanUtilssetProperty( )方法可以把Map看作成Bean , 

     例如 : BeanUtils.setProperty(map,"name","Kim");
 
PropertyUtils类
和BeanUtils不同在于，运行getProperty、setProperty操作时，没有类型转换，使用属性的原有类型或者包装类。

全篇代码 :

[java]  view plain copy

1. package com.itheima;  
2. import java.beans.*;  
3. import java.lang.reflect.*;  
4. import java.util.Map;  
5.   
6. import org.apache.commons.beanutils.*;  
7.   
8. public class IntroSpectorTest {  
9.   
10.       @SuppressWarnings({ "unused", "rawtypes" })  
11.       public static void main(String[] args) throws Exception{  
12.             ElementBean e = new ElementBean(3,7);  
13.             String propertyName = "x";            
14.             Object value = 7;   
15.               
16.              //使用自己写的方法获取"x"的值  
17.             System. out.println( getProperties(e, propertyName));     
18.             System. out.println( getProperties_2(e, propertyName));  
19.               
20.              //使用BeanUtils设置"x"并获取其值  
21.             BeanUtils. setProperty(e, "x", "9");  
22.             System. out.println(BeanUtils. getProperty(e, propertyName));  
23.               
24.              //使用BeanUtils设置并获取属性birthday的值  
25.             BeanUtils. setProperty(e, "birthday.time", 1111);  
26.             System. out.println(BeanUtils. getProperty(e, "birthday.time"));  
27.               
28.             Map map = BeanUtils. describe(e);  
29.             System. out.println(map);  
30.       }  
31.         
32.       public static void setProperties(ElementBean e, String propertyName,  
33.                   Object value) throws IntrospectionException,  
34.                   IllegalAccessException, InvocationTargetException {  
35.             PropertyDescriptor pd = new PropertyDescriptor(propertyName,e.getClass());  
36.             Method methodSetX = pd.getWriteMethod();  
37.             methodSetX.invoke(e, value);  
38.       }  
39.       public static Object getProperties(ElementBean e, String propertyName)  
40.                    throws IntrospectionException, IllegalAccessException,  
41.                   InvocationTargetException {  
42.             PropertyDescriptor pd = new PropertyDescriptor(propertyName, e.getClass());  
43.             Method methodGet = pd.getReadMethod();  
44.             Object retValX = methodGet.invoke(e);  
45.              return retValX;  
46.       }  
47.       public static Object getProperties_2(ElementBean e, String propertyName)  
48.                    throws IntrospectionException, IllegalAccessException,  
49.                   InvocationTargetException {  
50.             BeanInfo beanInfo = Introspector. getBeanInfo(e.getClass());  
51.             PropertyDescriptor[] pds = beanInfo.getPropertyDescriptors();  
52.             Object retVal =  null;  
53.              for(PropertyDescriptor p : pds){  
54.                    if(p.getName().equals(propertyName)){  
55.                         Method methodGet = p.getReadMethod();  
56.                         retVal = methodGet.invoke(e);                     
57.                   }                   
58.             }  
59.              return retVal;  
60.       }  
61. }  

注解Annotation

JDK1.5出现的新特性。在java.lang.annotation包中。

• 对于过时的语句，java会提示过时了，通过@SuppressWarnings("Deprecation")在DOS中取消提示，但Eclipse无 法取消。这就是注解 .

一个注解就是一个类。

@SuppressWarnings，取消警告。

@Deprecated， 这个方法或类不再建议使用 , 在新版本中有其他方法或类可以代替这个使用，以后的版本也不会再更新这个方法或类 .

HashSet集合中，对象必须覆盖Object类的equals()方法，否则会继续使用Object类的equals()方法进行比较，错误的比较方 法。覆盖equals()方法，参数必须一致，为了防止错误写入本类的对象，加入-------->

@Override，必须正确覆盖父类方法，不是创建新方法。
 

总结 : 注解相当于一种标记。编译器、开发工具、javac通过反射获得注解里的内容，进而明确应该做什么、不应该做什么。注解可以加在包、类、属 性、方法、参数及局部变量之上。

注解的应用
       在源程序中，调用一个类，如果这个类会用到注解，就需要先准备好注解类，然后类再调用注解类的对象 . 注意 : 类上的注解都是调用的注解的对象 , 而非注解类 . 可以加多个注解 . 

       注解类的写法类似接口，@interface。先写好注解类A， 将注解放在类B中，类C在调用类B时通过反射获得注解类A，进而明确需要做什么。

       main()方法必须放在一个类下，但与这个类不一定有所属关系。

       在注解类A上加注解B，这个注解B只为这个注解类A服务，B称为“元注解”。类似的还有元信息、元数据。

       元注解有2个：Rentention和Target。对注解类的注解，可以理解为注解类的属性。

Rentention元注解
注解的生命周期：Java源文件—》class文件—》内存中的字节码。编译或者运行时，都有可能会取消注解。Rentention的3种取值意味让注解 保留到哪个阶段，RententionPolicy.SOURCE、RententionPolicy.CLASS(默认值)、 RententionPolicy.RUNTIME。
@Override、@SuppressWarnings是默认保留到SOURCE阶段；@Deprecated是保留到RUNTIME阶段。
Rentention相当于注解类的一个属性，因为Rentention的值不同，注解类保留到的阶段不同。注解类内部Rentention的值使用value表示，例如，@Deprecated中，value=Runtime。
Rentention的值是枚举RententionPolicy的值，只有3个：SOURCE、CLASS、RUNTIME。

Target元注解
性质和Rentention一样，都是注解类的属性，表示注解类应该在什么位置，对那一块的数据有效。例如，@Target(ElementType.METHOD)//表示在方法上有效
Target内部的值使用枚举ElementType表示，表示的主要位置有：注解、构造方法、属性、局部变量、函数、包、参数和类(默认值)。表示多个位置有效可以使用数组，例如，@Target({ElementType.METHOD,ElementType.TYPE})。
类、接口、枚举、注解这一类事物用TYPE表示，Class的父类，JDK1.5的新特性。

注解Annotation的属性

注解的基本属性
属性可以给注解提供更加详细的信息。

• 注解相当于接口，属性相当于接口的方法。例如，@ItcastAnnotation(color="black")，注解ItcastAnnotation中必须有String color();语句 , 给属性赋值，取值时类似调用方法例如，System.out.println(annotation.color()) ; 

• 如果只有value属性，没有其他属性，可以不写=，只针对value，例如，@SuppressWarnings("Deprecation")。或者 有其他属性而且有缺省值，例如，String color() default "blue";，此时value单独出现，不用value=。

注意 :　引用注解时，所有的属性必须全部出现，除非属性有缺省值。

获得注解的属性的值，例如
if(AnnotationDemo.class.isAnnotationPresent(ItcastAnnotation.class)){
ItcastAnnotation annotation =(ItcastAnnotation)AnnotationDemo.class.getAnnotation(ItcastAnnotation.class);
System.out.println(annotation.color());
}
} 
利用反射获得注解的对象，在让该对象调用属性对应的方法。注意类型转换。
Rentention和Target也是属性，都是value对应的值，值的类型分别是RententionPolicy和ElementType，例如，@Retention(value=RetentionPolicy.RUNTIME)。

注解的高级属性
给注解增加高级属性，数组、枚举、注解。
数组类型的属性
例如，int[] arr() default {3,7,5};，MyAnnotation(arr={3,7,6})。如果数组只有1个元素，可以不加{}。 @Target({ElementType.METHOD,ElementType.TYPE})也是数组类型的属性。
枚举类型的属性
//注解类内部的内容
EnumerationTest2.TrafficLamp lamp() default EnumerationDemo.TrafficLamp.RED;
//调用注解的类上
@ItcastAnnotation(lamp=EnumerationDemo.TrafficLamp.YELLOW)
//对注解进行操作
System.out.println(annotation.lamp().nextLamp());
注解类型的属性
将一个注解类作为属性加入到另一个注解类中。
MetaAnnotation annotationAtt() default @MetaAnnotation("Jobs")
@ItcastAnnotation(annotationAtt=@MetaAnnotation("lmn"))
annotation.annotationAtt().value()
注解的返回值可以是8个基本类型、String、Class、枚举以及前面类型的数组，内部还有属性。
需要详细学习注解，可以通过java语言规范，即languagespecification。

注解类的代码：

[java]  view plain copy

1. import java.lang.annotation.ElementType;  
2. import java.lang.annotation.Retention;  
3. import java.lang.annotation.RetentionPolicy;  
4. import java.lang.annotation.Target;  
5. //注解的注解又叫元注解  
6. @Retention(RetentionPolicy.RUNTIME )//决定注解的生命周期  
7. @Target({ElementType. TYPE,ElementType. METHOD}) //决定注解能放在什么位置  
8. public @interface ItcastAnnotation {  
9.       String color() default "blue";  
10.       String value();  
11.       int[] arrayAttr() default {1,2,3};  
12.       EnumTest2.Trafficlamp lamp() default EnumTest2.Trafficlamp. RED;  
13.       MetaAnnotation annotationAttr() default @MetaAnnotation( "xyz");  
14.       Class classAttr();  
15. }  
16. 调用注解类的代码：  
17. package com.itheima;  
18. @ItcastAnnotation(value="abc" ,annotationAttr=@MetaAnnotation ("lmn" ),classAttr=String.class)  
19. public class AnnotationTest {  
20.       @ItcastAnnotation(value= "abc",classAttr=String. class)  
21.       public static void main(String[] args) {  
22.             System. runFinalizersOnExit( true);  
23.              Class classAT = AnnotationTest.class;  
24.              Class classIA = ItcastAnnotation.class;  
25.              if( classAT.isAnnotationPresent(classIA)){  
26.                    ItcastAnnotation ia = (ItcastAnnotation)classAT.getAnnotation(classIA);  
27.                   System. out.println(ia.color());  
28.                   System. out.println(ia.value());  
29.                   System. out.println(ia.arrayAttr(). length);  
30.                   System. out.println(ia.lamp().nextTra());  
31.                   System. out.println(ia.annotationAttr().value());  
32.                   System. out.println(ia.classAttr());  
33.             }  
34.       }  
35.       @Deprecated//已过时,这个方法或类不再建议使用  
36.       public void sayHello(){  
37.             System. out.println( "hi,传智播客");  
38.       }  
39. }  

泛型 Generic
一.问题的引入：为什么要用泛型？
     引入泛型的原因之一：在使用集合时，可以向定义好的某一集合中存入任意类型的数据，而我们希望整个集合中的类型都是一样的，当加入的不期望的类型后，只有到运行期才能发现。  而且取出的类型需要强制转换。

[java]  view plain copy

1. //没有使用泛型：    
2. ArrayList collection = new ArrayList();      
3.         collection.add(1);      
4.         collection.add(1L);      
5.         collection.add("abc");      
6. //      int i = （Integer）collection.get(1);//这句会报错</span>      
7. //使用泛型的代码：    
8.     
9. //      在集合中的应用      
10.         ArrayList<String> collection1 = new ArrayList<String>();      
11. //      collection1.add(1);      
12. //      collection1.add(1L);      
13.         collection1.add("String");      
14.         String i = collection1.get(0);//        在反射中的应用      
15.         //用反射实现操作：String str = new String(new StringBuffer("abc"));           
16.         Constructor<String> constructor1 = String.class.getConstructor(StringBuffer.class);             
17.         String str1 = constructor1.newInstance(new StringBuffer("abc"));      
18.         System.out.println(str1.charAt(2));      

从上面两段代码的对比中，很容易看出使用泛型的好处：1.限定了集合元素的类型；2.省去了强制转换的过程。    
JDK升级一般可分为三个大的方面：1.简化书写；2.提高效率；3.提高安全性。而泛型就属于其中的第三方面安全，它是一种安全机制。

二.利用反射穿透泛型限制     

泛型能绝对保证集合中存入数据都是它限定的类型吗？

[java]  view plain copy

1. ArrayList<Integer> collection2 = new ArrayList<Integer>();      
2. System.out.println(collection1.getClass()==collection2.getClass());      
3. collection2.add（“123”）；//这句会报错      
4. collection2.getClass().getMethod("add", Object.class).invoke(collection2, "hello");      
5. System.out.println(collection2.get(0)); //结果却为hello    

三.ArrayList<E>类定义和ArrayList<Integer>类引用中涉及的术语：
1.ArrayList<E>：这个整体称为“泛型类型”，其中的“E”称为 类型变量 或 类型参数 。
2.ArrayList<Integer>：整体称为“参数化的类型”，“Integer”称为“类型参数的实例”或“实际类型参数”，"<>"读为typeof，ArrayList称为“原始类型”。
3.参数化类型与原始类型的兼容性：可以互相引用，但编译器会报告警告。 
4.参数化类型不考虑类型参数的继承关系  
5.编译器不允许创建类型变量的数组。在创建数组实例时，数组的元素不能使用参数化的类型。

[java]  view plain copy

1. Collection<String> c = new Vector();      
2.         Collection c1 =  new Vector<String>();      
3. //      见第4条      
4. //错误语句  Vector<String> v=new Vector<Object>();      
5. //错误语句  Vector<Object> v1=new Vector<String>();           
6.         Vector  v2=new Vector<String>();      
7.         Vector<Object> v3 = v2;      
8.               
9. //错误语句  Vector <Integer>  [] vectorList = new Vector <Integer>[10];//见第5条。      
10.         Vector <Integer[]>   vectorList = new Vector <Integer[]>();     

四.扩展应用：泛型中的通配符“？”
1.限定通配符的上边界
     Vector<? extends Number>  x = new Vector<Integer>();正确的
     Vector<? extends Number>  x = new Vector<String>()：错误的。
2.限定通配符的下边界
     Vector<? super Integer>  x = new Vector<Number>();正确的。
     Vector<? super Integer>  x = new Vector<Byte>();错误的。    
注意：限定通配符总是包括它自己。

[java]  view plain copy

1.         printCollection_2(collection2);      
2. //      Class<Number> x = String.class.asSubclass(Number.class);//错误。      
3. //      Class x1 = String.class.asSubclass(Number.class);      
4. //      Class<String> y = Class.forName("java.lang.String");//错误      
5.         Class y = Class.forName("java.lang.String");//要抛出异常。      
6.         Class<?> y1;      
7.         Class<String> y2 = null;      
8.         y1=y2;      
9. //      y2=y1;    

五.泛型集合类的综合应用案例

[java]  view plain copy

1. HashMap<String,Integer> hm = new HashMap<String,Integer>();      
2.         hm.put("zyq", 18);      
3.         hm.put("zsy", 49);      
4.         hm.put("zyx", 25);      
5.               
6.         Set<Map.Entry<String,Integer>> entrySet = hm.entrySet();      
7.         for(Map.Entry<String, Integer> entry:entrySet){      
8.             System.out.println(entry.getKey() + ":" + entry.getValue());      
9.         }      

六.定义泛型方法
1.泛型类似C++中的模板，但没有C++中的功能强大。
2.泛型的实际类型参数只能是引用数据类型，例如：对于HashMap<K,V>，K和V不能是八种基本数据类型。
3.异常也可以用泛型
4.类型参数的类型推断

例一：模拟C++中的模板实现求和功能（但没有C++中好用）

[java]  view plain copy

1. add(1,2);      
2.       Number x1 = add(1,1.4);//int 和float的最大公共集是Number      
3.       Object x2 = add(1,"abc");//String 和int的最大公共集是Object      
4.     
5. ivate static<T> T add(T x,T y){//取得的T是 x 和  y的最大公共集，其实也是java中多态的体现。      
6.       return null;      
7.   }    

例二：实现数组中的元素位置交换

[java]  view plain copy

1. swap(new String[]{"abc","123","hello"},0,1);      
2. //      swap(int[]{1,2,3,4},2,3);//int是基本数据类型，所以不能实现。      
3. [java] view plaincopy    
4. private static<T> void swap(T[] t ,int x,int y){      
5.         T temp = t[x];      
6.         t[x] = t[y];      
7.         t[y] = temp;      
8.     }      

例三：

[java]  view plain copy

1. ArrayList<Integer> al = new ArrayList<Integer>();      
2.         al.add((Integer)autoConvert(345));      
3.         System.out.println(al.get(0));      
4.               
5.         String s = autoConvert("123");      
6.         System.out.println(s);      
7.         fillArray(new Integer[]{1,3,4},1);      
8.               
9.         copy1(new Vector<String>(), new String[]{"123","5674"});      
10.         copy2(new Date[20], new String[10]);//这个是两个取交集。      
11. //      copy1(new Vector<Date>(), new String[]{"123","5674"});    
12. //类型推断的传播性，Vector中T已经指定为Date，后边的T也应该是Date，否则报错。      
13.     
14. public static<T> void fillArray(T[] t,T obj){      
15.         for(int x= 0;x<t.length;x++){      
16.             t[x]= obj;      
17.         }      
18.     }      
19.     public static <T> T autoConvert(Object obj){      
20.         return (T)obj;      
21.     }      
22.     
23. public static <T>void copy1(Collection<T> des ,T[] src){      
24.         
25.  }      
26.  public static <T>void copy2(T[] des ,T[] src){      
27.          
28.  }    

七、泛型类

[java]  view plain copy

1. import java.util.Set;        
2. //dao data access object:CRUD      
3. public class GenericDao<E> {      
4.     //增      
5.     public void add(E x){      
6.               
7.     }      
8.     //删      
9.     public void delete(int id){      
10.                
11.     }      
12.     public void delete(E obj){      
13.                
14.     }      
15.     //查      
16.     public E findByID(int id){      
17.         return null;      
18.     }      
19.     public E findByName(String name){      
20.         return null;      
21.     }      
22.           
23.     public Set<E> findByConditions(String where){      
24.         return null;      
25.     }      
26.           
27.     //改      
28.     public void update(E obj){      
29.               
30.     }      
31.     public static<E> void update1(E obj){//静态方法不能用类上定义的泛型参数，但可以自己定义泛型,这里的E和类上的E是两码事。      
32.               
33.     }       
34. }      
35. GenericDao<ReflectPoint> dao = new GenericDao<ReflectPoint>();      
36.         dao.add(new ReflectPoint(5, 7));      
37. //      String s = dao.findByID(1);//返回的也必须是ReflectPoint      

八、通过反射获得泛型的参数化类型
没办法通过泛型的引用，用反射 获取参数化类型的类型参数。 
但可以通过反射获得方法的参数列表，从参数列表中获取参数化类型的原始类型和实际类型参数

[java]  view plain copy

1. import java.lang.reflect.Method;      
2. import java.lang.reflect.ParameterizedType;      
3. import java.lang.reflect.Type;      
4. import java.util.Date;      
5. import java.util.Vector;      
6.  class GenericTest {          
7.     public static void main(String[] args) throws Exception{      
8.         Method applyMethod =  GenericTest.class.getMethod("applyVector", Vector.class);      
9.         Type[] types =applyMethod.getGenericParameterTypes();      
10.         ParameterizedType pType =(ParameterizedType) types[0];      
11.               
12.         System.out.println(pType.getClass());      
13.         System.out.println(pType.getOwnerType());      
14.         System.out.println(pType.getRawType());      
15.         System.out.println(pType.getActualTypeArguments()[0]);      
16.     }      
17.           
18.     public static void applyVector(Vector<Date> v){      
19.               
20.     }      
21.     /*   
22.     public static void applyVector(Vector<Integer> v){ //这个方法和上边的方法是同一个方法。   
23.            
24.     }*/      
25. }      

类加载器
什么叫类加载器? 加载类的工具.
java虚拟机中可以安装多个类加载器,系统默认三个主要类加载器,每个负责特定位置的类.
BootStrap xitClassLoader AppClassLoader
类加载器也是java类,因为其他是java类的类加载器也要被类加载器加载，显然必须有第一个类加载器不是java类, 这正是：BootStrap，它是由C++编写的.

java虚拟机中类加载器之间的父子关系和管辖范围：

Bootstrap ClassLoader  ---->JRE/lib/rt.jar

                                ↑
Extension ClassLoader ---->JRE/lib/ext/.jar

                                ↑
ApplicationClassLoader ---->ClassPath指定的所有jar或目录。

                                ↑ 
MyClassLoader ---->指定的特殊目录

                                ↑
itcastClassLoader---->指定的特殊目录

[java]  view plain copy

1. package study.day2;  
2. import java.util.Date;  
3. public class ClassLoderTest {  
4.   
5.     public static void main(String[] args) throws Exception {  
6.         System.out.println(ClassLoderTest.class.getClassLoader().getClass().getName());  
7.         System.out.println(System.class.getClassLoader());  
8.           
9.         ClassLoader loader = ClassLoader.class.getClassLoader();  
10.         while(loader!=null){  
11.             System.out.println(loader.getClass().getName());  
12.             loader = loader.getParent();  
13.         }  
14.         System.out.println(loader);      
15.         System.out.println(new ClassLoaderAttachment().toString());  
16.     }  
17. }  

类加载器的委托机制 ---分为两个过程
①类加载器的选择：当java虚拟机要加载一个类时，到底派出那个类加载器去加载？
       (1).首先当前线程的类加载器去加载线程中的第一个类。
       (2).如果类A中引用了B类，java虚拟机将使用类A的加载器来加载类B
       (3).还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。
②类加载器怎样加载：每个类加载器加载类时，又先委托给器上级类加载器。当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛出ClassNotFoundException，不再去找发起者类加载器的儿子，因为没有getChild方法；即使有，那么有多个儿子，到底要找那个一个呢？
    

思考：能否自己写一个JDK中已经存在的类呢？

通常不可以，因为根据类加载器的委托机制，每次都会先委托给上级寻找，先找到的是Jdk中的java.lang.System,而不是自己写的 java.lang.System类；但可以自己写一个类加载器，撇开器委托机制，不给它指定上级，来加载自己的类。
注意：需要说明一下 Java 虚拟机是如何判定两个Java类是相同的。Java虚拟机不仅要看类的全名是否相同，还要看加载此类的类加载器是否一样。只有两者都相同的情况，才认为两个类是相同的。即便是同样的字节代码，被不同的类加载器加载之后所得到的类，也是不同的。

编写自己的类加载器,模板方法设计模式：
父类->loadClass/findClass/得到class文件的转换成字节码用父类的defineClass方法。
子类：（自己干）
子类2：（自己干）
总体的流程已经在父类定义好，实现的具体细节有一部分父类不清楚，留给子类完成。

知识讲解：
1.自定义的类加载器必须继承ClassLoader
2.loadClass方法与findClass方法：只需重新findClass方法，就会跳出委托机制。
3.defineClass方法。
 编程步骤：
1.编写一个队文件内容进行监督加密的程序
2.编写了一个自己的类加载器，可实现对加密的类进行撞在和解码。
3.编写一个程序调用类加载器加载类，在源程序中不能用该类定义引用变量，因为编程器无法识别这个类。程序中可以除了使用ClassLoader.load方法外，还可以使用使用设置线程的上下文加载器或者系统加载器，然后再使用Class.forName.

[java]  view plain copy

1. package study.day2;  
2. //需要加载的类  
3. import java.util.Date;  
4. public class ClassLoaderAttachment extends Date {     
5.     @Override  
6.     public String toString() {  
7.         return "hello,itcast";  
8.     }     
9. }  
10. //包含加密解密方法和覆盖ClassLoader的findClass方法  
11. package study.day2;  
12. import java.io.*;  
13. import com.sun.beans.finder.ClassFinder;  
14. public class MyClassLoader extends ClassLoader{  
15.     public static void main(String[] args) throws Exception {  
16.         String srcPath = args[0];  
17.         String destDir = args[1];  
18.         FileInputStream fis = new FileInputStream(srcPath);  
19.         String destFileName = srcPath.substring(srcPath.lastIndexOf('\\'));  
20.         String destPath = destDir+destFileName;  
21.         FileOutputStream fos = new FileOutputStream(destPath);  
22.         cypher(fis,fos);  
23.         fis.close();  
24.         fos.close();  
25.     }  
26.     //加密方法  
27.     public static void cypher(InputStream fis, OutputStream fos) throws Exception {  
28.         int b = -1;  
29.         while((b=fis.read())!=-1){  
30.             fos.write(b ^ 0xff);  
31.         }  
32.     }  
33.     private String classDir;  
34.     @Override  
35.     protected Class<?> findClass(String name) throws ClassNotFoundException {  
36.         String classFileName = classDir+"\\"+name.substring(name.lastIndexOf('.')+1)+".class";  
37.         try {  
38.             System.out.println("It's MyClassLoader.");  
39.             FileInputStream fis = new FileInputStream(classFileName);  
40.             ByteArrayOutputStream bos = new ByteArrayOutputStream();  
41.             cypher(fis,bos);  
42.             byte[] bys = bos.toByteArray();  
43.             return defineClass(null, bys, 0,bys.length);              
44.         }   
45.         catch (Exception e) {  
46.             e.printStackTrace();  
47.         }  
48.         return super.findClass(name);  
49.     }  
50.     public MyClassLoader(String classDir){  
51.         this.classDir = classDir;  
52.     }  
53. }  
54. //调用写好的类加载器  
55. package study.day2;  
56. import java.util.Date;  
57. public class ClassLoderTest {  
58.     public static void main(String[] args) throws Exception {  
59.         Class clazz = new MyClassLoader("itcastlib").loadClass("study.day2.ClassLoaderAttachment");  
60.         Date dd = (Date) clazz.newInstance();  
61.         System.out.println(dd);  
62.     }  
63. }  

关于类加载器的一个高级问题

当把我们写好的MyServlet作为jar包导入的Tomcat使用的JDK的jre/lib/ext中时，这时的MyServlet的类加载器由原来tomcat的WebAppClassLoader变成了ExtClassLoader，在加载TMyServlet时，又用到了HttpServlet，ExtClassLoader找不到就不会报错此时，只需将tomcat中包含HttpServlet的servlet-api.jar也导入ext文件夹下即可。

------ ASP.Net+Android+IO开发.Net培训期待与您交流！ ------