张孝祥J2SE加强自学笔记(41-47)

张孝祥J2SE加强自学笔记(41-47)

• 博客分类：
• J2SE

J2SE EXT 面试 JVM 网络应用

41、自定义泛型方法的练习与类型推断总结：

Java代码  

1. (1)编写一个方法自动将Object类型转化为其他的类型  
2.         代码示例：  
3.         public static <T>T autoConvert(Object obj) {  
4.             return (T)obj;  
5.         }  
6.     (2)将任意类型数组中的每一个元素填充为任意类型的对象。  
7.         代码示例：  
8.         public static <T>void fillArray(T[] a, T obj) {  
9.             for(int i=0; i<a.length; i++) {  
10.                 a[i] = obj;  
11.             }  
12.         }  
13.     (3)采用自定义泛型的方法打印出任意参数化集合类型中的内容：  
14.         代码示例：  
15.         //采用通配符  
16.         public static void printCollection(Collection<?> coll) {  
17.             for(Object obj : coll) {  
18.                 System.out.println(obj);  
19.             }  
20.             //错误：因为无法知道？到底是什么类型，你add一个String类型，万一?是Integer呢?  
21.             //coll.add("abc");  
22.         }  
23.           
24.         //采用泛型  
25.         public static <T>void printCollection2(Collection<T> coll, T obj2) {  
26.             for(Object obj : coll) {  
27.                 System.out.println(obj);  
28.             }  
29.             coll.add(obj2);  
30.         }  
31.     (4)把任意参数化类型的数组中的数据安全的复制到相应类型的集合中  
32.         代码示例：  
33.         public static <T>void copyCollection1(Collection<T> dist, T[] src) {  
34.             for(int i=0; i<src.length; i++) {  
35.                 dist.add(src[i]);  
36.             }  
37.         }  
38.           
39.     (5)把任意参数类型的数组中的数据安全的复制到另外一个数组中：  
40.         代码示例：  
41.         public static <T>void copyCollection2(T[] dist, T[] src) {  
42.           
43.         }  
44.     调用：  
45.     public static void main(String[] args) {  
46.         //T表示的都是String  
47.         copyCollection1(new Vector<String>(), new String[20]);  
48.         //取交集:Object  
49.         copyCollection2(new Date[10], new String[10]);  
50.         //错误：new Vector<Date>已经指定了T:Date 而后面又new String:这是不可以的  
51.         //这叫做泛型的传播性  
52.         //copyCollection1(new Vector<Date>(), new String[20]);  
53.     }  

(6)类型参数的类型推断：太复杂不常用-->省略

42、自定义泛型类的应用：

Java代码  

1. 代码示例：  
2.     /** 
3.      * 自定义泛型模仿Dao层的crud 
4.      * @author Administrator 
5.      * 
6.      */  
7.     public class GenericDao {  
8.           
9.         public <T>void add(T obj) {  
10.               
11.         }  
12.           
13.         public <T>T find(int id) {  
14.             return null;  
15.         }  
16.     }  

//定义测试用类:
public class Person {}
如果我们采用如上的方式定义方法，那么我们在调用的时候会出现如下情况：
public static void main(String[] args) {
GenericDao ge = new GenericDao();
ge.add(new Person());//我们添加的是Person类型
String s = ge.find(1);//而我们却可以以String类型的方式返回，编译器并不报错
}
但是我们在add的时候以T的类型传递过去的，返回的时候也是以T的类型返回的，那么为什么不行呢，因为这是两个方法，
你可以认为两个方法定义的T毫无关系。那么如何把T应用到这个类中的整个方法呢。我们应该把T定义到类名上就可以了
代码示例：

Java代码  

1. public class GenericDao<T> {  
2.         public void add(T obj) {  
3.               
4.         }  
5.         public T find(int id) {  
6.             return null;  
7.         }  
8.     }  

如果这样定义，我们就能保证添加进去的和拿出来的是同一类的对象。
注意：当一个变量或方法被声明为泛型的时候，只能被实例变量和方法调用，而不能被静态变量
和静态方法调用。因为静态成员变量是被所有参数化的类的对象所共享的。如下：

Java代码  

1. public class GenericDao<T> {  
2.         //报错：  
3.         public static void update(T obj) { }  
4.         应改为：  
5.         public static void update(T obj) { }  
6.     }  
7.       

43、通过反射获得泛型实际类型参数：
示例代码：

Java代码  

