初步认识java泛型

在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的 强制类型转换 ，而这种转换是要求开发者对 实际参数 类型可以预知的情况下进行的。对于 强制类型转换 错误的情况， 编译器 可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的（不需要前加强制类型转换），提高代码的重用率。

[java]  view plain copy

1. public class Gen<T> {  
2.     private T ob; // 定义泛型成员变量  
3.   
4.     public Gen(T ob) {  
5.         this.ob = ob;  
6.     }  
7.   
8.     public T getOb() {  
9.         return ob;  
10.     }  
11.   
12.     public void setOb(T ob) {  
13.         this.ob = ob;  
14.     }  
15.   
16.     public void showType() {  
17.         System.out.println("T的实际类型是: " + ob.getClass().getName());  
18.     }  
19. }  

[java]  view plain copy

1. public class GenDemo {  
2.     public static void main(String[] args) {  
3.         // 定义泛型类Gen的一个Integer版本  
4.         Gen<Integer> intOb = new Gen<Integer>(88);  
5.         intOb.showType();  
6.         int i = intOb.getOb(); //不需要加强制类型转换 
7.         System.out.println("value= " + i);  
8.         System.out.println("----------------------------------");  
9.         // 定义泛型类Gen的一个String版本  
10.         Gen<String> strOb = new Gen<String>("Hello Gen!");  
11.         strOb.showType();  
12.         String s = strOb.getOb();  
13.         System.out.println("value= " + s);  
14.     }  
15. }  

[java]  view plain copy

1. public class Gen2 {  
2.     private Object ob; //定义一个通用类型成员  
3.     public Gen2(Object ob) {  
4.     this.ob = ob;  
5.     }  
6.     public Object getOb() {  
7.     return ob;  
8.     }  
9.     public void setOb(Object ob) {  
10.     this.ob = ob;  
11.     }  
12.     public void showTyep() {  
13.     System.out.println("T的实际类型是: " + ob.getClass().getName());  
14.     }  
15. }  

[java]  view plain copy

1. public class GenDemo2 {  
2.     public static void main(String[] args) {  
3.         //定义类Gen2的一个Integer版本  
4.         Gen2 intOb = new Gen2(new Integer(88));  
5.         intOb.showTyep();  
6.         int i = (Integer) intOb.getOb();  //需要强制类型转换
7.         System.out.println("value= " + i);  
8.         System.out.println("---------------------------------");  
9.         //定义类Gen2的一个String版本  
10.         Gen2 strOb = new Gen2("Hello Gen!");  
11.         strOb.showTyep();  
12.         String s = (String) strOb.getOb();  
13.         System.out.println("value= " + s);  
14.         }  
15. }  

做项目的时候，我们很多时候可能想写一个方法，可以处理不同的类型，最常见的是继承，通过将方法的参数写成父类（或者是一个接口），这样利用多态就可以实现传入任意子类型。但是局限性是很明显的，只能传入该类型和他的子类型。

但是我们很多时候需要的功能远不止这样，我们需要不管我传入什么类型都可以处理，这该怎么办呢？

java泛型机制可以帮你解决这个问题。

java泛型机制笔记一：

1、java泛型可以作用于类 也可以作用于方法，  拥有泛型方法的类不一定要定义为泛型类，这两者之间没有联系。

2、泛型类在初始化的时候需要制定类型，这个时候不可以是基本数据类型。这个时候java自动装箱不起作用。

3、泛型方法的定义格式： 访问修饰符 <泛型参数列表> 返回值  方法名称(方法参数列表)

4、访问泛型方法时候可以传入基本数据类型，这个时候java的自动装箱有用。

提给程序员和开发者的 10 道 Java 泛型面试题

英文原文：10 Interview Questions on Java Generics for Programmer and Developers

