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 + "、") ;
	}
};

泛型接口

interface Info<T>{		// 在接口上定义泛型
	public T getVar() ;	// 定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl<T> implements Info<T>{	// 定义泛型接口的子类
	private T var ;				// 定义属性
	public InfoImpl(T var){		// 通过构造方法设置属性内容
		this.setVar(var) ;	
	}
	public void setVar(T var){
		this.var = var ;
	}
	public T getVar(){
		return this.var ;
	}
};
public class GenericsDemo24{
	public static void main(String arsg[]){
		Info<String> i = null;		// 声明接口对象
		i = new InfoImpl<String>("汤姆") ;	// 通过子类实例化对象
		System.out.println("内容：" + i.getVar()) ;
	}
};
----------------------------------------------------------
interface Info<T>{		// 在接口上定义泛型
	public T getVar() ;	// 定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl implements Info<String>{	// 定义泛型接口的子类
	private String var ;				// 定义属性
	public InfoImpl(String var){		// 通过构造方法设置属性内容
		this.setVar(var) ;	
	}
	public void setVar(String var){
		this.var = var ;
	}
	public String getVar(){
		return this.var ;
	}
};
public class GenericsDemo25{
	public static void main(String arsg[]){
		Info i = null;		// 声明接口对象
		i = new InfoImpl("汤姆") ;	// 通过子类实例化对象
		System.out.println("内容：" + i.getVar()) ;
	}
};