(21)基础加强-泛型加强-类加载器加强

最新推荐文章于 2021-03-05 04:24:54 发布

食草动物

最新推荐文章于 2021-03-05 04:24:54 发布

阅读量700

点赞数

分类专栏： Java基础加强

本文链接：https://blog.csdn.net/u011818171/article/details/18007467

版权

Java基础加强专栏收录该内容

7 篇文章 0 订阅

订阅专栏

基础加强之泛型加强-类加载器加强

JDK1.5新特性--泛型

概述：

泛型是jdk1.5所有新特性最后最难深入掌握的部分，不过，我们在实际应用中不用掌握的那么深入，掌握泛型中一些基本的内容就差不多了；没有使用泛型时候，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为某个类型，而该集合只能存储同一个类型的对象，这样更安全，并且当从集合中获取一个对象时，编译器也知道这个对象的类型，所以就不用再进行强制类型转换，更方便。

注意：

在jdk1.5中，我们可以按照原来的方式将各种不同类型的数据装到一个集合中，但编译器会报告unchecked警告。

作用原理及更深应用：

泛型是给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，当编译器编译带类型说明的集合时，会去掉“类型”信息，使程序运行效率不受影响；对于参数化的泛型类型如：getClass()方法返回值类型和原始类型一样，由于编译会去掉泛型的类型信息只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，如：用反射调用集合，再调用其add方法。

示例：

package cn.heima.Day02;
import java.util.ArrayList;
public class GenericTest {
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		ArrayList<String> collection1 = new ArrayList<String>();
		collection1.add("abc");
		ArrayList<Integer> collection2 = new ArrayList<Integer>();
		
		//当编译器编译带类型说明的集合时（即参数化的类型），会去掉“类型”信息,所以两字节码是同一份
		System.out.println(collection1.getClass()==collection2.getClass());//true
		//由于编译会去掉泛型的类型信息只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，
		//如：用反射调用集合，再调用其add方法。
		//collection2.add("abc");错误
		collection2.getClass().getMethod("add", Object.class).invoke(collection2, "abc");
		System.out.println(collection2.get(0));	
	}
}

了解泛型：

ArrayList<E>类定义和ArrayList<Integer>类引用中涉及如下术语：

整个称为ArrayList<E>泛型类型；

ArrayList<E>中的E称为类型变量或类型参数；

整个ArrayList<Integer>称为参数化的类型

ArrayList<Integer>中的Integer称为类型参数的实例或实际类型参数。

ArrayList<Integer>中的<>typeof；

ArrayList称为原始类型；

参数化类型和原始类型的兼容性：

参数化类型可以引用一个原始类型的对象，编译报告警告，例如：

Collection<String> c = new Vector();//

原始类型可以引用一个参数化类型的对象，编译报告警告，例如：

Collection c = new Vector<String>();//原来的方法接受一个集合参数，新的类型也要能接受

参数化类型不考虑类型参数的继承关系：

Vector<String> v = new Vector<Object>();//错误，不写Object没错，写了就是明知故犯；

Vector<Object> v=new Vector<String>();//错误；

在创建数组实例时，数组元素不能使用参数化的类型，例如：

Vector<Integer> vectorList[] = new Vector<Integer>[10];

泛型通配符扩展应用

泛型中的？通配符

定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义？

错误方法：
Public static void printCollection(Collection<Object> cols){
　　For (Object obj: cols){
　　Systenm.out.println(obj);
　　}
　　//cols.add(“string”)没有错;
　　//cols = new HashSet<Date>()会报错误；
}
正确方式：
Public static void printCollection(Collection<？> cols){
　　For (Object obj: cols){
　　Systenm.out.println(obj);
　　}
　　//cols.add(“string”)有错，因为将匹配的类型不确定；
　　Clos.size();//没错，此方法与类型参数没有关系
　　cols = new HashSet<Date>()；
}

总结：

使用？通配符可以引用其他各种参数化的类型，？通配符定义的变量主要用来引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。

