第十五章　泛型

泛型的引入的原因:主要解决容器类存放数据的灵活性．
泛型的主要目的之一：用来制定容器类可以存放什么类型对象，而且有编译器来保证类型的正确性．［说明在编译时就能确定］核心概念:告诉编译器想使用什么类型，然后编译器帮你处理一切细节．

15.2.1 用泛型返回多个对象(一个元组类库)

package tinking_in_java.generics;
/**
 * Created by leon on 17-12-18.
 */
public class Holder<T> {
    private T t;
    public Holder(T t) {
        this.t = t;
    }
    public void setT(T t) {
        this.t = t;
    }
    public T getT() {
        return t;
    }

package tinking_in_java.generics;
/**
 * Created by leon on 17-12-18.
 */
public class Tuple<A, B> {
    public final A a;
    public final B b;
    public Tuple(A a, B b) {
        this.a = a;
        this.b = b;
    }
    @Override
    public String toString() {
        return "" + a + b;
    }
}
/**
 * 三元元组
 *
 * @param <A>
 * @param <B>
 * @param <C>
 */
class ThreeTuple<A, B, C> extends Tuple<A, B> {
    public final C c;
    public ThreeTuple(A a, B b, C c) {
        super(a, b);
        this.c = c;
    }
    @Override
    public String toString() {
        return "A= " + a + " B= " + b + " C= " + c;
    }
}
class FourTuple<A, B, C, D> extends ThreeTuple<A, B, C> {
    public final D d;
    public FourTuple(A a, B b, C c, D d) {
        super(a, b, c);
        this.d = d;
    }
}

15.2.2泛型作为　LinkedStack<T>

package tinking_in_java.generics;
/**
 * Created by leon on 17-12-18.
 */
public class LinkedStack<T> {
    class Node<U> {
        private U value;
        private Node<U> next;
        public Node() {
            value = null;
            next = null;
        }
        public Node(U u, Node<U> nextNode) {
            value = u;
            next = nextNode;
        }
        public boolean isEnd() {
            return value == null && next == null;
        }
    }
    private Node<T> top = new Node<T>();
    public void push(T t) {
        top = new Node<>(t, top);
    }
    public T pop() {
        if (top.isEnd()) return null;
        T result = top.value;
        top = top.next;
        return result;
    }
    public static void main(String[] args) {
        LinkedStack<String> myStack = new LinkedStack<>();
        myStack.push("abc");
        myStack.push("skjhklh");
        myStack.push("asdadf");
        String myStr = null;
        while ((myStr = myStack.pop()) != null) {
            System.out.println(myStr);
        }
    }
}

15.4泛型方法

泛型方法和是否是泛型类没有关系．以下是一条基本原则: 无论何时，只要你能做到，尽量使用泛型方法，也就是说如果泛型方法能代替泛型类，就应该采用泛型方法，因为他可以把事情更清楚明白．static方法无法使用泛型类的类型参数,如果需要使static 方法使用泛型参数必须申明为泛型方法.

泛型方法定义:在返回值前加<T> .
杠杆利用,类型参数推断.
可以做一个泛型推断生成器工具类．(但是这只对赋值操作有效，如果把他直接传入函数参数时是无效的，传入参数时候，编译器认为执行泛型方法后，返回值赋给一个Object类型变量)

package tinking_in_java.generics;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
/**
 * Created by leon on 17-12-18.
 */
public class NewUtils {
    public static <V, K> HashMap<V, K> map() {
        return new HashMap<>();
    }
    public static <T> List<T> list() {
        return new ArrayList<T>();
    }
    public static <T> LinkedList<T> linkedList() {
        return new LinkedList<T>();
    }
    public static <T> Queue<T> quene() {
        return new LinkedList<>();
    }
　　public static void main(String[] args) {
    HashMap<String, List<String>> myHash = NewUtils.map();
　　}

}

可变参数与泛型方法

泛型方法可以与可变参数很好的共存

public static <T> List<T> makeList(T... args) {
    ArrayList<T> list = new ArrayList<T>();
    for (T arg : args) {
        list.add(arg);
    }
    return list;
}
…
public static void main(String[] args) {
  List<String> makeList = makeList("a", "abc", "adalkj");
    System.out.println(makeList.toString());
}

15.5泛型构建匿名内部类
15.6 构建复杂模型

15.7擦除的神秘．

在泛型代码内部，无法获取获取任何泛型参数类型信息．

因此List<String> ,List<Integer>在运行时事实上是相同类型的，这两种形式都被摖除成”原生”类型,即List．所以为了确定泛型的参数类型，所以必须使用限定边界．

边界　<T extends AAA>,这个边界说明　T 必须具有AAA，或者Ｔ是从ＡＡＡ导出的类型(ＡＡＡ是Ｔ的基类)．泛型类型将摖除到他的第一个边界(他可能会有多个边界)．

class Manipupolor<T extends Frob>
   private T obj;
    public Manipupolor(T t) {
        obj = t;
    }
    public void manipuplor() {
        obj.f();
    }
}