1. public static void main(String[] args) {  
2.         //得到方法applyVector的反射对象  
3.         Method applyMethod = GenericTest.class.getMethod("applyVector", Vector.class);  
4.         //得到这个方法的"泛型的参数化类型"返回一个数组，因为这个方法可能有多个参数   
5.         Type[] types = applyMethod.getGenericParameterTypes();  
6.         //因为我们知道我们的方法中只有一个参数所以：types[0]  
7.         ParameterizedType pType =(ParameterizedType) types[0];  
8.         //得到第一参数的真实类型：Vector  
9.         System.out.println(pType.getRawType());  
10.         //.getActualTypeArguments()：得到第一个参数的参数化类型(可以简单理解为：就是泛型)，是一个数组，因为可能有多个例如：Map<K,V>  
11.         System.out.println(pType.getActualTypeArguments()[0]);  
12.     }  
13.       
14.     public static void applyVector(Vector<Date> v1) {  
15.           
16.     }  

对于Vector<Date> v1 如果只是根据v1这个对象，你是无法拿到Vector的参数化类型Date的，但是当这个类型的对象作为一个方法的参数的
时候，我们就可以利用反射的方式得到他了。

44、类加载器及其委托机制的深入分析
类加载器负责将 .class 文件(可能在磁盘上, 也可能在网络上) 加载到内存中, 并为之生成对应的 java.lang.Class 对象
当 JVM 启动时，会形成由三个类加载器组成的初始类加载器层次结构：
类加载器的树形结构



