关于泛型你要知道的二三事[2]

书接上文。
上文地址：https://www.jianshu.com/p/d13ed2b58c8a
本内容均属原创，转载请注明出处：
https://www.jianshu.com/p/4f9b47e44b0e
本次主要解释清楚泛型的分类，以及jdk1.7中的一些对于泛型的增强以及坑。

泛型分类

接下来我会通过四个方向依次详细说明泛型在不同情境下定义要遵守的一些规则。

泛型类：

定义普通泛型类

public class Test01 {
    public static void main(String[] args) {
        //create generic type Gen instance and assign
        //generic type of Gen is Integer
        //it`s use of autoboxing to encapsulate 
        //the value 12 within an Integer Object
        Gen g1 = new Gen();
        g1.t = 12;
        g1.getT();
        //jdk1.7  enhancement type inference 
        Gen g2 = new Gen<>();
        g2.t = "hello";
        g2.getT();
        //create generic type Gen instance and 
        //don`t assign generic type
        Gen g3 = new Gen();
        g3.t = new Date();
        g3.getT();
    }
}
//declared a generic type Gen
class Gen{
    T t;
    public void getT(){
        System.out.println(t.getClass().getName());
    }
}

在这里说明了一个Generic类->Gen,泛型类型是T，我们上文提到过，泛型就是一个类型，那么这里的T你不防理解为一个类型。并且为了获取T类型方便一些，我们将T类型也声明为了一个成员变量。我们在代码中通过getT()方法获取成员变量T的Class对象的名称。其次我们在测试类创建了3个Gen的对象。
在第一个用例中：创建对象时指定类型为Integer，且通过给对象中的T类型赋值为12。我们发现获取到的Class对象的名称为Integer。
第二个用例中：创建对象时指定类型为String，且这里我们在对象创建中只通过<>，而没有在括号中给具体的类型，这是jdk1.7中的增强类型推断，因为已经声明过时String类型,所以会自动推断出Gen对象的T类型是String。同样这里获取到的Class对象名称为String。
第三个用例中：创建对象时没有指定泛型类型，我们这里直接赋值发型可以给T传入任何Object类型。其实这就是典型的擦除。我们后续分享会逐一解开这个面纱。这里获取到的泛型的name成为了Object。

总结：在一个类声明时通过会指定泛型类型。创建对象时可以在<>指定具体的泛型类型。
如果不指定则经过擦除之后，类型变为Object。我们可以将g1Gen和g2
理解为一个Gen类的一个特殊子类。这个子类是不存在。(注意只是这样理解，方便我们后续
理解类型擦除)。

注意：创建泛型类型对象时，构造器的类名还是原来的类名。不需要增加泛型声明。不需要写为Gen。

泛型类中的继承

我们通过以下几个小例子阐述，在创建泛型子类时的编写问题：

class Gen{
    T t;
    public void getT(){
        System.out.println(t.getClass().getName());
    }
}
//declared a subclass for Gen
//subclass don`t define generic tyoes,  allow the definition of declared
class SubGen1 extends Gen{}
//allows subclass to specify the superclass specific generic type
class SubGen2 extends Gen{}
//don`t allows superclass definition generic type 
class SubGen3 extends Gen{}//compile-time error

总结：
1、定义子类继承泛型类，不做任何泛型方法，那么创建子类对象时泛型类中的类型自动转为Object
2、定义子类继承泛型类，在父类中指定具体泛型类型，那么创建子类对象时泛型类中的类型为指定类型
3、定义子类继承泛型类，在父类中指定不具体的泛型类型，那么是不允许的。

泛型接口：

//define generic interface
interface List extends Iterator{
    void add(E e);
    Iterator iterator();
}
//define generic interface
interface Iterator{
    E next();
    boolean hasNext();
} 
//define subclass for interface
class MyList implements List {
    @Override
    public String next() {return null;}
    @Override
    public boolean hasNext() {return false;}
    @Override
    public void add(String e) {}
    @Override
    public Iterator iterator() {return null;}
    //test generic interface
    public static void main(String[] args) {
        MyList ls = new MyList();
        ls.add("hehe");//execute add method can only add Stirng type 
    }
}

结论：
1、定义泛型接口时，实现类如果声明时指定了泛型类型，那么后续调用时，在编译阶段只能使用该类型。
2、如果定义泛型接口时，实现类不指定接口的泛型类型，那么会报警告。
   List is a raw type. References to generic type List should be parameterized。
   说明当前泛型接口是一个 raw type.最好指定泛型是参数化的。
    而且对于后续程序来讲这样也是不太可取的。

包含泛型的类型，不论是类、子类、实现类、对象。我们其实在理解层面上都可以认为是当前类、实现类的一个逻辑子类。比如Gen可以理解为一个Gen