泛型中的？通配符的扩展——限定

限定通配符的上边界即上限：

True：Vector<?extends Number>x = new Vector<Integer>();

Error：Vector<?extends Number>x = new Vector<String>();

限定通配符的下边界即下限：

True：Vector<?super Integer>x = new Vector<Number>();

Error：Vector<?super Integer>x = new Vector<String>();

注意：

限定通配符总是包括自己。

泛型集合的综合应用案例：

HashMap<String,Integer> Hm = new HashMap<String,Integer>();
Hm.put(“zhangsan”,19);
Hm.put(“lisi”,22);
Hm.put(“wangwu”,34);

Set<Map.Entry<String,Integer>> entrys = hm.entrySet();
For(Map.Entry<String,Integer> me : entrys){
　　System.out.println(me.getKey()+”:”+me.getValue());
}
对在jsp页面中也要经常对Set或者Map集合进行迭代：
<c:forEach items = “${map}” var = “entry”>
　　${entry.key}:${entry.value}
</c:foeEach>

自定义泛型方法及其应用

由C++的模板函数引入自定义泛型

如下函数的结构很相似，仅类型不同：

int add(int x,int y) {

return x+y;

}

float add(float x,float y) {

return x+y;

}

double add(double x,double y) {

return x+y;

}

C++用模板函数解决，只写一个通用的方法，它可以适应各种类型，示意代码如下：

template<class T>

T add(T x,T y) {

return (T) (x+y);

}

定义泛型方法

Java的泛型方法没有C++模板函数功能强大，java中的如下代码无法通过编译：

<T> T add(T x,T y) {

return (T) (x+y);

//return null;

}

用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前。

按照惯例，类型参数通常用单个大写字母表示。

例如：交换数组中的两个元素的位置的泛型方法语法定义如下：

Static<E> void swap(E[] a, int i,int j){

Et = a[i];

a[i] = a[j];

a[j] = t;

}

只有引用类型才能作为泛型方法的实际参数，swap(new int[3],3.4)；会包编译异常

除了在应用时可以使用extends限定符，在定义泛型时也可以使用，

例如：

Class.getAnnotation()方法的定义。并且可以用%来指定多个边界，如：<V extends Serizable&coloneable> void method(){}

普通方法，构造方法静态方法中都可以使用泛型，编译器不允许创建类型变量的数组。

可以用类型变量表示异常，称为参数化的异常，可以用于方法的throws列表中，但是不能用于catch语句中。

在泛型中可以同时有多个类型参数，在你定义它们的尖括号中用逗号分，例如：

Public static<K,V>V getValue(K key){return map.get(key)}

类型参数的类型推断

编译器判断泛型方法的实际类型参数的过程成为类型推断，类型推断是相对于直觉推断的，其实现方法是一种非常复杂的过程。

根据调用泛型方法时实际传递的参数类型或返回值的类型来听推断，具体分析如下：

1，当某个类型变量只在整个参数列表中的所有参数和返回值中的一处被应用了，那么根据调用方法时该处的实际应用类型来确定，这很容易凭着感觉推断出来，即直接根据调用方法时传递的参数类型或返回值来决定泛型参数的类型，例如：

Swap(new String[3],3,4)-->

static<E>void swap(E[] a,int i,int j);

T add(T a,T b);

2，当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应同一种类型来确定，这很容易凭着感觉推断出来，例如：

Add(3,5)-->

static<T>T add(T a,T b);

3，当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应了不同的类型，且没有使用返回值，这时候去多个参数中的最大交际类型，例如，下面语句实际对应的类型就是Number了，编译没问题，只是运行时出问题：

Fill(new Integer[3],35)-->

static<T>void fill(T[] a,T v);

4，当某个类型变量在整个参数列表中的所有参数和返回值中的多处被应用了，如果调用方法时这多处的实际应用类型都对应了不同的类型，且使用返回值，这时候有限考了返回值类型，例如：下面语句实际对应的类型就是Integer了，编译将报错误，将变量的类型改为float，对比eclipse报告错误提示，接着再将变量x类型改为Number则没有错误：

