Java编程思想 -- 泛型概括总结（一）

最新推荐文章于 2022-07-31 16:20:20 发布

Y_ZhiWen

最新推荐文章于 2022-07-31 16:20:20 发布

阅读量1k

点赞数 1

分类专栏： Java 文章标签： java 泛型

本文链接：https://blog.csdn.net/Y_ZhiWen/article/details/50413914

版权

Java 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

在面向对象编程语言中，多态算是一种泛化机制。

例如你可以将方法的参数类型设为基类，那么该方法就可以接受从这个类中导出的任何类作为参数。但是，考虑到除了final类不能扩展，这种灵活性大大降低。

如果方法的参数是一个接口，而不是一个类，这种限制就放松很多，可是有时候，使用了接口，对程序的约束也还是太强了。因为一旦指明了接口，它就要求你的代码必须使用特定的接口。

Java SE5的重大变化之一就是：泛型的概念。泛型实现了参数化类型的概念，使代码可以应用于多种类型。

简单泛型

直接看例子

public class Holder<T> {
    private T a;

    public Holder(T a) { this.a = a; }

    public void set(T a) { this.a = a; }

    public T get() { return a; }

    public static void main(String[] args) {
        Holder<String> holder = new Holder<String>("String");
        String s = holder.get();

        // Error
        // holder.set(1);
        // holder.set(1.1);
    }
}

在这个例子中可以看出，Holder是持有对象T的类（Holder< T>），在构造器，方法参数，成员变量以及返回值都可以使用对象T的类型。

class I<T> {

        class K<T>{

        }

        class KK{
            private T t;
        }

        // Error
        // public static class KKK<T>{ }

        // public static class KKK{
        //    private static T t;
        // }
}

这里可以看到，内部类可以持有对象T的类型，而嵌套类不可以。

泛型接口

直接看例子

public interface GenericsInstance<T> {
        T next();

        void set(T t);

        class InnerClass<T>{

        }

        public static T t;
}

这里可以看到，GenericsInstance是持有对象T的接口，在其返回值，方法参数，成员变量已经嵌套类都可以使用对象T的类型

泛型方法

可以在类中包含参数化方法，而这个方法所在的类可以是泛型类，也可以不是。

泛型方法使得该方法能够独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能做到，就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白

定义泛型方法，只需将泛型参数列表置于返回值之前

public class GenericMethods {

    // 泛型方法
    public <T> void f(T t){
        System.out.println(t.getClass().getName());
    }

    public static void main(String[] args){
        GenericMethods gm = new GenericMethods();

        gm.f("");
        gm.f(1);
        gm.f(1.2);      
    }
}

这个例子中，只有方法f()拥有类型参数T。

可以看下面例子

class T{

        public <T> T get(T t){
            T tt = null;

            return tt;
        }

        // 可变参数与泛型方法
        public static <E> void f(E... es){
            for (E e:es){
                // do something
            }
        }
}

注意，当在使用泛型类时，必须在创建对象的时候指定类型参数的值，而使用泛型方法的时候，通常不必指明参数类型，比如前面的gm.f(1);。因为编译器会为我们找出具体的类型。这称为类型参数推断

匿名内部类

泛型还可以应用于内部类以及匿名内部类

内部类前面例子已经简单描述，这里看一下匿名内部类的例子

public Interface Generator<T>{
    T next();
}

class Customer{
    private static long counter = 1;
    private final long id = counter++;

    private Customer() { }

    public String toString() { return "Customer " + id; }

    // 匿名内部类与泛型
    public static Generator<Customer> generator(){
        return new Generator<Customer>(){
            public Customer next(){
                return new Customer();
            }
        }
    }
}

擦除的神秘之处

例如，可以声明ArrayList.class，但是不能声明ArrayList< Integer>.class。

public class ErasedTypeEquivalence{
    public static void main(String[] args){
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();

        System.out.println(c1 == c2);
    }
}
/*Output:
true
*/

上面的c1和c2被认为相同的类型

在泛型代码内部，无法获得任何有关泛型参数类型的信息

Java泛型是使用擦除来实现的，这意味着当你在使用泛型时，任何具体类型信息都被擦除了，你唯一知道的就是你在使用一个对象。

因此，List< String>和List< Integer>在运行时事实上是相同类型，这两种形式都被擦除成为它们的“原生”类型List

下面看个例子：

public class HasF{
        public void f(){

        }
}

