Java编程思想__泛型(三)

• 下面是使用模板的C++示例, 你将注意到用于参数化类型的语法十分相似,因为Java是受C++的启发。

template class Manipulator{
    T obj;
 public:
    Manipulator(T x){ obj=x; }
    void maniput(){ obj.f(); }       
}

class HasF{
    public:
        void f(){
        cout << "HasF::f()" << endl;
    }
    
    int main(){
        HasF hf;
        Manipulator manipulator(hf);
        manipulator.maniput();
    }
}

1.  Manipulator 类存储了一个 T 的对象,有意思的地方是 manipulator() 方法,它在调用 obj 上调用方法 f()。它怎么能知道 f() 方法是为类型参数 T 而存在的呢?当你实例化这个模板时,C++编译器将进行检查,因此在 Manipulator 被实例化的这一刻,它看到 HasF拥有一个方法 f() 。如果情况并非如此,就回到得到一个编译期错误,这样类型安全就得到了保障。
2. C++ 编写这种代码很简单,因为当模板被实例化时,模板代码知道其模板参数的类型。Java泛型就不同了。如下 Java版本 HasF

class HasF{
    void f(){
        System.out.println("HasF f()");
    }
}

public class Manipulator{
    private T t;

    public Manipulator(T t) {
        this.t = t;
    }
    public void manipultor(){
        //error: 找不到符号方法f（）
        t.f();
    }

    public static void main(String[] args) {
        HasF hasF = new HasF();
        Manipulator hasFManipulator = new Manipulator(hasF);
        hasFManipulator.manipultor();
    }
}

1. 由于有了擦除,Java编译器无法将 manupulator() 必须能够在 t 上调用f() 这一需求映射到 HasF 拥有 f() 这一事实上。
2. 为了调用 f() ,我们必须协助泛型类,给定泛型类的边界,以告知编译器只能接受遵循这个边界的类型。这里冲用了 extends 关键字。 由于有了边界,西面代码就可以编译了。

public class Manipulator2{
    private T t;

    public Manipulator(T t) {
        this.t = t;
    }
    public void manipultor(){
        t.f();
    }
}

1. 边界 声明 T 必须具有类型 HasF 或者从 HasF 导出的类型。如果情况确实如此,那么就可以安全地在 obj上调用 f()。
2. 我们说泛型类型参数将擦除到它的第一个边界(它可能会有多个边界,稍后你就会看到),我们还提到了类型参数的擦除。编译器实际上会把类型参数替换为它的擦除,就像上面的示例一样。T 擦除到了 HasF,就好像在类的声明中用 HasF 替换了T一样。
3. 你可能已经正确地观察到 ,在Manipulator2类中,泛型没有贡献任何好处。只需很容易地自己去执行擦除,就可以创建出没有泛型的类:

public class Manipulator3{
    private HasF hasF;

    public Manipulator3(HasF hasF) {
        this.hasF = hasF;
    }
    public void manipultor() {
        hasF.f();
    }
}

1. 这提出可很重要的一点: 只有当你希望使用的类型参数比某个具体类型(以及它的所有子类型) 更加 泛化 时___也就是说,当你希望代码能够跨多个类工作时,使用泛型才有所帮助。
2. 因此,类型参数和它们在有用的泛型代码中的应用,通常比简单的类替换要更复杂。但是,不能因此而认为 形式是有所缺陷的。
3. 例如,如果某个类有一个返回T 的方法,那么泛型就有所帮助,因为它们之后将返回准确的类型:

class ReturnGenericType{
    private T t;

    public ReturnGenericType(T t) {
        this.t = t;
    }
    public T getT(){
        return t;
    }
}

1. 必须查看所有的代码,并确定它是否 足够复杂 到必须使用泛型的程序。

 

迁移兼容性

