5、Java泛型

1. 泛型的基本应用

泛型可以解决数据类型的安全性问题，其主要原理是在类声明时通过一个标识表表示类中某个属性的类型或者某个方法的返回值及参数类型。这样在类声明或者实例化时只要制定好需要的具体的类型即可。

class Notepad<K,V>{
    private K key;
    private V value;
    public K getKey(){
      return key;
    }
    public void setKey(K key){
       this.key=key;
    }
     public V getValue(){
      return key;
    }
    public void setKey(V value){
       this.value=value;
    }

}

2. 泛型的安全警告

在泛型应用中最好在声明类对象时指定好其内部的数据结构，如Info，如果不指定类型，这样用户使用这样的类是，就会出现不安全操作的警告信息。

3. 通配符

以上程序中在操作时都设置了一个固定的类型，在泛型操作中也可以通过通配符接收任意指定泛型类型的对象。

• Java中引入了通配符“？”,表示可以接收此类型的任意泛型对象：

public class GenericsDemo{
  public static void main(String[] args){
   Info<String> i=new Info<String>();
   i.setValue("Winson");
   fun(i);
  }
  public static void fun(Info<?> temp){//此处可以接收Info的对象
     System.out.println("内容："+temp);
  }
}

• 受限泛型

在引用传递中，在泛型操作中也可以设置一个泛型对象的范围上限和范围下限。范围上限使用extends关键字声明，表示泛型的类型可能是指所指定的类型或者此类型的子类，而范围下限使用super进行声明，表示泛型的类型可能是所指定的类型，或者此类型的父类型，或是Object类。具体如下所示：

泛型上限

public class GenericsDemo{
  public static void main(String[] args){
    Info<Integer> i1=new Info<Integer>();
    Info<Float> i2=new Info<Float>();
    i1.setVar(30);
    i2.serVar(30.1f);
    fun(i1);
    fun(i2);
  }
  //接收info对象，范围上限设置为Number，所以只能接收数字类型
  public static void fun(Info<? extends Number>temp){
    System.out.println(tmp+",");
  }
}

范围下限

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 GenericsDemo{
  public static void main(String[] args){
    Info<Object> i1=new Info<Object>();
    Info<String> i2=new Info<String>();
    i1.setVar(new Object());
    i2.serVar("Winson");
    fun(i1);
    fun(i2);
  }
  //只能接收String或者Object类型的泛型   下限
  public static void fun(Info<? super String>temp){
    System.out.println(tmp+",");
  }
}

4. 泛型接口

在接口上声明泛型，声明格式与之前类型。

泛型接口定义完成之后，就要定义此接口的子类，定义泛型接口的子类有两种方式，一种是直接在子类后声明泛型，另一种是直接在子类实现的接口中明确给出泛型类型。

1. 在子类的定义上声明泛型类型：

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 GernericsDemo{
   public static void main(String[] args){
     Info<String> i=null; //定义接口对象
     i=new InfoImpl<String>("Winson");//通过子类实例化此对象
     System.out.println("内容："+i.getVar());
   }
}

1. 直接在接口中指定具体类型：

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 GenericsDemo{
  public static void main(String args[]){
    Info<String> i=null; //定义接口对象，指定泛型
    i=new InfoImpl("Winson");//通过子类实例化此对象，不用指定泛型
    System.out.println("内容："+i.getVar());
  }
}

5. 泛型方法

class Demo{
  public <T> T fun(T t){
    return t;
  }
}
public class GenericsDemo{
  public static void main(String[] args){
    Demo d=new Demo();
    String str=d.fun("Winson");
    int i=d.fun(20);
  }
}