黑马程序员_温习 高新技术二 (个人笔记)摘要（JavaBean类------注解------泛型------类加载器(代理)）

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------

摘要（JavaBean类------注解------泛型------类加载器(代理)）

小体会：高新技术这里，个人感觉挺难的，首先 eclipse 之前没用过

其次和毕老师的教程联系不太多，第一次看的迷迷糊糊的

直到第二遍才有点感觉, 尤其是反射的原理想了很久才有点明白。

泛型的原理及应用

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入，编译器编译带类型说明的集合时会去除掉“类型”信息，使程序运行效率不受影响，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。

由于编译生成的字节码会去掉泛型的类型信息，只要能跳过编译器，就可以往某个泛型集合中加入其它类型的数据，例如，用反射得到集合，再调用其add方法即可。

泛型是jdk1.5的所有新特性中最难深入掌握的部分，不过，我们在实际应用中不需要掌握得那么深入，掌握泛型中一些最基本的内容就差不多了。

没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，这样更方便。

在JDK 1.5中，你还可以按原来的方式将各种不同类型的数据装到一个集合中，但编译器会报告unchecked警告。

泛型中的？通配符扩展:

限定通配符的上边界：

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

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

限定通配符的下边界：

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

错误：Vector<? super Integer> x = new Vector<Byte>();

提示：

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

?只能用作引用，不能用它去给其他变量赋值

Vector<? extends Number> y = new Vector<Integer>();

Vector<Number> x = y;

上面的代码错误，原理与Vector<Object > x11 = new Vector<String>();相似，

只能通过强制类型转换方式来赋值。

整个称为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>(); //错误!

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

编译器不允许创建泛型变量的数组。即在创建数组实例时，数组的元素不能使用参数化的类型，例如，下面语句有错误：

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

Vector v1 = new Vector<String>();

Vector<Object> v = v1;

Cols<Object> 中的Object只是说明Cols<Object> 实例对象中的方法接受的参数是Object

Cols<Object> 是一种具体类型，new HashSet<Date>也是一种具体类型，两者没有兼容性问题。

Collection<?> a可以与任意参数化的类型匹配，但到底匹配的是什么类型，只有以后才知道，所以，a=new ArrayList<Integer>和a=new ArrayList<String>都可以

但a.add(new Date())或a.add(“abc”)都不行，

HashMap<String,Integer> hm = new HashMap<String,Integer>();

hm.put("zxx",19);

hm.put("lis",18);

Set<Map.Entry<String,Integer>> mes= hm.entrySet();

for(Map.Entry<String,Integer> me : mes) {

System.out.println(me.getKey() + ":" + me.getValue());

}

对在jsp页面中也经常要对Set或Map集合进行迭代：

<c:forEach items=“${map}” var=“entry”>

${entry.key}:${entry.value}

</c:forEach>

定义泛型方法:

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

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

return (T) (x+y);

//return null;

}

Ø 用于放置泛型的类型参数的尖括号应出现在方法的其他所有修饰符之后和在方法的返回类型之前，也就是紧邻返回值之前。按照惯例，类型参数通常用单个大写字母表示。

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

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

E t = a[i];

a[i] = a[j];

a[j] = t;

}//或用一个面试题讲：把一个数组中的元素的顺序颠倒一下

l 只有引用类型才能作为泛型方法的实际参数，swap(new int[3],3,5);语句会编译错误。

l 除了在应用泛型时可以使用extends限定符，在定义泛型时也可以使用extends限定符，例如，Class.getAnnotation()方法的定义。并且可以用&来指定多个边界，如<V extends Serializable & cloneable> void method(){}

l 普通方法、构造方法和静态方法中都可以使用泛型。但是数组元素不能使用参数化类型

泛型类中的静态上下文中类型变量无效。

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

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

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