Int x = (3,3.4) -->

static <T>T add(T a,T b);

5，参数类型的类型推断具有传递性，下面第一种情况推断实际参数类型为Object，编译没问题，而第二种情况则根据参数化的Vector类实例将类型变量直接确定为String类型，编译将出现问题：

Copy(new Integer[5],new String[5])-->

static <T> void copy(T[] a, T,b);

自定义泛型类的应用

如果类的实例对象中的多处都要用到同一个泛型参数，即这些地方引用的泛型类型要保持同一个实际类型时，这时候就要采用泛型类型的方式进行定义，也就是类级别的泛型，语法格式如下：

用Dao举例说明：（是Data access Object 数据访问对象：如在数据库里面增删改查（crud）某个学生）

Public class Generic Dao<T>{

Private T field1;

Public void save(T obj){}

Public T getByld(int id){}

Public void delete(int id){}

Public void update(T obj){}

}

类级别的泛型是根据引用该类名是指定的类型信息来参数化类型变量的，例如，如下两种方式都可以：

GenericDao<String> dao = null;

New genericDao<String>0;

注意：

1，在对泛型类型进行参数化时，类型参数的实例必须是引用类型，不能使基本类型。

2，当一个变量被声明为泛型时，只能被实例变量和方法调用，而不能用静态变量和静态方法调用，因为静态成员是被所有参数化的类所共享的，所以它不应该有类级别的类型参数。

通过反射获得泛型的实际类型参数

我们怎么获取到泛型类的实际类型参数呢？

Vector<Date> v = new Vector<Date>();

若用通常方法通过对象v是获取不到泛型的参数类型，通过张老师的讲解知道我们可以通过将变量交给方法去使用，就可以通过反射来获取泛型类的实际类型参数。

步骤：

1，定义方法，其中参数就是指定的某类型变量

2，通过反射获取该类的字节码，再获取Method

3，在Method类的方法中有获取泛型的返回类型即Type[] getGenericParameterTypes();

（以泛型的类型返回参数列表）

4，在Type类有几个子类，其子类（参数化的类型）即ParameterizedType；这里获取第一个参数Type[0]其返回类型是ParameterizedType；

5，在ParameterizedType类上有可以得到实际类型参数的方法(getActualTypeArguments() 返回的是数组)还有原始类型(Type getRawType())

代码实例：

package cn.heima.Day02;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.net.Proxy.Type;
import java.sql.Date;
import java.util.Vector;

public class ReflectGeneric {
	public static void main(String[] args)throws Exception {
		// TODO Auto-generated method stub
		Method applyMethod=ReflectGeneric.class.getMethod("applyVector", Vector.class);   //获取字节码反射出Method
		ParameterizedType pType = 
			(ParameterizedType)(applyMethod .getGenericParameterTypes())[0]; 
        System.out.println(pType.getActualTypeArguments()[0]);  
        System.out.println(pType.getRawType()); 
	}
	public static void applyVector(Vector<Date> v1){}
}

类加载器加强

简单介绍什么是类加载器和类加载器的作用

简单的说，类加载器就是加载类的工具，将.class文件中的内容变为字节码加载进内存。

在java程序中用到一个类，出现这个类的名字，java虚拟机首先将这个类的字节码加载到内存中，通常这个类的字节码的原始信息放在硬盘上的classPath指定目录下，虚拟机把.class文件的内容加载到内存中，再进行处理，处理过后的结果就是字节码。

系统默认加载器：

Java虚拟机中可以安装多个类加载器，系统默认三个主要类加载器，每个类负责加载特定位置的类：

BootStrap，

ExtClassLoader，

AppClassLoader；

说明：

类加载器也是java类，因为其他是java类的类加载器本身也需要被类加器加载，那么必须有一个类加载器不是java类，它就是BootStrap；（其很特殊，它不是java类，因为它嵌套在java虚拟机内核里面，所以java虚拟机启动它就开启了，它是C++语言写的二进制代码）