class Manipulator<T>{
    private T obj;
        public Manipulator(T t){
            this.obj = t;
        }

        public void manipulate(){
            // Error
            //obj.f();
        }
}

由于有了擦除，所以上面obj.f()方法不能调用。

为了调用f()，我们必须协助泛型类，给定泛型类的边界，这里使用extends关键字：

// 协助泛型类，给定泛型类的边界
class Manipulator<T extends HasF>{
        private T obj;
        public Manipulator(T t){
            this.obj = t;
        }

        public void manipulate(){
            obj.f();
        }
}

边界< T extends HasF>声明T必须具有类型HasF或者从HasF导出的类型。这样就可以安全调用f()

擦除的问题

擦除的代价是显著的。泛型不能用于显式地引用运行时类型的操作之中，例如转型、instanceof操作和new表达式

另外，使用泛型并不是强制的

class GenericBase<T>{
    private T element;
    public void set(T arg) { element = arg; }
    public T get() { return element; }
}

class Derived1<T> extends GenericBase<T> { }

class Derived2 extends GenericBase { } // No warning

// class Derived3 extends GenericBase<?> { } // Error
// class or interface without bounds

public class ErasureAndInheritance{

    @SuppressWarnings("unchecked")
    public static void main(String[] args){
        Derived2 d2 = new Derived2();
        Object obj = d2.get();
        d2.set(obj); // Warning here    
    }
}

边界处的动作

public class ArrayMaker<T> {

    private Class<T> kind;

    public ArrayMaker(Class<T> kind){
        this.kind = kind;
    }

    @SuppressWarnings("unchecked")
    T[] create(int size){
        // Type safety: Unchecked cast from Object to T[]
        return (T[]) Array.newInstance(kind, size);
    }

    public static void main(String[] args) {
        ArrayMaker<String> stringMaker = new ArrayMaker<String>(String.class);

        String[] stringArray = stringMaker.create(5);

        System.out.println(stringArray);
    }
}
/*Output:
[null, null, null, null, null]
*/

即使kind被存储为Class< T>，擦除也意味着它实际类型将被存储为Class，没有任何参数，因此，在创建数组时，这不会产生具体的结果，所以必须转型，这将产生一条警告。

注意，对于在泛型中创建数组，使用Array.newInstance()是推荐方式

泛型中的所有动作都发生在边界处——对传递进来的值进行额外的编译期检查，并插入对传递出去的值的转型

擦除的补偿

由于擦除，一下操作将无法操纵

public class Erased<T>{
    private final int SIZE = 10;
    public static void f(Object arg){

        if( arg instanceof T ){ } // Error
        T var = new T();// Error
        T[] array = new T[SIZE];// Error

        T[] array = (T) new Object[SIZE];// Warning
    }
}

通过引入类型标签对擦除进行补偿，这意味着需要显式地传递类型的Class对象，以便在表达式中使用，如果引入类型标签，就可以转而使用动态的isInstance()。

class Building { }
class House extends Building { } 

public static class ClassTypeCapture<T>{
    Class<T> kind;
    public ClassTypeCapture(Class<T> kind){
        this.kind = kind;
    }

    public boolean f(Object arg){
        return kind.isInstance(arg);
    }


    public static void main(String[] args) {

        ClassTypeCapture<Building> ctt1 = new ClassTypeCapture<Building>(Building.class);
        System.out.println(ctt1.f(new Building()));
        System.out.println(ctt1.f(new House()));

        ClassTypeCapture<House> ctt2 = new ClassTypeCapture<House>(House.class);
        System.out.println(ctt2.f(new Building()));
        System.out.println(ctt2.f(new House()));

    }
}
/*Output:
true
true
false
true
*/

创建类型实例

new T()无法实现，部分原因是因为擦除，另一部分原因是因为编译器不能验证T具有默认（无参）构造器，但是C++却可以实现，因为它是在编译期受到检查

Java中的解决方案是传递一个工厂对象

class ClassAsFactory<T>{
    T x;
    public ClassAsFactory(Class<T> kind){
        try{
            x = kind.newInstance();
        }catch(Exception e){
            throw new RuntimeException(e);
        }
    }
}

class Employee { }

public class InstantiateGenericType{
    public static void main(string[] args){
        ClassAsFactory<Employee> fe = new ClassAsFactory<Employee>(Employee.class);

        // Exception
        ClassAsFactory<Integer> fi = new ClassAsFactory<Integer>(Integer.class);
    }
}

