限制泛型可用类型

限制泛型可用类型

　　在定义泛型类别时，预设可以使用任何的类型来实例化泛型类型中的类型。但是如果想限制使用泛型类别时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义类型时，使用extends关键字指定这个类型必须是继承某个类，或者实现某个接口，也可以是这个类或接口本身。

1.比如下面的例子：
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
public class ListGenericFoo<T extends List>
{
    private T[] fooArray;

    public T[] getFooArray()
    {
        return fooArray;
    }

    public void setFooArray(T[] fooArray)
    {
        this.fooArray = fooArray;
    }
    
    public static void main(String[] args)
    {
        ListGenericFoo<LinkedList> foo1 = new ListGenericFoo<LinkedList>();
        ListGenericFoo<ArrayList> foo2 = new ListGenericFoo<ArrayList>();
        
        //Error: Bound mismatch
        //ListGenericFoo<HashMap> foo3 = new ListGenericFoo<HashMap>();
        
        LinkedList[] linkedLists = new LinkedList[10];
        foo1.setFooArray(linkedLists);
        
        ArrayList[] arrayLists = new ArrayList[10];
        foo2.setFooArray(arrayLists);
        
    }

}
　　类声明中：public class ListGenericFoo<T extends List>
　　这样就规定了T必须是一个List继承体系中的类，即实现了List接口的类。
　　此处注意，虽然List是一个接口，但是关键字仍然是extends而不是implements。
　　并且这个List也可以后加括号指明类型，如List<String>等。
　　当没有指定泛型继承的类型或接口时，默认使用T extends Object，所以默认情况下任何类型都可以作为参数传入。
　　当不使用泛型时，比如那些声明时带有<T>的集合类型，如果使用时没有指定类型，泛型类别为Object。不会报错，但是会有警告。
　　<? extends SomeClass>是一个限界通配符（bounded wildcard），？代表了一个未知的类型，并且它是SomeClass的子类，也可以是SomeClass本身。
　　这里面SomeClass是统配符的上界（upper bound of the wildcard）。
　　相应的也有限定下界的，使用关键字super。
　　通配符所代表的其实是一组类型，但具体的类型是未知的。

2.类型通配声明

   　GenericFoo<Integer> foo1 = null;
       GenericFoo<Boolean> foo2 = null;
     //此时foo1只能接受GenericFoo<Integer>类型的实例，foo2只能接受GenericFoo<Boolean>类型的实例
　 如果希望有一个变量foo可以指向下面所有的实例：
      //foo = new GenericFoo<ArrayList>();
      //foo = new GenericFoo<LinkedList>();
　　可以这样声明:
    GenericFoo<? extends List> foo = null;
    foo = new GenericFoo<ArrayList>();
    foo = new GenericFoo<LinkedList>();
　　注意这种形式不同于前面的限制泛型可用类型时提到的形式。
　　前面提到的形式是在声明泛型的类的时候限制了可以用的泛型类型，而现在这种形式是在使用的时候限制了引用的类型，使得引用指向继承了某一个类或接口的类型。
　　如果该应用指向其他类型，则会编译报错：
    //Error:Type mismatch
    foo = new GenericFoo<HashMap>();
　　也可以限制引用指向某个类或接口的继承层次之上的类或接口：
　　比如：        
    //引用指向继承层次之上
   GenericFoo<? super List> ge= null;
   ge = new GenericFoo<Object>();
　　使用<?>或是<? extends SomeClass>的声明方式，意味着您只能通过该名称来取得所参考的实例的信息，或者是移除某些信息，但不能增加或者改写它的信息。
　　因为只知道当中放置的是SomeClass的子类，但不确定是什么类的实例，编译器不让您加入信息，理由是，如果可以加入信息的话，那么您就得记得取回的是什么类型的实例，然后转换为原来的类型方可进行操作，这样就失去了使用泛型的意义。
　　另，GenericFoo<? extends Object>等价于GenericFoo<?>，但是它们与GenericFoo<Object>不同，因为GenericFoo<Object>限定了类型为Object。
 JAVA 泛型与通配符的使用
      泛型的本质是参数化类型。即所操作的数据类型被指定为一个参数。
      1.jdk 1.5/1.6 必须显式的写出泛型的类型。
      2.jdk 1.7/1.8 不必显式的写出泛型的类型。

一、泛型声明

      可以用<T>、<K,V>、<T  extends  Number>等进行泛型的声明。其中，<T  extends  Number>的声明方式限定了T的范围，T只能为 Number的子类。
      1.参数类型用在类的创建中，泛型类。
      2.参数类型用在接口的创建中，泛型接口。
      3.参数类型用在方法的创建中，泛型方法。注意泛型<T>的声明位置，在方法的修饰符之后，返回值类型之前。
package me;
public class GeneTest<T> {
    private T date;
    public T getDate() {
        return date;
    }
    public void setDate(T date) {
        this.date = date;
    }

}
package me;
public interface InteGene<E> {
    public E getData();

    public void setData(E e);

}

package me;
public class MeGeneTest {
    public static <T> void Gene(T test) {
        System.out.println(test);
    }
    public <T> T getDate(T test) {
        return test;
    }

}

二、? ，类型通配符

      通配符的几种形式：
      1.无限定通配符，<?>。
      2.上限通配符,<?  extends  Number>。表示参数类型只能是Number的子类。
      3.下限通配符，<?  supper Number>。表示参数类型只能是Number的父类。
package me;
public class Test {
    public static void main(String[] args) {
 
        GeneTest<String> gts = new GeneTest<>();
        gts.setDate("this is a test !");
        print(gts);
        
        GeneTest<Integer> gti = new GeneTest<>();
        gti.setDate(123);
        print(gti);
    }
    
    public static void print(GeneTest<?> s){
        
        System.out.println(s.getDate());
    }

}
      上面的示例代码中，print()方法的参数使用了通配符，得以传入泛型类GeneTest<T>任意类型的参数。如果，将通配符改成具体的一种类型，例如String类型。那print()方法就只能传入泛型类GeneTest<String>类型的参数。
      泛型的声明表明，在类、接口、方法的创建中，要使用一个未知的数据类型，将来可能会用到的一种数据类型。它可以是Integer类型，也可以是String类型。就把它的类型定义成 T 、K 或者是V等等。
      在实例化的时候，就必须声明T具体是一个什么类型。
      在定义泛型对象的使用方法时，还不知道T是什么类型，它可能是String类型，也可能是Integer类型。如果，把T定义成一个确定的泛型数据类型，参数就只能是这种数据类型。此时，就用到了通配符代替确定的泛型数据类型。
      使用泛型、通配符提高了代码的复用性。
      把一个对象分为声明、使用两部分的话。泛型侧重于类型的声明上代码复用，通配符则侧重于使用上的代码复用。泛型用于定义内部数据类型的不确定性，通配符则用于定义使用的对象类型不确定性。