泛型:JAVA5时引入，泛型实现了参数化类型的概念，使代码可以应用于多种类型.
常用的泛型实现：<T> /<k,v>/Object/<?>/<? extends xxx>/<? super xxx>
1.泛型类/接口：
(1).泛型接口：
如一个提供产生指定类的接口：
public interface Gernerator<T>{
T next() ;
}
public class A implement Generator<A>{
A next(){
return new A();
}
}
(2).泛型类：
public class Test1<T>{
}
2.泛型方法：
例如：
public class GenericMethods{
public <T> void f(T x){
System.out.println(x.getClass().getName()) ;
}
public static void main(String[] args){
GenericMethods gm = new GenericMethods();
gm.f(“”);
gm.f(1);
gm.f(1.0);
……
}
}
输出结果为：
java.lang.String
java.lang.Integer
java.lang.Double
3.泛型集合：
Java中泛型集合使用的非常广泛，在Java5以前，java中没有引入泛型机制，使用java集合容器时经常遇到如下两个问题：
a. java容器默认存放Object类型对象，如果一个容器中即存放有A类型对象，又存放有B类型对象，如果用户将A对象和B对象类型弄混淆，则容易产生转换错误，会发生类型转换异常。
b. 如果用户不知道集合容器中元素的数据类型，同样也可能会产生类型转换异常。
鉴于上述的问题，java5中引入了泛型机制，在定义集合容器对象时显式指定其元素的数据类型，在使用集合容器时，编译器会检查数据类型是否和容器指定的数据类型相符合，如果不符合在无法编译通过，从编译器层面强制保证数据类型安全。
(1).java常用集合容器泛型使用方法：
如：
public class New{
public static <K, V> Map<K, V> map(){
return new HashMap<K, V>();
}
public static <T> List<T> list(){
return new ArrayList<T>() ;
}
public static <T> LinkedList<T> lList(){
return new LinkedList<T>();
}
public static <T> Set<T> set(){
return new HashSet<T>();
}
public static <T> Queue<T> queue(){
return new LinkedList<T>() ;
}
;public static void main(String[] args){
Map<String, List<String>> sls = New.map();
List<String> ls = New.list();
LinkedList<String> lls = New.lList();
Set<String> ss = New.set();
Queue<String> qs = New.queue();
}
}
(2).Java中的Set集合是数学上逻辑意义的集合，使用泛型可以很方便地对任何类型的Set集合进行数学运算，代码如下：
public class Sets{
//并集
public static <T> Set<T> union(Set<T> a, Set<T> b){
Set<T> result = new HashSet<T>(a);
result.addAll(b);
return result;
}
//交集
public static <T> Set<T> intersection(Set<T> a, Set<T> b){
Set<T> result = new HashSet<T>(a);
result.retainAll(b);
return result;
}
//差集
public static <T> Set<T> difference(Set<T> a, Set<T> b){
Set<T> result = new HashSet<T>(a);
result.removeAll(b);
return Result;
}
//补集
public static <T> Set<T> complement(Set<T> a, Set<T> b){
return difference(union(a, b), intersection(a, b));
}
}
4.泛型也可用于匿名内部类
class Customer {
private static long counter = 1;
private final long id = counter++;
private Customer() {
}
public String toString() {
return "Customer " + id;
}
// A method to produce Generator objects:
public static Generator<Customer> generator() {
//匿名内部类
return new Generator<Customer>() {
public Customer next() {
return new Customer();
}
};
}
}
class Teller {
private static long counter = 1;
private final long id = counter++;
private Teller() {
}
public String toString() {
return "Teller " + id;
}
// A single Generator object:
public static Generator<Teller> generator = new Generator<Teller>() {
//匿名内部类
public Teller next() {
return new Teller();
}
};
}
5.用泛型构建复杂数据结构模型
泛型能够简单而安全的创建复杂的数据结构模型，例如下面的 泛型List ：
public class TupleList<A, B, C, D> extends ArrayList<FourTuple<A, B, C, D>> {
public static void main(String[] args) {
TupleList<Vehicle, Amphibian, String, Integer> tl = new TupleList<Vehicle, Amphibian, String, Integer>();
tl.add(TupleTest.h());
tl.add(TupleTest.h());
for (FourTuple<Vehicle, Amphibian, String, Integer> i : tl)
System.out.println(i);
}
} /*
* Output:
* (75% match) (Vehicle@11b86e7, Amphibian@35ce36, hi, 47)
* (Vehicle@757aef, Amphibian@d9f9c3, hi, 47)
*/// :~
尽管看起来复杂，但依旧是一个强大的数据结构.
6.泛型边界：
边界使得你可以在用于泛型的参数类型上设置限制条件。
Java泛型编程时，编译器忽略泛型参数的具体类型，认为使用泛型的类、方法对Object都适用，这在泛型编程中称为类型信息檫除。
例如：
class GenericType{
public static void main(String[] args){
System.out.println(new ArrayList<String>().getClass());
System.out.println(new ArrayList<Integer>().getClass());
}
}
输出结果为：
java.util.ArrayList
java.util.ArrayList
泛型忽略了集合容器中具体的类型，这就是类型檫除。
7.类型通配符
Box<Number>和Box<Integer>实际上都是Box类型，现在需要继续探讨一个问题，那么在逻辑上，类似于Box<Number>和Box<Integer>是否可以看成具有父子关系的泛型类型呢？
为了弄清这个问题，我们继续看下下面这个例子:
class Box<T> {
private T data;
public Box() {
}
public Box(T data) {
setData(data);
}
public T getData() {
return data;
}
public void setData(T data) {
this.data = data;
}
}
public class GenericTest {
public static void main(String[] args) {
Box<Number> name = new Box<Number>(99);
Box<Integer> age = new Box<Integer>(712);
getData(name);
//The method getData(Box<Number>) in the type GenericTest is
//not applicable for the arguments (Box<Integer>)
getData(age); // 1
}
public static void getData(Box<Number> data){
System.out.println("data :" + data.getData());
}
19
20 }
假设Box<Number>在逻辑上可以视为Box<Integer>的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getData()方法取出数据时到底是什么类型呢？Integer? Float? 还是Number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上Box<Number>不能视为Box<Integer>的父类。
好，那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总部能再定义一个新的函数吧。这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Box<Integer>和Box<Number>的父类的一个引用类型，由此，类型通配符应运而生。
类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box<?>在逻辑上是Box<Integer>、Box<Number>...等所有Box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。
在代码//1处出现了错误提示信息：The method getData(Box<Number>) in the t ype GenericTest is not applicable for the arguments (Box<Integer>)。显然，通过提示信息，我们知道Box<Number>在逻辑上不能视为Box<Integer>的父类。那么，原因何在呢？
假设Box<Number>在逻辑上可以视为Box<Integer>的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getData()方法取出数据时到底是什么类型呢？Integer? Float? 还是Number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上Box<Number>不能视为Box<Integer>的父类。
好，那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总部能再定义一个新的函数吧。这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Box<Integer>和Box<Number>的父类的一个引用类型，由此，类型通配符应运而生。
类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box<?>在逻辑上是Box<Integer>、Box<Number>...等所有Box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。
public class GenericTest {
public static void main(String[] args) {
Box<String> name = new Box<String>("corn");
Box<Integer> age = new Box<Integer>(712);
Box<Number> number = new Box<Number>(314);
getData(name);
getData(age);
getData(number);
}
public static void getData(Box<?> data) {
System.out.println("data :" + data.getData());
}
}
有时候，我们还可能听到类型通配符上限和类型通配符下限。具体有是怎么样的呢？
在上面的例子中，如果需要定义一个功能类似于getData()的方法，但对类型实参又有进一步的限制：只能是Number类及其子类。此时，需要用到类型通配符上限。
public class GenericTest {
public static void main(String[] args) {
Box<String> name = new Box<String>("corn");
Box<Integer> age = new Box<Integer>(712);
Box<Number> number = new Box<Number>(314);
getData(name);
getData(age);
getData(number);
//getUpperNumberData(name); // 1
getUpperNumberData(age); // 2
getUpperNumberData(number); // 3
}
public static void getData(Box<?> data) {
System.out.println("data :" + data.getData());
}
public static void getUpperNumberData(Box<? extends Number> data){
System.out.println("data :" + data.getData());
}
}
此时，显然，在代码//1处调用将出现错误提示，而//2 //3处调用正常。
类型通配符上限通过形如Box<? extends Number>形式定义，相对应的，类型通配符下限为Box<? super Number>形式，其含义与类型通配符上限正好相反，在此不作过多阐述了。
另外
Java中没有所谓的泛型数组一说。
对于泛型，最主要的还是需要理解其背后的思想和目的。