这摖除之后相当于

class Manipupolor {
  private Frob obj;
    public Manipupolor(Frob t) {
        obj = t;
    }
    public void manipuplor() {
        obj.f();
    }
}

只有需要希望使用这个类型比某个具体类型(以及他所有子类)更加”泛化”的时候，也就是他能跨多个类工作时，泛型才有帮助．
泛型类型只有在静态类型检测期间才出现，在此之后，程序中的所有泛型类型都会被摖除，替换成他们的非泛型上界．诸如List<T> ==>摖除成 List,而普通类型变量在未指定边界情况下将摖除成Object. java采用摖除的原因是，要使得泛型能向后兼容．必须采取折中方案．
因为泛型擦除在方法体中移除了类型信息，所有在运行时的问题就是边界：对象进入和离开的方法地点．

通过泛型创建类型实例.java中要创建通用实例，是做不到的，只能通过工厂方法预先针对不同类型创建．

15.8.2泛型数组

不能直接创建泛型数组(例如　new T[])，一般的解决方法是用arrayList<T> 创建,或者创建(T[])new Object[],(创建object数组，然后转型T[]).因为有了擦除，数组在运行时只能是Object[],那么在编译的时候如果强行转成T[],　编译期该数组的实际类型将会丢失，那么编译器会错过错误检查，所以最好在集合内部使用Object[],在使用时候再进行转型T.其实ArrayList　就是内部的存储就是这么做得．

15.9边界

extends关键字在泛型上下文环境中和普通情况下的意义完全不同．
1.通过在<T extends　xxx> 来确定边界
2.还可以在　class< > extends 基类来确定边界．(好处是可以省去重复代码)
例如:
第一种 :
BasicBound.java

package tinking_in_java.generics;
import java.awt.Color;
/**
 * Created by leon on 17-12-19.
 */
interface HashColor {
    Color getColor();
}
class Colored<T extends HashColor> {
    T item;
    public Colored(T t) {
        this.item = t;
    }
    T getItem() {
        return item;
    }
    public Color color() {
        return item.getColor();
    }
}
class Dimension {
    public int x, y, z;
}
//extends 多重继承关系　,必须class 在前，interface在后
class DimensionColor<T extends Dimension & HashColor> {
    T item;
    public DimensionColor(T t) {
        item = t;
    }
    public Color color() {
        return item.getColor();
    }
    public int getX() {
        return item.x;
    }
    public int getY() {
        return item.y;
    }
    public int getZ() {
        return item.z;
    }
}
interface Weight {
    int getWeight();
}
class Solid<T extends Dimension & HashColor & Weight> {
    T item;
    public Solid(T t) {
        item = t;
    }
    T getItem() {
        return item;
    }
    Color color() {
        return item.getColor();
    }
    int getX() {
        return item.x;
    }
    int getY() {
        return item.y;
    }
    int getZ() {
        return item.z;
    }
    int weight() {
        return item.getWeight();
    }
}
class Bound extends Dimension implements HashColor, Weight {
    @Override
    public Color getColor() {
        return Color.RED;
    }
    @Override
    public int getWeight() {
        return 0;
    }
}
public class BasicBound {
    public static void main(String[] args) {
        Solid<Bound> solid = new Solid<>(new Bound());
        System.out.println("" + solid.getX() + solid.getY() + solid.color() + solid.weight());
    }
}

第二种,采用继承基类的形式:

package tinking_in_java.generics;
import java.awt.Color;
/**
 * Created by leon on 17-12-19.
 */
class Hold<T> {
    T item;
    Hold(T t) {
        item = t;
    }
    T getItem() {
        return item;
    }
}
class Colors2<T extends HashColor> extends Hold<T> {
    Colors2(T t) {
        super(t);
    }
    Color color() {
        return item.getColor();
    }
}
class DimensionColor2<T extends Dimension & HashColor> extends Colors2<T> {
    DimensionColor2(T t) {
        super(t);
    }
    int getX() {
        return item.x;
    }
    int getY() {
        return item.y;
    }
    int getZ() {
        return item.z;
    }
}
class Solid2<T extends Dimension & HashColor & Weight> extends DimensionColor2<T> {
    Solid2(T t) {
        super(t);
    }
    int weight() {return item.getWeight();   }
}
public class InheritBound {
    public static void main(String[] args) {
        Solid2<Bound> solid2 = new Solid2<>(new Bound());
        System.out.println("" + solid2.getX() + solid2.getY() + solid2.color() + solid2.weight());
    }
}

15.10通配符类型:

协变<? Extends MyClass> :具有任何从MyClass 继承类的通配符 Pair<? extends Emplee> myPair=new Pair<Mannager>(Bob,Linar) .只可以读取数据，不能通过myPair 往里面再次添加数据．

15.10.2　逆变(使用超类通配符)

<? Super MyClass>甚至可以用<? Super T>　有某个特定类任一的基类来界定.
解读协变和逆变：