关于泛型的面试题在  Java面试中变得越来越常见，因为  Java 5问世已经有相当长的时间了，越来越多的应用已经迁移到Java 5上来了，并且几乎所有新的Java开发工作也都是在Tiger(Java 5的项目代号)版本上进行的。泛型和其它Java 5特性比如  枚举、  自动拆装箱、  可变参数，还有集合工具类比如  CountDownLatch、  CyclicBarrier 和  BlockingQueue ，这些在Java面试中变得越来越流行。如果你对  泛型的限定通配符和非限定通配符不熟悉，那么泛型面试题就会变得非常的棘手。  Java内部  泛型是怎么工作的呢，答案是类型擦除，此外程序员也应当精通于编写带参数的Java泛型类和泛型方法。准备泛型面试的最好的方法是，尝试编写一些简单的程序来了解泛型的各种特性。而本文中，我们将会看到一些流行的Java泛型面试题及其答案。顺便说一下，Javarevisited网站上提供了很多资料来帮助你更好的为Java和J2EE面试做准备，你可以查看  15个线程面试题和  排名前10的Java集合类面试题来准备多线程和集合类方面的知识，另外还有关于Spring、Struts、JSP和Servlet的问答文章。如果你是GUI开发人员，并且使用的是Java Swing技术，那么你也可以查看投资银行面试中通常会问到的  Java Swing面试题。

Java泛型面试题 1. Java中的泛型是什么 ? 使用泛型的好处是什么? 这是在各种Java泛型面试中，一开场你就会被问到的问题中的一个，主要集中在初级和中级面试中。那些拥有Java1.4或更早版本的开发背景的人都知道，在集合中存储对象并在使用前进行类型转换是多么的不方便。泛型防止了那种情况的发生。它提供了编译期的类型安全，确保你只能把正确类型的对象放入集合中，避免了在运行时出现ClassCastException。

2. Java的泛型是如何工作的 ? 什么是类型擦除 ? 这是一道更好的泛型面试题。泛型是通过类型擦除来实现的，编译器在编译时擦除了所有类型相关的信息，所以在运行时不存在任何类型相关的信息。例如List<String>在运行时仅用一个List来表示。这样做的目的，是确保能和Java 5之前的版本开发二进制类库进行兼容。你无法在运行时访问到类型参数，因为编译器已经把泛型类型转换成了原始类型。根据你对这个泛型问题的回答情况，你会得到一些后续提问，比如为什么泛型是由类型擦除来实现的或者给你展示一些会导致编译器出错的错误泛型代码。请阅读我的Java中泛型是如何工作的来了解更多信息。

3. 什么是泛型中的限定通配符和非限定通配符 ? 这是另一个非常流行的Java泛型面试题。限定通配符对类型进行了限制。有两种限定通配符，一种是<? extends T>它通过确保类型必须是T的子类来设定类型的上界，另一种是<? super T>它通过确保类型必须是T的父类来设定类型的下界。泛型类型必须用限定内的类型来进行初始化，否则会导致编译错误。另一方面<?>表示了非限定通配符，因为<?>可以用任意类型来替代。更多信息请参阅我的文章泛型中限定通配符和非限定通配符之间的区别。

4. List<? extends T>和List <? super T>之间有什么区别 ? 这和上一个面试题有联系，有时面试官会用这个问题来评估你对泛型的理解，而不是直接问你什么是限定通配符和非限定通配符。这两个List的声明都是限定通配符的例子，List<? extends T>可以接受任何继承自T的类型的List，而List<? super T>可以接受任何T的父类构成的List。例如List<? extends Number>可以接受List<Integer>或List<Float>。在本段出现的连接中可以找到更多信息。

5. 如何编写一个泛型方法，让它能接受泛型参数并返回泛型类型? 编写泛型方法并不困难，你需要用泛型类型来替代原始类型，比如使用T, E or K,V等被广泛认可的类型占位符。泛型方法的例子请参阅Java集合类框架。最简单的情况下，一个泛型方法可能会像这样: 1 public V put(K key, V value) { 2         return cache.put(key, value); 3 }

6. Java中如何使用泛型编写带有参数的类? 这是上一道面试题的延伸。面试官可能会要求你用泛型编写一个类型安全的类，而不是编写一个泛型方法。关键仍然是使用泛型类型来代替原始类型，而且要使用JDK中采用的标准占位符。 7. 编写一段泛型程序来实现LRU缓存? 对于喜欢Java编程的人来说这相当于是一次练习。给你个提示，LinkedHashMap可以用来实现固定大小的LRU缓存，当LRU缓存已经满了的时候，它会把最老的键值对移出缓存。LinkedHashMap提供了一个称为removeEldestEntry()的方法，该方法会被put()和putAll()调用来删除最老的键值对。当然，如果你已经编写了一个可运行的JUnit测试，你也可以随意编写你自己的实现代码。