第一个可以创建，但是ClassAsFactory<Integer>失败，因为Integer没有默认的构造器，而是应该使用显示工厂

interface Factory<T>{
    T create();
}

class Foo<T>{
    private T x;
    // 构造器：public <F extends Factory<T>> Foo(f factory) 
    public <F extends Factory<T>> Foo(f factory) { 
        x = factory.create();
    }
    // ...
}

class IntegerFactory implements Factory<Integer>{
    public Integer create(){
        return new Integer(0);
    }
}

class Widget{
    public static class Factory implements Factory<Widget>{
        public Widget create(){
            return new Widget();
        }
    }
}

public class FactoryConstraint{
    public static void main(String[] args){
        new Foo<Integer>(new IntegerFactory);
        new Foo<Widget>(new WidgetFactory);
    }
}

另一种方式是模板方法设计模式

abstract class GenericWithCreate<T>{
    final T element;
    GenericWithCreate() { element = create(); }
    abstract T create();
}

class X { }

class Creator extends GenericWithCreate<X>{
    X create() { return new X(); }
    void f(){
        System.out.println(element.getClass().getSimpleName());
    }
}

public class GreatorGeneric{
    public static void main(String[] args){
        Creator c = new Creator();
        c.f();
    }
}

泛型数组

看一下例子

class Generic<T> { }

public class ArrayOfGenericReference{
    // 泛型数组
    static Generic<Integer>[] gia;
}

编译器将接受这个程序，而不会产生警告，但是，永远都不能创建这个确切类型的数组（包括类型参数），这一点令人困惑。

既然所以数组无论它们持有的类型如何，都具有相同的结构，那么看起来应该能够创建一个Object数组，并将其转型为所希望的数组类型，事实上这可编译，但是不能运行：

publicclassArrayOfGeneric{
    static Generic<Integer>[] gia;
    public static void main(String[] args){
        // ClassCaseException
        // gia = (Generic<Integer>[])new Object[100];

        // 成功创建泛型数组
        gia = (Generic<Integer>[])new Generic[100];
        System.out.println(gia.getClass().getSimpleName());
        gia[0] = new Generic<Integer>();

        //gia[1] = new Object();
        //gia[2] = new Generic<Double>();
    }
}

成功创建泛型数组的唯一方式就是创建一个被擦除类型的新数组，然后对其转型
即：gia = (Generic<Integer>[])new Generic[100];

public class GenericArray<T>{
    private T[] array;

    @SuppressWarnings("unchecked")
    public GenericArray(int size){
        array = (T[])new Object[size];
    }

    public void put(int index, T item){
        array[index] = item;
    }

    public T get(int index){
        return array[index];
    }

    public T[] rep() { return array; }

    public static void main(String[] args){
        GenericArray<Integer> gai = new GenericArray<Integer>(10);

        // ClassCastException
        // Integer[] ia = gai.rep();

        Object[] oa = gai.rep();
    }
}

rep()方法返回T[]，并将结果作为Integer[]引用来捕获，会产生ClassCastException，这是因为实际运行时类型是Object[]。

因为有了擦除，数组的运行时类型就只能是Object[]，如果我们立即将其转型为T[]，那么在编译期该数组的实际类型就将丢失，而编译器可能错过某些潜在的错误检查。正因为这样，最好是在集合内部使用Object[]，然后当你使用数组元素时，添加一个对T的转型。这一点在集合框架的源码可以见到。

示例：

public class GenericArray<T>{
    private Object[] array;
    public GenericArray(int size){
        array = new Object[size];
    }

    @SuppressWarnings("unchecked")
    public T get(int index){ return (T)array[index]; }

    @SuppressWarnings("unchecked")
    public T[] rep(){
        return (T[])array;
    }

    public static void main(String[] args){
        GenericArray<Integer> gai = new GenericArray<Integer>(10);

        for(int i = 0; i < 10; i++)
            gai.put(i,i);

        for( int i = 0; i < 10; i ++)
            System.out.println(gai.get(i)+"");

        // ClassCastException
        // Integer[] ia = gai.rep();
    }
}

然而，如果你调用rep()，它还是尝试着将Object[]转型为T[]，这仍旧是不正确的，将在编译期产生警告，运行时产生异常。

public class GenericArrayWithTypeToken{
    private T[] array;

