Java泛型(2)泛型实参的限定

1.官方文档

https://docs.oracle.com/javase/tutorial/java/generics/bounded.html

2.作用

        有时候为减少不必要的转换和运行时错误发生。可以对泛型形参使用 extends X 语句，指定泛型实参必需为X及其子类，那么潜在的错误在编译时就可以发现。

• extends X 限定泛型实参为X及其子类型。好处是可以确定调用X的某些行为(函数)一定存在。
• 可以限定一个类类型，多个接口类型，它们之间用 & 相连。
• 类类型必需是第1个
• super 不能用在泛型形参声明时进行限制，如class MyNum<T super Integer>{}，super只能用在通配符中进行限制。
• 如有多个泛型形参，每个泛型形参都可以使用extends

3.泛型类中泛型形参 extends

3.1 简单示例

    interface I1{}
    interface I2{}
    interface I3{}
    interface I4 extends I2{}
    @Test
    public void bounded_test2(){
        class A {}
        abstract class B{}
        //class C <T extends Number & B >   {}  //error ： 只能有一个类类型 限定
        class D <T extends B & I1 & I2 & I3>{}  //ok
        class E <T extends I4 & I2>         {}  //ok    :  接口重复
        class F <T extends I1 , I2,无dfo3 > {}  //error :  编译通过，但是只限定了I1，多个限定类之间用“&”，其中“,”后面的字符无意义
        class G <T extends I1 , K extends A>{}  //ok    :  多个泛型形参时，可分别extends限定。
    }

3.1 使用extends限制的好处示例

public class NaturalNumber<T extends Integer> {
 
    private T n;
 
    public NaturalNumber(T n)  { this.n = n; }
 
    public boolean isEven() {
        return n.intValue() % 2 == 0;
    }
 
    // ...
}

T被限制为Integer后，那么第8行的 n.intValue() 调用一定存在。

3.3 extends 泛型类型 及 多类型限制

    @Test
    public void wildcards_test4(){
        class MyNumber extends Number implements Serializable,Comparable<MyNumber>{
            @Override public int compareTo(MyNumber o)  { return this.intValue() - o.intValue(); }
            @Override public int    intValue        ()  { return 0; }
            @Override public long   longValue       ()  { return 0; }
            @Override public float  floatValue      ()  { return 0; }
            @Override public double doubleValue     ()  { return 0; }
        }
        class MyInteger extends Number{
            @Override public int    intValue        () { return 0; }
            @Override public long   longValue       () { return 0; }
            @Override public float  floatValue      () { return 0; }
            @Override public double doubleValue     () { return 0; }
        }
        class MyByte  extends Number implements     Comparable{             //warning,raw type
            @Override public int    intValue        () { return 0; }
            @Override public long   longValue       () { return 0; }
            @Override public float  floatValue      () { return 0; }
            @Override public double doubleValue     () { return 0; }
 
            @Override public int compareTo(Object   o) { return 1; }        //这里意义，与Object比较
        }
        class MyFloat extends Number implements     Comparable<Float>{      //warning,raw type
            @Override public int    intValue        () { return 0; }
            @Override public long   longValue       () { return 0; }
            @Override public float  floatValue      () { return 0; }
            @Override public double doubleValue     () { return 0; }
 
            @Override public int compareTo(Float    o) { return floatValue() > o ? 1 : (floatValue() == 0 ? 0 : -1); }
        }
        //ArrayList<? extends Number & Serializable> ee;                //error
        class A  <T extends Number & Serializable & Comparable<?>> {}   //ok,
        class B  <T extends Number & Serializable & Comparable<T>> {}   //ok
        class C  <T extends Number & Serializable & Comparable   > {}   //warning,raw type
 
        A<MyNumber>     am = new A<>();
        //A<MyInteger>  ai = new A<>();                 //error,MyInteger不是Comparable<?>
        //A<MyByte>     ab = new A<>();                 //error,MyByte不是Comparable<?>
        A<MyFloat>      af = new A<>();
 
        //B<String>     bm = new B<>();                 //error String 不是number
        //B<MyInteger>  bi = new B<>();                 //error,MyInteger没有实现Comparable<MyInteger>
        //B<MyFloat>    bf = new B<>();                 //error,MyFloat没有实现Comparable<MyFloat>
        //B<MyByte>     bb = new B<>();                 //error,MyByte实现的是Comparable<MyByte>
        B<MyNumber>     bn = new B<>();                 //ok
 
        //C<MyInteger>  ci = new C<>();                 //error,MyInteger没有实现Comparable
        C<MyByte>       cb = new C<>();                 //ok
        C<MyNumber>     cn = new C<>();                 //ok
        C<MyFloat>      cf = new C<>();                 //ok
    }

4.泛型函数中泛型形参 extends