8. 你可以把List<String>传递给一个接受List<Object>参数的方法吗？ 对任何一个不太熟悉泛型的人来说，这个Java泛型题目看起来令人疑惑，因为乍看起来String是一种Object，所以List<String>应当可以用在需要List<Object>的地方，但是事实并非如此。真这样做的话会导致编译错误。如果你再深一步考虑，你会发现Java这样做是有意义的，因为List<Object>可以存储任何类型的对象包括String, Integer等等，而List<String>却只能用来存储Strings。 1 List<Object> objectList; 2 List<String> stringList; 3        4 objectList = stringList;  //compilation error incompatible types

9. Array中可以用泛型吗? 这可能是Java泛型面试题中最简单的一个了，当然前提是你要知道Array事实上并不支持泛型，这也是为什么Joshua Bloch在Effective Java一书中建议使用List来代替Array，因为List可以提供编译期的类型安全保证，而Array却不能。 10. 如何阻止Java中的类型未检查的警告? 如果你把泛型和原始类型混合起来使用，例如下列代码，Java 5的javac编译器会产生类型未检查的警告，例如 1 List<String> rawList = new ArrayList() 2 注意: Hello.java使用了未检查或称为不安全的操作; 这种警告可以使用@SuppressWarnings("unchecked")注解来屏蔽。

!

Java泛型面试题补充更新: 我手头又拿到了几个Java泛型面试题跟大家分享下，这几道题集中在泛型类型和原始类型的区别上，以及我们是否可以用Object来代替限定通配符的使用等等： Java中List<Object>和原始类型List之间的区别? 原始类型和带参数类型<Object>之间的主要区别是，在编译时编译器不会对原始类型进行类型安全检查，却会对带参数的类型进行检查，通过使用Object作为类型，可以告知编译器该方法可以接受任何类型的对象，比如String或Integer。这道题的考察点在于对泛型中原始类型的正确理解。它们之间的第二点区别是，你可以把任何带参数的类型传递给原始类型List，但却不能把List<String>传递给接受List<Object>的方法，因为会产生编译错误。更多详细信息请参阅Java中的泛型是如何工作的。

Java中List<?>和List<Object>之间的区别是什么? 这道题跟上一道题看起来很像，实质上却完全不同。List<?> 是一个未知类型的List，而List<Object>其实是任意类型的List。你可以把List<String>, List<Integer>赋值给List<?>，却不能把List<String>赋值给List<Object>。      1 List<?> listOfAnyType; 2 List<Object> listOfObject = new ArrayList<Object>(); 3 List<String> listOfString = new ArrayList<String>(); 4 List<Integer> listOfInteger = new ArrayList<Integer>(); 5        6 listOfAnyType = listOfString; //legal 7 listOfAnyType = listOfInteger; //legal 8 listOfObjectType = (List<Object>) listOfString; //compiler error - in-convertible types 想了解更多关于通配符的信息请查看Java中的泛型通配符示例

List<String>和原始类型List之间的区别. 该题类似于“原始类型和带参数类型之间有什么区别”。带参数类型是类型安全的，而且其类型安全是由编译器保证的，但原始类型List却不是类型安全的。你不能把String之外的任何其它类型的Object存入String类型的List中，而你可以把任何类型的对象存入原始List中。使用泛型的带参数类型你不需要进行类型转换，但是对于原始类型，你则需要进行显式的类型转换。 view source print ? 01 List listOfRawTypes = new ArrayList(); 02 listOfRawTypes.add("abc"); 03 listOfRawTypes.add(123); //编译器允许这样 - 运行时却会出现异常 04 String item = (String) listOfRawTypes.get(0); //需要显式的类型转换 05 item = (String) listOfRawTypes.get(1); //抛ClassCastException，因为Integer不能被转换为String 06        07 List<String> listOfString = new ArrayList(); 08 listOfString.add("abcd"); 09 listOfString.add(1234); //编译错误，比在运行时抛异常要好 10 item = listOfString.get(0); //不需要显式的类型转换 - 编译器自动转换

出处：  http://www.oschina.net/translate/10-interview-questions-on-java-generics?p=2#comments