    @SuppressWarnings("unchecked")
    public GenericArrayWithTypeToken(Class<T> type, int sz){
        array = (T[]) Array.newInstance(type,sz);
    }

    public void put(int index, T item){
        array[index] = item;
    }

    public void get(int index) { return array[index]; }

    public T[] rep() { return array; }

    public static void main(String[] args){
        GenericArrayWithTypeToken<Integer> gai = new GenericArrayWithTypeToken<Integer>(Integer.class,10);

        // work
        Integer[] ia = gai.rep();
    }
}

通过传递类型标记Class<T>到构造器中，以便从擦除中恢复，使得我们可以创建需要的实际类型的数组。

边界

因为擦除移除了类型信息，所以可以用无界泛型参数调用的方法只是那些可以用Object调用的方法。但是如果能够将这个参数限制为某个类型子集，那么你就可以用这些类型子集来调用方法

interface HasColor { int getColor(); }

class Colored<T extends HasColor>{
    T item;
    Colored(T item){ this,item = item; }
    T getItem() { return item; }
    // 泛型边界
    int color() { return item.getColor(); }
}

class Dimension { public int x,y,z; }

//T extends Dimension & HasColor:类在前，接口在后
class ColoredDimension<T extends Dimension & HasColor>{
    T item;
    ColoredDimension(T item) { this.item = item; }

    T getItem() { return item; }
    // 泛型边界
    int color() { return item.getColor(); }
    int getX() { return item.x; }
    int getY() { return item.y; }
    int getZ() { return item.z; }
}

interface Weight { int weight(); }

//T extends Dimension & HasColor & Weight:类在前，接口在后
class Solid<T extends Dimension & HasColor & Weight>{
    T item;
    ColoredDimension(T item) { this.item = item; }

    T getItem() { return item; }
    // 泛型边界
    int color() { return item.getColor(); }
    int getX() { return item.x; }
    int getY() { return item.y; }
    int getZ() { return item.z; }
    int weight() { return item.weight(); }
}

class Bounded extends Dimension implements HasColor, Weight{
    public int getColor() { return null; }
    public int weight() { return 0; }
}

public class BasicBounds{
    public static void main(String[] args){
        Solid<Bounded> solid = new Solid<Bounded>(new Bounded());
        solid.color();
        solid.getY();
        solid.weight();
    }
}

可以看到使用<T extends Dimension & HasColor & Weight>实现多边界，而且类在前，接口在后。

更多层次的情况在书中。

通配符

通配符被限制为单一边界，所以List<? extends A & B>会报错

看一下例子：数组向导出类型的数组赋予基类型的数组引用

class Fruit{ }
class Apple extends Fruit{ }
class Jonathan extends Apple{ }
class Orange extends Fruit{ }

public class GovariantArrays{
    public static void main(String[] args){
        // 
        Fruit[] fruit = new Apple[10];
        fruit[0] = new Apple(); // OK
        fruit[1] = new Jonahan(); // OK

        //  编译器不会报错，运行期报错
        // fruit[0] = new Fruit(); // ArrayStoreException
        // fruit[1] = new Fruit(); // ArrayStoreException
    }
}

实际数组类型是Apple[]，应该只能放置Apple和Apple的子类型，这在编译期和运行时都可以工作。

但是编译器允许你将Fruit放置到这个数组中，因为它有一个Fruit[]引用，但是运行时数组机制知道它处理的是Apple[]，因此会抛出异常

泛型的主要目标之一就是将这种错误检测移入到编译期

因此使用泛型容器来代替数组

public class NonCovariantGenerics{
    // 编译错误
    List<Fruit> flist = new ArrayList<Apple>();
}

这里要明确一点：Apple的List不是Fruit的List，尽管Apple是一种Fruit类型

那怎么解决这问题呢？

这时候需要在两种类型之间建立某种类型的向上转型关系

public class GenericsAndCovariance{
    public static void main(String[] args){
        List<? extends Fruit> flist = new ArrayList<Apple>();

        // 编译错误
        flist.add(new Apple());
        flist.add(new Fruit());
        flist.add(new Object());

        // 可以运行
        flist.add(null);
        Fruit f = flist.get(0);
        flist.contains(new Apple()); // 参数类型是Object
        flist.indexOf(new Apple()); // 参数类型是Object
    }
}

flist类型现在是List<? extends Fruit>，可以将其读作“具有任何从Fruit继承的类型的列表”。但是，这实际上并不意味着这个List将持有任何类型的Fruit。