引入的原因是解决　单一泛型类型的制约．

对于协变List<? extends Number > numList;

image.png

从语义上分析：
修改：因为? 都是继承Number ,所以按理说　既可以往numList 添加　Integer,也可以往里面添加Float,也可以添加Double,Long.但是这样就会出现问题，编译器无法知道究竟往里面添加了什么类型的数据．［因此为了保证明确性，规定不能这样做］
读取：因为都是继承Number ,所以这里面的数据必然能读取到Number,因为里面的数据要么是Number，要么是Number的子类数据．［所以允许读取］

对于逆变List<? Super Integer>

image.png

读取 :按照字面意思　因为容器里面　的数据都是　Integer的超类，那么：既可以读取Integer,也可以读取Number,还可以读取Object .这就造成读取数据的不确定性［所以禁止读取］
修改 :为了保证数据的确定性，必须往里面写入Integer 或者Integer的子类(因为Integer的子类也属于Integer)．

适用场景:生产者(获取数据)适用Extends ,消费者(装入数据)适用　Super.

例如:

// Collections.java
public static <T> void copy(List<? super T> dest, List<? extends T> src) {
    int srcSize = src.size();
    if (srcSize > dest.size())
        throw new IndexOutOfBoundsException("Source does not fit in dest");

    if (srcSize < COPY_THRESHOLD ||
        (src instanceof RandomAccess && dest instanceof RandomAccess)) {
        for (int i=0; i<srcSize; i++)
            dest.set(i, src.get(i));
    } else {
        ListIterator<? super T> di=dest.listIterator();
        ListIterator<? extends T> si=src.listIterator();
        for (int i=0; i<srcSize; i++) {
            di.next();
            di.set(si.next());
        }
    }
}

包含泛型相同名字，参数类型相似的多个接口不能同时被一个类继承，因为擦除的作用，他们会被当做相同的接口．一个类中如果传有多个泛型T,V ,不能把不同泛型当做不同类型数据看待进行函数重载，因为擦除之后他们的类型都是会变成Object．

15.12自限定的类型．

class SelfBounded<T extends SelfBounded<T>>{…}

这就话的意思是　＂SelfBounded类接受泛型参数T，而T由一个边界类限定，这个边界就是拥有T作为其参数的SelfBounded＂．这个的好处在与，能使得　导出类用自己作为参数以及　返回类型．但是这在编译器中并不是强制要求这么做的，一般来说需要要求其他每个用这种方式的人遵循这个原则.

package tinking_in_java.generics;
/**
 * Created by leon on 17-12-19.
 */
/**
 * 自限定　要求继承者都必须传入参数和　返回参数有相同
 *
 * @param <T>
 */
class SelfBounded<T extends SelfBounded<T>> {
    T elment;
    SelfBounded<T> set(T t) {
        elment = t;
        return this;
    }
    public T get() {
        return elment;
    }
}
/**
 * 属于正确理解
 */
class A extends SelfBounded<A> {
}
/**
 * 不属于正确理解，但是编译器不会报错
 */
class B extends SelfBounded<A> {
}
/**
 * 属于正确理解,参数和返回参数都是C类型
 */
class C extends SelfBounded<C> {
    C setAndGet(C c) {
        set(c);
        return get();
    }
}
public class SelfBounding {
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 202,529评论 5赞 475
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 85,015评论 2赞 379
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 149,409评论 0赞 335
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 54,385评论 1赞 273
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 63,387评论 5赞 364
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 48,466评论 1赞 281
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 37,880评论 3赞 395
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,528评论 0赞 256
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 40,727评论 1赞 295
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,528评论 2赞 319
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 37,602评论 1赞 329
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,302评论 4赞 318
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 38,873评论 3赞 306
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 29,890评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,132评论 1赞 259
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 42,777评论 2赞 349
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,310评论 2赞 342

推荐阅读更多精彩内容

  • 第十五章：泛型
    泛型实现了参数化类型的概念。 简单泛型 容器是出现泛型的重要原因之一。泛型的主要目的之一就是用来指定容器要持有什么...
    MAXPUP阅读 520评论 0赞 0
  • Java梳理之理解泛型
    在之前的文章中分析过了多态，可以知道多态本身是一种泛化机制，它通过基类或者接口来设计，使程序拥有一定的灵活性，但是...
    _小二_阅读 676评论 0赞 0
  • Java泛型
    开发人员在使用泛型的时候，很容易根据自己的直觉而犯一些错误。比如一个方法如果接收List作为形式参数，那么如果尝试...
    时待吾阅读 1,038评论 0赞 3
  • 敢于不敢，只有自己决定
    When I was sane, often in his thoughts on the night peopl...
    深夜阅书阅读 226评论 0赞 0
  • 信意闲弹和寡曲，琴格高低心自知
    江湖曾有传言，说我是一枚大规模杀伤性武器。 这话根本就不靠谱，试想，若我真属于此类范畴的话，联合国岂能容我活到今天...
    唐家小痴阅读 994评论 34赞 27