• 为了减少潜在的关于擦除的混淆,你必须清除地认识到这不是一个语言特性。它是Java 的泛型实现中的一个折中,因为泛型不是Java语言出现时就有的组成部分,所以这种折中是必须的。这种折中会让你痛苦,因为你需要习惯它并了解为什么它会是这样。
• 如果泛型在Java1.0中就已经是其一部分了,那么这个特性将不会擦除来实现___它将使用具体化,使用类型参数保持为第一类实体,因此你就能够在类型参数上执行基于类型语言操作和反射操作。你将在本章稍后看到,擦除减少了泛型的泛化性。泛型在Java中仍旧是有用的,只是不如它们设想的那么有用,而原因就是擦除。
• 在基于擦除的实现中,泛型类型被当做第二类类型处理,即不能再某些重要的上下文环境中使用的类型。泛型类型只有在静态类型检查期间才出现,在此之后,程序中的所有泛型类型都将被擦除,替换为它们的非泛型上界。例如 List 这样的类型注解将被擦除为 List, 而普通的类型变量在未指定边界的情况下将被擦除为 Object。
• 擦除的核心动机是它使得泛化的客户端可以用非泛化的类库来使用,反之亦然,这经常被称为 迁移兼容性。在理想状态下,当所有事物都可以同时被泛化时,我们就可以专注于此。在现实中,即使程序员只编写泛型代码,他们也必须处理在Java SE5之前编写的非泛型类库。那些类库的作者可能从没有想过要泛化它们的代码,或者可能刚刚开始接触泛型。
• 因此Java泛型不仅必须支持向后兼容性,即现有的代码和类文件仍旧合法,并且继续保持其之前的含义。而且还要支持迁移兼容性,使得类库按照他们自己的步调变为泛型的,并且当某个类库变为泛型时,不会破坏依赖于它的代码和应用程序。在决定这就是目标之后,Java设计者们和从事此问题相关工作的各个团队决策认为擦除是唯一可行的解决方案。通过允许非泛型代码与泛型代码共存,擦除使得这种向着泛型的迁移称为可能。
• 例如, 假设某个应用程序具有两个类库 X 和 Y,并且 Y 还要使用类库 Z。随着JavaSE5 的出现,这个应用程序和这些类库的创建者最终可能希望迁移到泛型上。但是,当进行这种迁移时,他们有着不同动机和限制。为了实现迁移兼容性,每个类库和应用程序都必须与其他所有的部分是否使用了泛型无关。这样,它们必须不具备探测其他类库是否使用了泛型的能力。因此,某个特定的类库使用了泛型这样的证据必须被擦除。
• 如果没有某种类型的迁移途径,所有已经构建了很长时间的类库就需要与希望迁移到Java泛型上的开发者说再见了。但是,类库是编程语言无可争议的一部分,它们对生成效率会产生最重要的影响,因此这不是一种可以接受的代价。擦除是否是最佳的或者唯一的迁移途径,还需要时间来证明。

 

擦除的问题

• 因此,擦除主要的正当理由是从非泛型代码到泛型代码的转变过程,以及在不破坏现有类库的情况下,将泛型融入Java语言。

• 擦除使得现有的非泛型客户端代码能够在不改变的情况下继续使用,直至客户端准备好使用泛型重写这些代码。这是一个崇高的动机,因为它不会突然间破坏所有现有的代码。

• 擦除的代价是显著的。泛型不能用于显式地引用运行时类型的操作之中,例如转型, instanceof 操作和new表达式。因为所有关于参数的类型信息都丢失了,无论何时,当你在编写泛型代码时,必须时刻提醒自己,你只是看起来好像拥有有关参数的类型信息而已。

• 因此,如果你便携了下面这样的代码段:

class Foo{
    T var;
}

1. 那么,看起来当你在创建Foo 的实例时:

Foo f=new Foo();

1. class Foo 中的代码应该知道现在工作于Cat之上,而泛型语法也在强烈暗示: 在整个类中的各个地方,类型 T 都在被替换。但事实并非如此,无论何时,当你在编写这个类代码时,必须提醒自己:  不 ,它只是一个 Object。
2. Java 中的泛型基本都是在编译器这个层次来实现的,在生成的 Java 字节码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数,会在编译器的时候去掉。这个过程就称为 类型擦除。