BootStrap  加载：JRE/lib/rt.jar
| |
| |
ExtClassLoader 加载：JRE/lib/ext/*.jar
| |
| |
AppClassLoader   加载：classpath指定的所有jar或目录

在AppClassLoader下面我们可以把我们自己写的ClassLoader挂载到下面用来装载我们的放在
特定目录的类。
(一、)当Java虚拟机要加载一个类时，到底派出哪个类加载器去加载呢？
(1)首先当前线程的类加载器去加载线程中的第一个类。
(2)如果类A中引用了类B，Java虚拟机降使用加载类A的加载器来加载类B
(3)还可以直接调用ClassLoadedr.loadClass()方法来指定某个类加载器去加载某个类
(二、)每个类加载器加载文件的时候，都是先委托给其上级类加载器
(1)当所有的祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了
则抛出ClassNotFoundException,不是在去找发起者类加载器的儿子，因为没有
getChild方法，即使有，那有多个儿子找那一个呢？
(2)对类加载器的层次图和委托架子啊原理，解释先前将ClassLoaderTest输出成jre/lib/ext
目录下面的itcast.jar包后，运行结果为ExtClassLoader的原因？双亲委派机制

面试题：能不能自己写个类叫java.lang.String让泪加载器去加载他？
不能：为了不让我们写String类，类加载器采用委托机制，总是先让他的父类加载器
加载，这样总会加载到rt.jar所以总是使用java系统提供的String

示例代码：

Java代码  

1. public class ClassLoaderTest {  
2.     public static void main(String[] args) {  
3.         //AppClassLoader  
4.         System.out.println(  
5.                 ClassLoaderTest.class.getClassLoader().getClass()  
6.                 .getName()  
7.         );  
8.         //报错：getClassLoader()拿到的是null因为System类由BootStrap类加载器加载，而这个加载器我们是拿不到的  
9.         //是嵌在JVM中的，  
10.         System.out.println(  
11.                 System.class.getClassLoader().getClass()  
12.                 .getName()  
13.         );  
14.           
15.         ClassLoader classLoader = ClassLoaderTest.class.getClassLoader();  
16.         //输出所有的类加载器  
17.         while(classLoader != null) {  
18.             System.out.println(classLoader);  
19.             //拿到它的父类加载器  
20.             classLoader = classLoader.getParent();  
21.         }  
22.         System.out.println(classLoader);  
23.         //输入结果：AppClassLoader、ExtClassLoader、null  null是因为我们拿不到了，实际上是BootStrap  
24.           
25.     }  
26. }  

45、自定义类的加载器的编写原理分析：
ClassLoader是一个抽象类，里面有两个我们要写自己的类加载器将要用到的方法
//通过给他一个类名，来加载一个类返回这个类的字节码，这个方法内部在调用这个方法的时候会先
//找他的父加载器去加载，然会回来在去找findClass(String name)方法，如果你把这个方法覆盖了它加载的
//时候不会去找父类了，我们还要自己去写这段代码，所以我们用覆盖findClass(String name)方法就行了(保存流程)
(1)public Class<?> loadClass(String name):
//把一份字节数组转化为一个Class的一个实例对象
(2)protected final Class<?> defineClass(String name,byte[] b,int off, int len);

概念：模板方法的设计模式：
父类
子类1 子类2

许多相同的部分都放到父类中，而具体的细节由我们的子类自己完成自己的那部分，所以
重写父类的方法加入我们自己实现的细节就可以了。

46、编写对class文件进行加密的工具类
(1)编写加密工具类

Java代码  

1. public class MyClassLoader {  
2.         public static void main(String[] args) throws Exception {  
3.             String srcPath = args[0];   //D:\J2SE\EclipseWorkSpace\javaenhance\bin\cn\itcast\day2\ClassLoaderAttachment.class  
4.             String destDir = args[1];   //itcast  
5.             String destFileName = srcPath.substring(srcPath.lastIndexOf('\\') + 1); //ClassLoaderAttachment.class  
6.             String destPath = destDir + "\\" + destFileName;    //itcast\ClassLoaderAttachment.class  
7.             FileInputStream fis = new FileInputStream(srcPath);  
8.             FileOutputStream fos = new FileOutputStream(destPath);  
9.             cyper(fis, fos );  
10.         }  
11.           
12.         public static void cyper(InputStream ips, OutputStream ops) throws Exception {  
13.             int b = -1;  
14.             while((b =ips.read())!= -1) {  
15.                 ops.write(b ^ 0xff);  
16.             }  
17.         }  
18.     }  
19.       
20.     (2)生成.class文件的测试类  
21.         public class ClassLoaderAttachment extends Date {  
22.             @Override  
23.             public String toString() {  
24.                 return "hello world";  
25.             }  
26.         }  
27.           
28.     (3)运行测试  
29.     //出错：  
30.     System.out.println(new ClassLoaderAttachment().toString());  

Run as --->args参数：D:\J2SE\EclipseWorkSpace\javaenhance\bin\cn\itcast\day2\ClassLoaderAttachment.class    itcast
第一个参数是你写的那个要加密的类生成的.class文件的路径
第二个参数是加密完成之后，生成的文件放到哪个文件夹下面

结果：在我们对ClassLoaderAttachment.toString()进行打印的时候，会输出hello world 因为这个时候他的.class文件没有加密，当我们用家完密
的.class文件覆盖它的.class文件 然后再运行就出错了。

47、编写和测试自己编写的解密类加载器
在上一个示例中，我们对类的.class文件进行了加密，所以无法运行，在这个例子中我们进行解密操作；
在MyClassLoader 继承 ClassLoader并重写他的findClass(String name) 方法：
//添加二个构造方法和一个属性用于传递.class文件名

Java代码  

1. public MyClassLoader() {  
2.           
3.     }  
4.       
5.     private String fileDir;  
6.       
7.     public String getFileDir() {  
8.         return fileDir;  
9.     }  
10.   
11.     public void setFileDir(String fileDir) {  
12.         this.fileDir = fileDir;  
13.     }  
14.   
15.     public MyClassLoader(String fileDir) {  
16.         this.fileDir = fileDir;  
17.     }  
18.       
19.     @Override  
20.     protected Class<?> findClass(String name) throws ClassNotFoundException {  
21.         //找到那个错误的.class文件的位置  
22.         String filePath = fileDir + '\\' + name + ".class";  
23.         FileInputStream fis;  
24.         try {  
25.             fis =new FileInputStream(filePath);  
26.             ByteArrayOutputStream baos = new ByteArrayOutputStream();  
27.             //解密  
28.             cyper(fis, baos);  
29.             fis.close();  
30.             byte[] bytes = baos.toByteArray();  
31.             baos.close();  
32.             //解密完成之后调用defineClass方法返回一个Class对象  
33.             Class clazz = defineClass(bytes, 0, bytes.length);  
34.             return clazz;  
35.         } catch (Exception e) {  
36.             e.printStackTrace();  
37.         }  
38.         return super.findClass(name);  
39.     }  
40.     测试运行：  
41.         Class clazz = new MyClassLoader("itcastlib").findClass("ClassLoaderAttachment");  
42.         //这个地方不呢个直接写: ClassLoaderAttachment d1 = (ClassLoaderAttachment)clazz.newInstance();  
43.         //因为如果这样写，因为用到了ClassLoaderAttachment这个类ClassLoader会又去加载这个类的字节码这个时候还没有解密所以会报错  
44.         //所以先写他的父类  
45.         Date d1 = (Date)clazz.newInstance();  
46.         System.out.println(d1.toString());