1、匹配任意的通配符

在开发中对象的引用传递是最常见的，如果在泛型类的操作中，在进行引用传递的时候泛型类型必须匹配才可以传递，否则是无法传递的。

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 GenericsDemo12{
	public static void main(String args[]){
		Info<String> i = new Info<String>() ;		// 使用String为泛型类型
		i.setVar("MLDN") ;							// 设置内容
		fun(i) ;
	}
	public static void fun(Info<Object> temp){		// 接收Object泛型类型的Info对象
		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 GenericsDemo13{
	public static void main(String args[]){
		Info<String> i = new Info<String>() ;		// 使用String为泛型类型
		i.setVar("MLDN") ;							// 设置内容
		fun(i) ;
	}
	public static void fun(Info temp){		// 接收Object泛型类型的Info对象
		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 GenericsDemo14{
	public static void main(String args[]){
		Info<String> i = new Info<String>() ;		// 使用String为泛型类型
		i.setVar("MLDN") ;							// 设置内容
		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 GenericsDemo15{
	public static void main(String args[]){
		Info<?> i = new Info<String>() ;		// 使用String为泛型类型
		i.setVar("MLDN") ;							// 设置内容
	}
};

编译时错误：

2、受限泛型

2.1设置上限

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 GenericsDemo18{
	public static void main(String args[]){
		Info<String> i1 = new Info<String>() ;		// 声明String的泛型对象
		i1.setVar("hello") ;
		fun(i1) ;
	}
	public static void fun(Info<? extends Number> temp){	// 只能接收Number及其Number的子类
		System.out.print(temp + "、") ;
	}
};

在类中使用：

class Info<T extends Number>{	// 此处泛型只能是数字类型
	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 GenericsDemo19{
	public static void main(String args[]){
		Info<Integer> i1 = new Info<Integer>() ;		// 声明Integer的泛型对象
	}
};

如果现在在使用Info的时候设置成了String类型，则在编译的时候将出现错误：

class Info<T extends Number>{	// 此处泛型只能是数字类型
	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 GenericsDemo20{
	public static void main(String args[]){
		Info<String> i1 = new Info<String>() ;		// 声明Integer的泛型对象
	}
};

2.2设置下限

当使用的泛型只能在本类及其父类类型上应用的时候，可以使用泛型的范围下限配置。

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

如果现在使用Integer作为泛型的类型，不能满足泛型下限。编译会出错：

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 GenericsDemo22{
	public static void main(String args[]){
		Info<Integer> i1 = new Info<Integer>() ;		// 声明Integer的泛型对象
		i1.setVar(30) ;
		fun(i1) ;
	}
	public static void fun(Info<? super String> temp){	// 只能接收String或Object类型的泛型
		System.out.print(temp + "、") ;
	}
};

3、泛型与子类继承的限制

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 ;
	}
};