《Thinking in Java》学习笔记——15章泛型（一）

简单泛型

1.泛型的主要目的之一就是用来指定容器要持有什么类型的对象，而且由编译器来保证类型的正确性。
2.Java泛型的核心概念：告诉编译器想使用什么类型，然后编译器帮你处理一切细节。

一.一个元组类库

1.元组（tuple）：它是将一组对象直接打包储存于其中的一个单一对象。
2.下面程序是一个二维元组，它能够持有两个对象：

public class TwoTuple<A, B> {
    public final A first;
    public final B second;
    public TwoTuple(A a, B b) {
        first = a;
        second = b;
    }
    public String toString() {
        return "(" + first + ", " + second + ")";
    }
}

客户端程序可以读取first或second所引用的对象，然后可以随心所欲地使用这两个对象。但是，它们却无法将其他值赋予first或second。因为final声明为你买了安全保险，实现了Java编程的安全性原则，而且这种格式更加简洁明了。
3.我们可以利用继承机制实现更长的元组。

一个堆栈类

1.不用LinkedList，自己实现的内部链式存储机制：

public class LinkedStack<T> {
    private static class Node<U> {
        U item;
        Node<U> next;
        Node() {
            item = null;
            next = null;
        }
        Node(U item, Node<U> next) {
            this.item = item;
            this.next = next;
        }
        boolean end() {
            return item == null && next == null;
        }
    }
     
    private Node<T> top = new Node<T>();
    public void push(T item) {
        top = new Node<T>(item, top);
    }
    public T pop() {
        T result = top.item;
        if (!top.end()) {
            top = top.next;
        }
        return result;
    }
}

2.另一个例子RandomList：假设我们需要一个持有特定类型对象的列表，每次调用其上的select()方法时，它可以随机地选取一个元素：

class RandomList<T> {
    private ArrayList<T> storage = new ArrayList<T>();
    private Random rand = new Random(47);
    public void add(T t) {
        storage.add(t);
    }
    public T select() {
        return storage.get(rand.nextInt()storage.size());
    }
}

泛型方法

1.可以在类中包含参数化方法，而这个方法所在的类可以是泛型类，也可以不是泛型类。也就是说，是否拥有泛型方法，与其所在的类是否是泛型没有关系。
2.如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型化，另外对于一个static方法而言，无法访问泛型类的类型参数，所以如果static方法需要使用泛型能力，就必须使其成为泛型方法。
3.要定义泛型方法，只需将泛型参数列表置于返回值之前：

public <T> void f(T x) {
    System.out.println(x.getClass().getName());
}

如果调用f()时传入的是基本类型，自动打包机制就会介入其中，将基本类型的值包装为对应的对象。

一.可变参数与泛型方法

1.泛型方法与可变参数列表能够很好的共存：

//和java.util.Arrays.asList()方法功能相同
public static <T> List<T> makeList(T... args) {
    List<T> result = new ArrayList<T>();
    for (T items : args) {
        result.add(item);
    }
    return result;
}
二.简化元组的使用

1.我们现在可以重新编写之前的元组工具，使其成为更通用的工具类库：

public class Tuple {
    public static <A, B> TwoTuple<A, B> tuple(A a, B b) {
        return new TwoTuple<A, B>(a, b);
    }
    ......
}

下面是一个测试类：

public class TupleTest {
    static TwoTuple<String, Integer> f() {
        return Tuple.tuple("hi", 47);
    }
    static TwoTuple f2() {
        return Tuple.tuple("hi", 47);
    }
    public static void main(String... args) {
        TwoTuple<String, Integer> ttsi = f();
        System.out.println(f());
        System.out.println(f2());
    }
}
/*
Output:
(hi, 47)
(hi, 47)
*/

在这里，方法f()返回一个参数化的TwoTuple对象，而f2()返回的是非参数化的TwoTuple对象。编译器并没有关于f2()的警告信息，因为我们并没有将其返回值作为参数化对象使用。在某种意义上，它被“向上转型”为一个非参数化的TwoTuple。然而，如果试图将f2()的返回值转型为参数化的TwoTuple，编译器就会发出警告。

擦除的神秘之处

1.ArrayList<String>和ArrayList<Integer>很容易被误认为是两种不同的类型，但它们是相同的：

public class Test {
    public static void main() {
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();
        if (c1 == c2)
            System.out.println("true");
        System.out.println(Arrays.toString(c1.getTypeParameters()));
        System.out.println(Arrays.toString(c2.getTypeParameters()));
    }
}
/*
Output:
true
[E]
[E]
*/

首先我们可以看到，上面的程序会认为它们是相同的类型。另外，程序中使用的Class.getTypeParameters()可以返回一个TypeVariable对象数组，表示有泛型声明所声明的类型参数，但是我们能够发现的只有用作参数占位符的标识符。因此我们得出结论：在泛型代码内部，无法获得任何有关泛型参数类型的信息。
2.Java泛型是使用擦除来实现的，这意味着当你在使用泛型时，任何具体的类型信息都被擦除了，你唯一知道的就是你在使用一个对象。因此List<String>和List<Integer>在运行时都被擦除成它们的“原生”类型List。
3.由于擦除，在使用泛型时，这些类型参数都会被当作Object进行处理。

一.擦除的问题

1.泛型不能用于显式地引用运行时类型的操作之中，例如转型、instanceof操作和new表达式。
2.为了关闭由于没有使用泛型的警告，Java提供了一个注解：

@SuppressWarnings("unchecked")

这个注解被放置在可以产生这类警告的方法之上，而不是整个类上。