所以不能通过java程序获取其名字，获得的只能是null。

示例代码：

package cn.heima.Day02;
public class ClassLoaderTest {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//通过反射获取字节码，再通过Class上的方法getClassLoader返回的是ClassLoader对象，（因为类加载也是一个java对象所以对象也有自己的类型）类加载器再转为字节码获取类加载器名称
		System.out.println(ClassLoaderTest.class.getClassLoader().
				getClass().getName());//sun.misc.Launcher$AppClassLoader
		//BootStarp没有再类似父类的类加载器所以获取不了名称
		System.out.println(System.class.getClassLoader());//null
	}
}

类加载器间的关系及结构

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

类加载器之间的父子关系和管辖范围图

类加载器的委托机制

什么是类加载器的委托？

每个ClassLoader本身只能分别加载特定位置和目录中的类，但它们可以委托其他的类加载器去加载类，这就是类加载器的委托模式。

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

1，当前线程的类加载器去加载线程中的第一个类。

2，若A引用类B（即继承或使用B），Java虚拟机将使用加载类的类加载器来加载类B。

3，还可以直接调用ClassLoader的LoaderClass()方法，来指定某个类加载器去加载某个类。

委托模式：每个类加载器加载类时，又先委托给上级类加载器。

类装载器是一级级委托到顶级BootStrap类加载器，当BootStrap无法加载当前所要加载的类时，然后才一级级回退到子孙类加载器去进行加载。当退回到最初的发起者类装载器时，如果它自己也不能完成类的装载，那就会抛出ClassNotFoundException异常。这时就不会再委托发起者加载器的子类去加载了，如果它还有子类的话。

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

委托机制的好处：

可以集中管理，不会产生多字节码重复的现象。

张孝祥老师的补充面试题：

问题：你可不可以自己写个类为：java.lang.System呢？

回答：（注意技巧，不要直接否定，通过简要说明委托机制的原理来回答）

首先呢通常不可以的，因为类加载器的委托机制，会将System这个类一级一级的委托到顶级BootStrap，由于BootStrap是在指定的目录中加载rt.jar中的类，且其中就有System这个类的，那么首先它就会直接加载自己目录中的，就是早就定义好的System类，而不会加载自定义的Sytsem类。

但是，还是有办法加载这个自定义的System类的，首先就不能交给上级加载了，需要用自定义的类加载器加载，这就需要有特殊的写法才能去加载这个自定义的System类的。

自定义类加载器的编写原理分析

自定义的类加载器必须继承抽象类ClassLoader，

要覆写其中的findClass(String name)方法（参数指定字符串即：类名），而不用覆写loadClass()方法。

不复写loadClass方法而覆写findClass(Stringname)方法的原因：

1，根据原理我们了解了，在loadClass()内部是会先委托给父级，当父级找不到后返回，再调用findClass(String name)方法，也就是你自定义的类加载器去找。所以只需要覆写findClass方法，就能实现用自定义的类加载器加载类的目的。如果是复写loadClass就还需要找父级，还要复写找父级的方法，这样就很麻烦得不偿失。

2，一般自定义类加载器，会把需要加载的类放在自己指定的目录中，而java中已有的类加载器是不知道你这个目录的，所以会找不到。这样才会调用你复写的findClass()方法，用你自定义的类加载器去指定的目录加载类。

3，这是一种模板方法设计模式。这样就保留了loadClass()方法中的流程（这个流程就是先找父级，找不到再调用自定义的类加载器），而我们只需复写findClass方法，实现局部细节就行了。

注： ClassLoader提供了一个protected Class<?> defineClass(String name, byte[] b, int off, int len)方法，只需要将类对应的class文件传入，就可以将其变为字节码。

简单步骤模式：

