学步园

泛型的存在是为了规范数据的统一性而形成的，此在1.5之后才形成的。并且在泛型中，必须使用包装类来进行操作。

1、泛型的基本操作。

以下分别为对应Int与String的泛型来理解使用泛型的好处。

设定为INTger类

class Point<T>
{   private T var;
    public T getvar(){
	return var;}
	public void setvar(T var){
	this.var=var;
	}
}
public class demo10_1
{
	public static void main(String args[]){
	Point<Integer> a=new Point<Integer>(); //定义泛型为一个整数类型
	a.setvar(20);                //添加进Int类型的数字进去。
	System.out.println(a.getvar()+3);

	}
}

设定为String类。

class Info<T>
{
	private T var;
	public T getVar(){
		return var;
		}
		public void setVar(T var){
		this.var=var;
		}
		public String toString(){
		return this.var.toString();
		}
}
public class demo10_2
{   public static void main(String args[]){
    Info<String> k=new Info<String>();
	k.setVar("helad"); //接受String类型的对象进来。
	System.out.println(k);
}
}

可以看出在面对不同的数据类型时，泛型都能够很的提供支持。

2、泛型的引用传递

class Info<T>
{
	private T var;
	public T getVar(){
		return var;
		}
		public void setVar(T var){
		this.var=var;
		}
		public String toString(){
		return this.var.toString();
		}
}
public class demo10_3
{
	public static void main(String args[]){
	Info<String> i=new Info<String>();//注意泛型时一种方法，必须加上括号。
	i.setVar("1234"); //传递值进去
	fun(i);
	}
	public static void  fun(Info<?> temp){
	System.out.println("内容是"+temp);
	}
}

3、泛型的上限与下限。

在泛型中，我们可以设定其的范围上限或者下限。上限用extends来表示，只能够使用其的子类，Number类的话只能够接受数字，否则报错。劣质如下。

class Info<T>
{
	private T var;
	public T getVar(){
		return var;
		}
		public void setVar(T var){
		this.var=var;
		}
		public String toString(){
		return this.var.toString();
		}
}
public class demo10_3
{
	public static void main(String args[]){
	Info<Integer> i=new Info<Integer>();//注意泛型时一种方法，必须加上括号。
        Info<Float>  i1=new Info<Float>();
	i.setVar(1234);
         i1.setVar(12.4f) //传递值进去
	fun(i);
        fun(i1);
	}
	public static void  fun(Info<? extends Number> temp)//为泛型规定了上限只能接受Number的子类。
{
	System.out.println(temp+"、");
	}
}

而下限的代码类似。只不过范围是不同的。

class Info<T>
{
	private T var;
	public T getVar(){
		return var;
		}
		public void setVar(T var){
		this.var=var;
		}
		public String toString(){
		return this.var.toString();
		}
}
public class demo10_4
{
	public static void main(String args[]){
	Info<Object> i=new Info<Object>();//注意泛型时一种方法，必须加上括号。
        Info<String>  i1=new Info<String>();
	i.setVar(new Object());
         i1.setVar("abcf") //传递值进去
	fun(i);
        fun(i1);
	}
	public static void  fun(Info<? super String> temp)//为泛型规定了下限只能接受String及其父类Object。
{
	System.out.println(temp+"、");
	}
}

3、泛型的接口

泛型接口在Java的内裤中大量的使用，这样就可以接受不同的数据这一点在类集中的体现尤为明显。

下面来说明泛型接口的两种实现方式。

在要使用的时候才定义类型。

interface Info<T>
{
	public T getVar();
}
class Infoa<T> implements Info<T>
{
	private T var;
	public  Infoa(T var){
	   this.setVar(var);
	}
     public void setVar(T var){
	 this.var=var;
	 }
	 public T getVar(){
	 return this.var;
	 }
}
public class demo10_4
{
	public static void main(String args[]){
	Info<String> i=null;        //定义接口的对象。
	i=new Infoa<String>("asd");//子类实例化对象
      System.out.println("内容是"+i.getVar());
	}
}

另一种是在子类中把接口定义完毕。

interface Info<T>
{
	public T getVar();
}
class Infoa implements Info<String>
{
	private String var;
	public  Infoa(String var){
	   this.setVar(var);
	}
     public void setVar(String var){
	 this.var=var;
	 }
	 public String getVar(){  //在接口处定义好要接收的内容。
	 return this.var;
	 }
}
public class demo10_5
{
	public static void main(String args[]){
	Info<String> i=null;      
	i=new Infoa("fas1");
      System.out.println("内容是"+i.getVar());
	}
}

我们可以很明显的看出来，明显是第一种方法比较方便，模版设计模式的思想体现的很好，第二种泛型的使用范围也要更小，使用有一定的局限性。