Java泛型

普通泛型

class Point<T>{		// 此處可以隨便寫標識符號，T是type的簡稱
	private T var ;	// var的類型由T指定，即：由外部指定
	public T getVar(){	// 返回值的類型由外部決定
		return var ;
	}
	public void setVar(T var){	// 設置的類型也由外部決定
		this.var = var ;
	}
}
public class GenericsDemo06{
	public static void main(String args[]){
		Point<String> p = new Point<String>() ;	// 裏面的var類型爲String類型
		p.setVar("it") ;		// 設置字符串
		System.out.println(p.getVar().length()) ;	// 取得字符串的長度
	}
}
----------------------------------------------------------
class Notepad<K,V>{		// 此處指定了兩個泛型類型
	private K key ;		// 此變量的類型由外部決定
	private V value ;	// 此變量的類型由外部決定
	public K getKey(){
		return this.key ;
	}
	public V getValue(){
		return this.value ;
	}
	public void setKey(K key){
		this.key = key ;
	}
	public void setValue(V value){
		this.value = value ;
	}
}
public class GenericsDemo09{
	public static void main(String args[]){
		Notepad<String,Integer> t = null ;		// 定義兩個泛型類型的對象
		t = new Notepad<String,Integer>() ;		// 裏面的key爲String，value爲Integer
		t.setKey("湯姆") ;		// 設置第一個內容
		t.setValue(20) ;			// 設置第二個內容
		System.out.print("姓名；" + t.getKey()) ;		// 取得信息
		System.out.print("，年齡；" + t.getValue()) ;		// 取得信息

	}
}

 

通配符

class Info<T>{
	private T var ;		// 定義泛型變量
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
	public String toString(){	// 直接打印
		return this.var.toString() ;
	}
}public class GenericsDemo14{
	public static void main(String args[]){
		Info<String> i = new Info<String>() ;		// 使用String爲泛型類型
		i.setVar("it") ;							// 設置內容
		fun(i) ;
	}
	public static void fun(Info<?> temp){		// 可以接收任意的泛型對象
		System.out.println("內容：" + temp) ;
	}
}

受限泛型

class Info<T>{
	private T var ;		// 定義泛型變量
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
	public String toString(){	// 直接打印
		return this.var.toString() ;
	}
};
public class GenericsDemo17{
	public static void main(String args[]){
		Info<Integer> i1 = new Info<Integer>() ;		// 聲明Integer的泛型對象
		Info<Float> i2 = new Info<Float>() ;			// 聲明Float的泛型對象
		i1.setVar(30) ;									// 設置整數，自動裝箱
		i2.setVar(30.1f) ;								// 設置小數，自動裝箱
		fun(i1) ;
		fun(i2) ;
	}
	public static void fun(Info<? extends Number> temp){	// 只能接收Number及其Number的子類
		System.out.print(temp + "、") ;
	}
};
----------------------------------------------------------
class Info<T>{
	private T var ;		// 定義泛型變量
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
	public String toString(){	// 直接打印
		return this.var.toString() ;
	}
};
public class GenericsDemo21{
	public static void main(String args[]){
		Info<String> i1 = new Info<String>() ;		// 聲明String的泛型對象
		Info<Object> i2 = new Info<Object>() ;		// 聲明Object的泛型對象
		i1.setVar("hello") ;
		i2.setVar(new Object()) ;
		fun(i1) ;
		fun(i2) ;
	}
	public static void fun(Info<? super String> temp){	// 只能接收String或Object類型的泛型
		System.out.print(temp + "、") ;
	}
}

 

泛型無法向上轉型

class Info<T>{
	private T var ;		// 定義泛型變量
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
	public String toString(){	// 直接打印
		return this.var.toString() ;
	}
};
public class GenericsDemo23{
	public static void main(String args[]){
		Info<String> i1 = new Info<String>() ;		// 泛型類型爲String
		Info<Object> i2 = null ;
		i2 = i1 ;								//這句會出錯 incompatible types
	}
} 

泛型方法

class Demo{
	public <T> T fun(T t){			// 可以接收任意類型的數據
		return t ;					// 直接把參數返回
	}
};
public class GenericsDemo26{
	public static void main(String args[]){
		Demo d = new Demo()	;	// 實例化Demo對象
		String str = d.fun("湯姆") ; //	傳遞字符串
		int i = d.fun(30) ;		// 傳遞數字，自動裝箱
		System.out.println(str) ;	// 輸出內容
		System.out.println(i) ;		// 輸出內容
	}
} 

 泛型數組

public class GenericsDemo30{
	public static void main(String args[]){
		Integer i[] = fun1(1,2,3,4,5,6) ;	// 返回泛型數組
		fun2(i) ;
	}
	public static <T> T[] fun1(T...arg){	// 接收可變參數
		return arg ;			// 返回泛型數組
	}
	public static <T> void fun2(T param[]){	// 輸出
		System.out.print("接收泛型數組：") ;
		for(T t:param){
			System.out.print(t + "、") ;
		}
	}
}

 

泛型的嵌套設置

class Info<T,V>{		// 接收兩個泛型類型
	private T var ;
	private V value ;
	public Info(T var,V value){
		this.setVar(var) ;
		this.setValue(value) ;
	}
	public void setVar(T var){
		this.var = var ;
	}
	public void setValue(V value){
		this.value = value ;
	}
	public T getVar(){
		return this.var ;
	}
	public V getValue(){
		return this.value ;
	}
};
class Demo<S>{
	private S info ;
	public Demo(S info){
		this.setInfo(info) ;
	}
	public void setInfo(S info){
		this.info = info ;
	}
	public S getInfo(){
		return this.info ;
	}
};
public class GenericsDemo31{
	public static void main(String args[]){
		Demo<Info<String,Integer>> d = null ;		// 將Info作爲Demo的泛型類型
		Info<String,Integer> i = null ;	// Info指定兩個泛型類型
		i = new Info<String,Integer>("湯姆",30) ;	 // 實例化Info對象
		d = new Demo<Info<String,Integer>>(i) ;	// 在Demo類中設置Info類的對象
		System.out.println("內容一：" + d.getInfo().getVar()) ;
		System.out.println("內容二：" + d.getInfo().getValue()) ;
	}
}

轉載自：http://www.cnblogs.com/sunwei2012/archive/2010/10/08/1845938.html