泛型的引入的原因:主要解决容器类存放数据的灵活性．
泛型的主要目的之一：用来制定容器类可以存放什么类型对象，而且有编译器来保证类型的正确性．［说明在编译时就能确定］核心概念:告诉编译器想使用什么类型，然后编译器帮你处理一切细节．
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>>{…}
这就话的意思是 ＂我在创建一个类，他继承自一个泛型类型，这个泛型类型 接受我的类的名字作为参数＂．这个的好处在与，能使得 导出类用自己作为参数以及 返回类型．但是这在编译器中并不是强制要求这么做的，一般来说需要要求其他每个用这种方式的人遵循这个原则.
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 {
}
网友评论