public class ArrayList1{
    
    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add("str");
        List integers = new ArrayList<>();
        integers.add(123);

        System.out.println(list.getClass());
        System.out.println(integers.getClass());
        System.out.println(integers.getClass() == list.getClass());
    }
}

//运行结果为
true

 

1. 我们定义两个ArrayList数组 ,不过一个是 List 泛型类型,只能保存字符串 ,一个是List 类型,只能保存 整型。
2. 我们通过 list 和 integers 对象的getClass() 获取它们的类的信息,最后结果发现为 true。说明了泛型类型 String 和Integer 都被擦除掉了,只剩下原始类型。

class ArrayList2{
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        List list=new ArrayList<>();
        list.add(1);
        //利用反射进行添加数据asd
        list.getClass().getMethod("add",Object.class).invoke(list,"asd");

        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

//运行结果为
1
asd

1. 在程序中定义一个 List 的集合,如果直接调用 add方法,那么只能存储 整型数值。
2. 不过我们利用反射调用 add 方法的时候,却可以存储字符串。这就说明了 Integer 泛型实例在编译之后就被擦除了,只保留了原始类型。

 

类型擦除后保留的原始类型

• 原始类型(raw type) : 擦除了泛型信息,最后在字节码中的类型变量的真正类型。
• 无论何时定义一个泛型,相应的原始类型都会被自动地提供。类型变量被擦除,并使用其限定类型(无限的变量用Object)替换。

class Person{

    private T t;

    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

//原始类型为

class Person{

    private Object object;

    public Object getObject() {
        return object;
    }

    public void setT(Object object) {
        this.object = object;
    }
}

• 在 Person 中,T 是一个无限定的类型变量,所以用 Object 替换。其结果就是一个普通的类,如同泛型加入 Java 编程语言之前已经实现的那样。
• 在程序中可以包含不同类型的 Person,(Person , Person) 但是擦除类型后它们就成为原始的 Person类型了,原始类型都是Object。
• 如果类型变量有限,那么原始类型就用第一个边界的类型变量来替换。例如

class ArrayList3{
    //...
}

1. 那么原始类型就不是 Object 而是 ArrayList2。
2. 注意: 如果 ArrayList 这样声明 class ArrayList ,那么原始类型就用 Serializable 替换, 而编译器在必要的时要向 ArrayList2 插入强制类型转换。为了提高效率,应该将标签接口放在边界限定列表的末尾。

 

要区分原始类型和泛型类型变量的类型

• 在调用泛型方法的时候,我们可以指定泛型,也可以不指定泛型。
• 在不指定泛型的情况下,泛型变量的类型为该方法中的几种参数变量类型的同一个父级的最小级,直到 Object。
• 在指定泛型的时候,该方法中的几种类型必须是该泛型实例类型或者其子类。

class ArrayList4{

    //这是一个简单的泛型方法
    static  T add(T t,T k){
        return k;
    }

    public static void main(String[] args) {
        //不指定泛型的时候

        //两个Integer 所以T为 Integer
        Integer add = ArrayList4.add(1, 2);
        //一个Integer 一个Double T取同一父级最小级 Number
        Number number = ArrayList4.add(1, 1.2);
        //一个Integer 一格String T取同一父级为 Serializable
        Serializable ask = ArrayList4.add(1, "ask");

        //指定泛型的时候

        //指定了Integer 所以只能为 Integer 类型 或其子类 当你传入 Double 是就会编译出错
        Integer add1 = ArrayList4.add(1, 2);
        //指定为 Number 所以可以为 Integer 和Double
        Number number1 = ArrayList4.add(1, 2.2);
    }
}

1. 其实在泛型类中,不指定泛型的时候,也差不多,只不过这个时候类型为 Object。比如ArrayList 中如果不指定泛型类型,那么这个ArrayList会默认为 Object 类型可以放置任意类型的对象。

class ArrayList5{
    public static void main(String[] args) {
        ArrayList