@Test
    public void bounded_test3(){
        class A implements Comparable<A> {
            private final int value;
            public A(int x){
                value = x;
            }
            public <T extends Number> void foo(T t){
                System.out.println("T = " + t.getClass().getSimpleName());
            }
            public <T extends Comparable<T>> int greaterThan(T []array,T x){
                int count = 0;
                for (T t : array){
                    /*if (t > x){                //error : 只有Number类型和基本类型可以使用 比较运算符
                        ++count;
                    }*/
                    if (t.compareTo(x) > 0){
                        ++count;
                    }
                }
                return count;
            }
 
            @Override
            public int compareTo(A o) {
                return this.value - o.value;
            }
            @Override
            public String toString() {
                return "A{" + value + '}';
            }
        }
        A obj = new A(2);
 
        obj.foo(1)             ;
        obj.<Float>foo(1f)     ;
        //obj.<A>foo(obj)      ;            //error : A 不是 Number的子类。
        //obj.foo("str");      ;            //error : "str" 不是 Number
 
 
        A [] array = new A[]{new A(1),new A(2),new A(3),new A(4)};
        int count = obj.greaterThan(array,obj);
 
        System.out.println(String.format("there are %d elements greater than %s",count,obj));
 
    }

其中

• 第11行的greaterThan泛型函数使用了extends语句，限制了泛型实参的类型为Comparable及子类，确保了 compareTo() 比较函数一定存在。
• 第14行编译时会出错，因为只有Number类型和基本类型可以使用 比较运算符。无法确保T一定是Number类型。

运行结果

T = Integer
T = Float
there are 2 elements greater than A{2}

5.泛型类之间的继承关系

5.1 泛型类型相同，泛型实参不同

泛型类型相同且泛型形参无通配符，泛型实参为继承关系时，它们组成的参数化类型(parameterized type)不为继承关系。

如，Box<Integer>与Box<Number>，Integer是Number的子类，但是Box<Integer>却不是的Box<Number>子类，但都是Object的子类。

示例代码如下：

    @Test
    public void test_inheritance1(){
        class A<T>              {}
        class B<T> extends A<T> {}
 
        Object     object;
        A<Number>  an = new A<>();
        B<Integer> bi = new B<>();
 
        //an    = bi;           //error,
        object  = an;           //ok
        object  = bi;           //ok
    }

5.2 泛型实参相同，泛型类型不同

泛型实参相同，继承关系由泛型类型决定。

如Collection<String>，List<String>，ArrayList<String>，泛型实参都是String，这时它们为继承关系。

示例代码如下：

    @Test
    public void test_inheritance2(){
        class A<T>              {}
        class B<T> extends A<T> {}
 
        Object     object;
        A<Number>  an = new A<>();
        B<Number>  bn = new B<>();
 
        an      = bn;           //ok
        object  = an;           //ok
        object  = bn;           //ok
    }

5.3 多个泛型参形与继承关系

当泛型类型有多个泛型形参时，泛型实参由声明时传给父泛型类型的泛型形参决定。继承关系如上两节.

在 class MyList<T,U> extends ArrayList<T> {} 中,这里声明把第1个泛型形参T传给ArrayList<T>.

详细示例如下:

    @Test
    public void test_inheritance3(){
 
        class MyList<T,U> extends ArrayList<T> {}
 
        MyList   <String,Number >   myList1 = new MyList<>();
        MyList   <String,Integer>   myList2 = new MyList<>();
        MyList   <Number,Integer>   myList3 = new MyList<>();
        ArrayList<String >          list1   = new ArrayList<>();
        ArrayList<Number >          list2   = new ArrayList<>();
        Object                      obj     ;
 
        list1   =  myList1   ;      //ok    , myList1与list1 的泛型实参都是String，因为MyList把第1个泛型实参传给ArrayList<T>
        list1   =  myList2   ;      //ok    , 泛型实参同是string，且ArrayList是MyList的父类
        list2   =  myList1   ;      //error , 泛型实参不同，泛型类型也不同。
        list2   =  myList3   ;      //ok    , 泛型实参同是Number，且ArrayList是MyList的父类
        myList1 =  myList2   ;      //error , 泛型类型相同，但是第2个泛型实参不同，虽然它们为继承关系.
        
        obj     =  list1     ;      //ok
        obj     =  list2     ;      //ok
        obj     =  myList1   ;      //ok
        obj     =  myList2   ;      //ok
        obj     =  myList3   ;      //ok
    }

6. super 不限制泛型形参

    @Test
    public void bounded_test4(){
        //class MyNum <T super Integer>{   }    //error : super 不在泛型声明时对泛型形参限制
        List<? super Number> ints           ;   //ok    : 与通配符一起使用，限制类型为Number的父类。
        ints = new ArrayList<Object>()      ;   //ok    : Object是 Number父类。
        //ints = new LinkedList<Integer>()  ;   //error : Integer 不是 Number父类
    }