java编程思想笔记（九）泛型

阅读更多

泛型:JAVA5时引入，泛型实现了参数化类型的概念，使代码可以应用于多种类型.

常用的泛型实现： //Object///

 

1.泛型类/接口：

(1).泛型接口：

如一个提供产生指定类的接口：

public interface Gernerator{  
    T next() ;  
}  
public class A implement Generator{  
    A next(){  
        return new A();  
    }  
}  

 

 

 (2).泛型类：

public class Test1{  
}

 

 

2.泛型方法：

例如：

public class GenericMethods{  
    public  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  Map map(){  
        return new HashMap();  
}  
public static  List list(){  
    return new ArrayList() ;  
}  
public static  LinkedList lList(){  
    return new LinkedList();  
}  
public static  Set set(){  
    return new HashSet();  
}  
public static  Queue queue(){  
    return new LinkedList() ;  
}  
;public static void main(String[] args){  
    Map> sls = New.map();  
    List ls = New.list();  
    LinkedList lls = New.lList();  
    Set ss = New.set();  
    Queue qs = New.queue();  
}  
}  
 
(2).Java中的Set集合是数学上逻辑意义的集合，使用泛型可以很方便地对任何类型的Set集合进行数学运算，代码如下：
public class Sets{  
    //并集  
    public static  Set union(Set a, Set b){  
        Set result = new HashSet(a);  
        result.addAll(b);  
        return result;  
}  
//交集  
public static  Set intersection(Set a, Set b){  
    Set result = new HashSet(a);  
    result.retainAll(b);  
    return result;  
}  
//差集  
public static  Set difference(Set a, Set b){  
    Set result = new HashSet(a);  
    result.removeAll(b);  
    return Result;  
}  
//补集  
public static  Set complement(Set a, Set 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 generator() {
		//匿名内部类
		return new Generator() {
			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 generator = new Generator() {
		//匿名内部类
		public Teller next() {
			return new Teller();
		}
	};
}

 

 5.用泛型构建复杂数据结构模型

  泛型能够简单而安全的创建复杂的数据结构模型，例如下面的 泛型List ：

public class TupleList extends ArrayList> {
	public static void main(String[] args) {
		TupleList tl = new TupleList();
		tl.add(TupleTest.h());
		tl.add(TupleTest.h());
		for (FourTuple 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().getClass());  
        System.out.println(new ArrayList().getClass());  
}  
}  

输出结果为：

java.util.ArrayList

java.util.ArrayList

泛型忽略了集合容器中具体的类型，这就是类型檫除。

 

7.类型通配符

Box和Box实际上都是Box类型，现在需要继续探讨一个问题，那么在逻辑上，类似于Box和Box是否可以看成具有父子关系的泛型类型呢？

为了弄清这个问题，我们继续看下下面这个例子:

 class Box {
 
     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 name = new Box(99);
          Box age = new Box(712);
  
          getData(name);
          
         //The method getData(Box) in the type GenericTest is 
         //not applicable for the arguments (Box)
         getData(age);   // 1
 
     }
     
     public static void getData(Box data){
         System.out.println("data :" + data.getData());
     }
19 
20 }

 

假设Box在逻辑上可以视为Box的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getData()方法取出数据时到底是什么类型呢？Integer? Float? 还是Number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上Box不能视为Box的父类。

好，那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总部能再定义一个新的函数吧。这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Box和Box的父类的一个引用类型，由此，类型通配符应运而生。

类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box在逻辑上是Box、Box...等所有Box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。

在代码//1处出现了错误提示信息：The method getData(Box) in the t ype GenericTest is not applicable for the arguments (Box)。显然，通过提示信息，我们知道Box在逻辑上不能视为Box的父类。那么，原因何在呢？

 

假设Box在逻辑上可以视为Box的父类，那么//1和//2处将不会有错误提示了，那么问题就出来了，通过getData()方法取出数据时到底是什么类型呢？Integer? Float? 还是Number？且由于在编程过程中的顺序不可控性，导致在必要的时候必须要进行类型判断，且进行强制类型转换。显然，这与泛型的理念矛盾，因此，在逻辑上Box不能视为Box的父类。

好，那我们回过头来继续看“类型通配符”中的第一个例子，我们知道其具体的错误提示的深层次原因了。那么如何解决呢？总部能再定义一个新的函数吧。这和Java中的多态理念显然是违背的，因此，我们需要一个在逻辑上可以用来表示同时是Box和Box的父类的一个引用类型，由此，类型通配符应运而生。

类型通配符一般是使用 ? 代替具体的类型实参。注意了，此处是类型实参，而不是类型形参！且Box在逻辑上是Box、Box...等所有Box<具体类型实参>的父类。由此，我们依然可以定义泛型方法，来完成此类需求。

 

public class GenericTest {
 
      public static void main(String[] args) {
  
          Box name = new Box("corn");
          Box age = new Box(712);
          Box number = new Box(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 name = new Box("corn");
          Box age = new Box(712);
          Box number = new Box(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 data){
         System.out.println("data :" + data.getData());
     }
 
 }

 

此时，显然，在代码//1处调用将出现错误提示，而//2 //3处调用正常。

类型通配符上限通过形如Box形式定义，相对应的，类型通配符下限为Box形式，其含义与类型通配符上限正好相反，在此不作过多阐述了。

 

另外

Java中没有所谓的泛型数组一说。

对于泛型，最主要的还是需要理解其背后的思想和目的。