通配符引用的是明确的类型，因此它意味着“某种flist引用没有指定的具体类型”

因此当你指定一个ArrayList<? extends Fruit>时，add的参数也变成? extends Fruit。编译器不能了解这里需要Fruit哪个具体子类型，因此它不会接受任何类型的Fruit

但是，在使用contains和indexOf时，类型参数是Object，因此不涉及任何通配符，而编译器也将允许这个调用。这一点在ArrayList等源码可以看到

那应该怎么解决呢？？

另一条路：超类型通配符

这里，可以声明通配符是由某个特定类的任何基类来界定的，方法是指定<? super MyClass>，甚至或者使用类型参数：<? super T>（尽管你不能对泛型参数给出一个超类型边界；即不能声明<T super MyClass>）

因此：

public class SuperTypeWildcards{
    static void writeTo(List<? super Apple> apples){
        apples.add(new Apple());
        apples.add(new Jonathan());
        // apples.add(new Fruit()); // Error
    }
}

参数Apple是Apple的某种基类型的List，这样你就知道向其中添加Apple或Apple的子类型是安全的

超类型边界放松了在可以先方法传递的参数上所作的限制，再看一个例子：

public class GenericWriting{
    static List<Apple> apples = new ArrayList<Apple>();
    static List<Fruit> fruit = new ArrayList<Fruit>();

    static <T> void writeExact(List<T> list,T item){
        list.add(item);
    }

    static void f1(){
        writeExact(apples, new Apple());
        // Error
        // writeExact(fruit, new Apple());
    }

    static <T> void writeExactWildcard(List<? super T> list, T item){
        list.add(item);
    }

    static void f2(){
        writeExactWildcard(apples, new Apple());
        writeExactWildcard(fruit, new Apple()); // OK
    }

    public static void main(String[] args){
        f1();
        f2();
    }
}

继续一个例子：

public class GenericReading{
    static List<Apple> apples = new ArrayList<Apple>();
    static List<Fruit> fruit = new ArrayList<Fruit>();

    static <T> T readExact(List<T> list){
        return list.get(0);
    }

    static void f1(){
        Apple a = readExact(apples);
        Fruit f = readExact(fruit);
        f = readExact(apples);
    }

    // 通过泛型类读取
    static class Reader<T> { 
        T readExact(List<T> list) { reutrn list.get(0); }
    }

    static void f2(){
        Reader<Fruit> fruitReader = new Reader<Fruit>();
        Fruit f = fruitReader.readExact(fruit);
        // Error
        // Fruit f = fruitReader.readExact(apples);
    }

    // 改进
    static class CovariantReader<T>{
        T readCovariant(List<? extends T> list){
            return list.get(0);
        }
    }

    static void f3(){
        CovariantReader<Fruit> fruitReader = new CovariantReader<Fruit>();
        Fruit f = fruitReader.readExact(fruit);
        // OK
        Fruit a = fruitReader.readExact(apples);
    }

    public static void main(String[] args){
        f1(); f2(); f3();
    }
}

上面这例子说明，List<? extends T>列表中所有对象至少是一个T，并且可能是从T导出的某种对象

问题

实现参数化接口

一个类不能实现同一个泛型接口的两个变体，由于擦除的原因，这两个变体会成为相同的接口

interface Payable<T>{ }

class Employee implements Payable<Employee>{ }
class Hourly extends Employee implements Payable<Hourly>{ } // Error

Hourly不能编译，因为擦除会将Payable<Employee>和Payable<Hourly>简化为相同的类Payable，这样，上面的代码就意味着在重复两次实现相同的接口。

十分有趣的是，如果从Payable的两种用法都移除掉泛型参数（就像编译器在擦除阶段所作的那样），这段代码就可以编译。

重载

下面程序是不能编译的

public class UserList<W,T>{
    void f(List<T> v) {}
    void f(List<W> w) {}    
}

由于擦除的原因，重载方法将产生相同类型的签名

因此可以改成

public class UserList<W,T>{
    void f1(List<T> v) {}
    void f2(List<W> w) {}   
}

基类劫持了接口

class ComparablePet implements Comparable<ComparablePet>{
    public int compareTo(ComparablePet arg) { return 0; }
}

//Error
class Cat extends ComparablePet implements Comparable<Cat>{ }

class Hamster extends ComparablePet implements Comparable<ComparablePet>{
    public int compareTo(ComparablePet arg) { return 0; }
}