复写findClass方法-->传入类名（字符串）-->将字符串转成字节数组（方法loadClassData）-->通过ClassLoader抽象类提供的defineClass(name, byte[] b,开始处，长度)方法，转换成字节码。

编程步骤：

1，编写一个对文件内容进行简单加密的程序

2，编写好了一个自己的类加载器，可实现对加密过来的类进行加载和解密。

3，编写一个程序，调用类加载器加载类，在源程序中不能用该类名定义引用变量，因为编译器无法识别这个类，程序中除了可使用ClassLoader的loadClass方法外，还可以使用设置线程的上下文类加载器或系统类加载器，然后再使用Class.forName。

实验步骤：

1，对不带包名的class文件进行加密，加密结果存放到另外一个目录，例如： java MyClassLoader MyTest.class F:\itcast

2，运行加载类的程序，结果能够被正常加载，但打印出来的类加载器名称为AppClassLoader：java MyClassLoader MyTest F:\itcast

3，用加密后的类文件替换CLASSPATH环境下的类文件，再执行上一步操作就出问题了，错误说明是AppClassLoader类装载器装载失败。

4，删除CLASSPATH环境下的类文件，再执行上一步操作就没问题了。

代码实例：

测试类：
package cn.heima.Day02;
import java.util.Date;
定义一个测试类，继承Date，便于使用时加载 
public class ClassLoaderAttachment extends Date{
	//覆盖Data类的toString方法
	public String toString(){
		return "hello heima";
	}
}
package cn.heima.Day02;

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Date;
public class MyClassLoader extends ClassLoader{
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		/*我们要调用加密的类对某个文件进行加密，
		需要传递文件的路径和要保存文件的路径即 源 和目的；
		*/
		String srcPath = args[0];//源
		String destDir = args[1];//目的
		String fileName = srcPath.substring(srcPath.lastIndexOf("\\"));
		String destPath = destDir+"\\"+fileName;
		FileInputStream fis = new FileInputStream(srcPath);
		FileOutputStream fos = new FileOutputStream(destPath);
		//将文件加密，调用自定义的方法
		cypher(fis,fos);
		fis.close();
		fos.close();//将资源关闭，（现在创建可以创建一个类，让对其类加密）
	}
	//定义一个加密方法
	private static void cypher(InputStream ips,OutputStream ops)throws Exception{
		//加密算法
		int b = -1;
		while((b = ips.read())!=-1){
			ops.write(b^0xff);
		}
	}
	//覆盖ClassLoader的findClass方法 
	@Override
	protected Class<?> findClass(String name) throws ClassNotFoundException {
		// TODO Auto-generated method stub
		 name=name.substring(name.lastIndexOf(".")+1);    
	        String classFileName=classDir+"\\"+name+".class";//获取class文件名    
	        InputStream ips=null;    
	        try {    
	            ips=new FileInputStream(classFileName);    
	            ByteArrayOutputStream bos=new ByteArrayOutputStream();//定义字节数组流    
	            cypher(ips,bos);//解密    
	            ips.close();    
	            byte[] buf=bos.toByteArray();//取出字节数组流中的数据    
	            return defineClass(null, buf,0,buf.length);//加载进内存    
	                
	        } catch (Exception e) {    
	            // TODO: handle exception    
	            e.printStackTrace();    
	        }    
	        return null;    
	        //return super.findClass(name);    
	}
	 private String classDir;    
	    public MyClassLoader(){}    
	    //带参数的构造函数    
	    public MyClassLoader(String classDir){    
	        this.classDir=classDir;    
	    }
package cn.heima.Day02;
import java.util.Date;
public class ClassLoaderDemo {
	public static void main(String[] args) throws Exception{
		// TODO Auto-generated method stub
		//将用自定义的类加载器加载.class文件    
        Class clazz=new MyClassLoader("itheimalib").loadClass("cn.itheima.demo.ClassLoaderAttachment");    
        Date d1 =  (Date)clazz.newInstance();//获取Class类的实例对象    
        System.out.println(d1); 
	}
}

------------------