Java中的泛型类型（或者泛型）类似于 C++ 中的模板。但是这种相似性仅限于表面，Java 语言中的泛型基本上完全是在编译器中实现，用于编译器执行类型检查和类型推断，然后生成普通的非泛型的字节码，这种实现技术称为擦除（erasure）（编译器使用泛型类型信息保证类型安全，然后在生成字节码之前将其清除）。这是因为扩展虚拟机指令集来支持泛型被认为是无法接受的，这会为 Java 厂商升级其 JVM 造成难以逾越的障碍。所以，java的泛型采用了可以完全在编译器中实现的擦除方法。

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

public class GenericDao<T> {

private T field1;

public void save(T obj){}

public T getById(int id){}

}

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

GenericDao<String> dao = null;

new genericDao<String>();

注意：

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

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

问题：类中只有一个方法需要使用泛型，是使用类级别的泛型，还是使用方法级别的泛型？ 类级别的

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

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

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

swap(new String[3],3,4) static <E> void swap(E[] a, int i, int j)

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

add(3,5) à static <T> T add(T a, T b)

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

fill(new Integer[3],3.5f) static <T> void fill(T[] a, T v)

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

int x =(3,3.5f) à static <T> T add(T a, T b)

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

copy(new Integer[5],new String[5]) à static <T> void copy(T[] a,T[] b);

copy(new Vector<String>(), new Integer[5]) à static <T> void copy(Collection<T> a , T[] b);

类加载器

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.用下面的代码让查看类加载器的层次结构关系

ClassLoader loader = ClassLoaderTest.class.getClassLoader();

//打印出当前的类装载器，及该类装载器的各级父类装载器

while(loader != null){

System.out.println(loader.getClass().getName());

loader = loader.getParent();

}

【通过反射获得泛型的参数化类型】：

示例代码：

Class GenericalReflection {

private Vector<Date> dates = new Vector<Date>();

public void setDates(Vector<Date> dates) {

this.dates = dates;

}

public static void main(String[] args) {

Method methodApply = GenericalReflection.class.getDeclaredMethod("applyGeneric", Vector.class);

ParameterizedType pType = (ParameterizedType)

(methodApply .getGenericParameterTypes())[0];

System.out.println("setDates("

+ ((Class) pType.getRawType()).getName() + "<"

+ ((Class) (pType.getActualTypeArguments()[0])).getName()

+ ">)" );

}

类加载器的委托机制：

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

首先当前线程的类加载器去加载线程中的第一个类。

如果类A中引用了类B，Java虚拟机将使用加载类A的类装载器来加载类B。

还可以直接调用ClassLoader.loadClass()方法来指定某个类加载器去加载某个类。

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

当所有祖宗类加载器没有加载到类，回到发起者类加载器，还加载不了，则抛ClassNotFoundException，不是再去找发起者类加载器的儿子，因为没有getChild方法，即使有，那有多个儿子，找哪一个呢？

对着类加载器的层次结构图和委托加载原理，解释先前将ClassLoaderTest输出成jre/lib/ext目录下的itcast.jar包中后，运行结果为ExtClassLoader的原因。

每个ClassLoader本身只能分别加载特定位置和目录中的类，但它们可以委托其他的类装载器去加载类，这就是类加载器的委托模式。类装载器一级级委托到BootStrap类加载器，当BootStrap无法加载当前所要加载的类时，然后才一级级回退到子孙类装载器去进行真正的加载。当回退到最初的类装载器时，如果它自己也不能完成类的装载，那就应报告ClassNotFoundException异常。

把先前编写的类加入到jdk的rt.jar中，会有怎样的效果呢？不行!!!看来是不能随意将自己的class文件加入进rt.jar文件中的。

编写自己的类加载器：

知识讲解：

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

loadClass方法委托父类加载器去加载，父类无法加载时调用findClass方法

defineClass方法

编程步骤：

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

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

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

实验步骤：

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

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

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

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

---------------------- <a href="http://edu.csdn.net"target="blank">ASP.Net+Android+IOS开发</a>、<a href="http://edu.csdn.net"target="blank">.Net培训</a>、期待与您交流！ ----------------------