二.边界处的动作
public class ArrayMaker<T> {
    private Class<T> kind;
    private ArrayMaker(Class<T> kind) {
        this.kind = kind;
    }
    
    @SuppressWarnings("unchecked")
    T[] create(int size) {
        return (T[]) Array.newInstance(kind, size);
    }
    public static void main(String... args) {
        ArrayMaker<String> stringMaker = new ArrayMaker<String>(String.class);
        String[] stringArray = stringMaker.create(9);
        System.out.println(Arrays.toString(stringArray))
    }
}
/*
Output:
[null, null, null, null, null, null, null, null, null]
*/

上面这段代码中，由于擦除，kind实际被储存为Class，没有任何参数。因此Array,newInstance()中并没有收到任何具体的类型信息，因此必须转型。
注意，对于在泛型中创建数组，使用Array.newInstance()是推荐的方式。
2.因为擦除在方法体中移除了类型信息，所以在运行时的问题就是边界：即对象进入和离开方法的地点。这些正是编译器执行类型检查并插入转型代码的地点。
3.在泛型中所有的动作都发生在边界处——对传递进来的值进行额外的编译期检查，并插入对传递出去的值的转型。典型的情况就是在get()和set()方法中使用泛型。

擦除的补偿

1.擦除丢失了在泛型代码中执行某些操作的能力。任何在运行时需要知道的确切类型信息的操作都将无法工作：

public class Erased<T> {
    private final int SIZE = 100;
    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];  //ERROR
    }
}
一.创建类型实例

1.上面的程序中对创建一个new T()的尝试无法实现，部分原因是因为擦除，而另一部分原因是因为编译器不能验证T具有默认（无参）构造器。
2.对于上面这个问题Java的解决方法是使用工厂对象来创建新的实例，建议使用显式工厂，并限制其类型，使得只能接受实现了这个工厂的类：

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

class Foo<T> {
    private T x;
    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 WidgetFactory implements Factory<Widget> {
        public WidgetFactory create() {
            return new Widget();
        }
    }
}

public class FactoryConstraint {
    public static void main(String... args) {
        new Foo<Integer>(new IntegerFactory());
        new Foo<Widget>(new Widget.WidgetFactory());
    }
}
二.泛型数组

1.不能直接创建泛型数组，一般想要达到相同效果的方法是在任何想要创建泛型数组的地方都使用ArrayList。
2.如果一定要创建一个泛型数组，唯一的方式就是创建一个被擦除类型的新数组，然后对其转型：

class Generic<T> {} 

class ArrayOfGeneric {
    static Generic<Interger> gia;
    public static void main(String... args) {
        gia = (Generic<Interger>[]) new Generic[10];
    }
}

3.因为有了擦除数组的运行时类型就只能是Object[]。如果我们立即将其转型为T()，那么在编译期该数组的实际类型就将丢失。因此，最好时机在集合内部使用Object[]，然后当你使用数组元素时，添加一个对T[]对转型：

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

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

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

但如果试着将Object[]转型为T[]是不行的，因为，没有任何方式可以推翻底层数组类型，它只能是Object[]。
4.下面是对上面代码对一种改进，ArrayList中就使用了这种形式对转型：

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

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

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

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

边界

1.边界使得我们可以在用于泛型的类型参数类型上设置限制条件。因为擦除了类型信息，所以可以用无界泛型参数调用的方法只是那些可以用 Object调用的方法。但是，如果能够将这个参数限制为某个类型子集，那就可以用类型子集来调用方法。
2.为了执行对泛型参数的限制，Java重用了extends关键字。
3.对泛型进行参数限制也有多继承，并且也可以通过继承消除冗余：

interface A{}

interface B {}

class C{}

class D extends C implements A, B {}

class E<T extends C & A & B> {}

class F {
    public F() {
        E<D> e = new E<D>();
    }
}

4.下面的程序展示了如何在继承的每个层次上添加边界限制：

class A {
   void set();
}

class B<T> {
   T item;
   public B(T item) {
       this.item = item;
   }
}

class C<T extends A> extends B<T> {
   T item;
   public C(T item) {
       this,item = item;
       item.set();
   }
}

上面的程序中B直接持有一个对象，因此这种行为被继承到了C中，它也要求其参数与A一致。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,457评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,837评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,696评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,183评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,057评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,105评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,520评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,211评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,482评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,574评论 2赞 309
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,353评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,213评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,576评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,897评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,174评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,489评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,683评论 2赞 335

推荐阅读更多精彩内容

  • 《Thinking in Java》学习——15章泛型（二）
    通配符 1.数组具有协变性：可以向导出类型的数组赋予基类型的数组引用： 上面的代码不会出现编译问题，因为Apple...
    zpauly阅读 684评论 0赞 0
  • Java学习日常：泛型
    附上思维导图。这篇博客主要讲了如下知识点。 看完了《Thinking in Java》的第十五章泛型，着实被震了一...
    Happioo阅读 707评论 0赞 1
  • 漫谈Java的泛型机制
    泛型是Java 1.5引入的新特性。泛型的本质是参数化类型，这种参数类型可以用在类、变量、接口和方法的创建中，分别...
    何时不晚阅读 3,020评论 0赞 2
  • 泛型
    2.简单泛型 -********Java泛型的核心概念:告诉编译器想使用什么类型, 然后编译器帮你处理一切细节 2...
    CodingHou阅读 387评论 0赞 0
  • Java的泛型解析
    一、为什么要使用泛型 1.类型参数的好处 类型安全：泛型的主要目标是提高 Java 程序的类型安全。通过知道使用泛...
    SeanMa阅读 7,005评论 1赞 18