15.泛型

第15章 泛型

泛型是在JDK5出现的，泛型实现了参数化类型的概念，使代码可以应用于多种类型。

15.2 简单泛型

促使泛型出现的原因之一就是创建容器类。

一个元组类库

元组：将一组对象直接打包存储于其中的一个单一对象，允许读取元素，不允许存放新元素。

@ToString
// 将两个对象打包于一个对象
class TwoTuple<A,B>{
    public final A a;
    public final B b;

    public TwoTuple(A a, B b) {
        this.a = a;
        this.b = b;
    }
}
/*
为什么要这么做？
通过声明public，客户端可以直接读取元素，声明final限制存放新元素，如果要存放新元素，需要重新创建对象
*/

// 通过继承实现更长的元组
@ToString
class ThreeTuple<A,B,C> extends TwoTuple<A,B>{
    public final C c;

    public ThreeTuple(A a, B b, C c) {
        super(a, b);
        this.c = c;
    }
}

// 返回元组
public class Test {
    public static void main(String[] args) {
        System.out.println(f());
        System.out.println(e());
    }
    static TwoTuple<String,Integer> f(){
        return new TwoTuple<>("make",12);
    }
    static ThreeTuple<String,Integer,Integer> e(){
        return new ThreeTuple<>("make",22,175);
    }
}

一个栈类

class MyStack<T>{
    // 节点类（包含当前数据及上一级节点）
    private  class Node<U>{
        private U item;
        private Node<U> next;

        public Node(U item, Node<U> next) {
            this.item = item;
            this.next = next;
        }

        public boolean end(){
            // 当数据和节点同时为空时及到头了
            return item == null && next == null;
        }
    }
    // 创建末端哨兵
    private Node<T> top = new Node<>(null,null);

    public void push(T item){
        top = new Node<>(item,top);
    }

    public T pop(){
        T item = top.item;
        if (!top.end()){
            top = top.next;
        }
        return item;
    }
}

 public static void main(String[] args) {
        MyStack<Integer> stack = new MyStack<>();
        for (int i = 0; i < 5; i++) {
            stack.push(i);
        }
        for (int i = 0; i < 10; i++) {
            System.out.println(stack.pop());
        }
    }

/*
4
3
2
1
0
null
null
null
null
null
*/

RandomList

class RandomList<T>{
    private List<T> list = new ArrayList<>();
    Random random = new Random();
    public void add(T t){
        list.add(t);
    }

    public T randomGet(){
        return list.get(random.nextInt(list.size()));
    }
}
  public static void main(String[] args) {
        RandomList<Integer> list = new RandomList<>();
        for (int i = 0; i < 10; i++) {
            list.add(i);
        }
        for (int i = 0; i < 5; i++) {
            System.out.println(list.randomGet());
        }
    }

15.3 泛型接口

class Coffee {
    // 计数，创建了多少对象
    private static Integer counter = 0;
    // 第n次创建的对象
    private final Integer id = counter++;

    @Override
    public String toString() {
        return "Coffee{" +
                "id=" + id +
                '}';
    }
}

class ACoffee extends Coffee{}
class BCoffee extends Coffee{}
class CCoffee extends Coffee{}

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


class CoffeeFactory implements Factory<Coffee>,
        // 为了可以使用foreach
        Iterable<Coffee>{
    private Class[] classes = {ACoffee.class,BCoffee.class,Coffee.class};
    Random random = new Random();
    private Integer size = 0;

    public CoffeeFactory() {
    }
    // 如果要使用循环语句，必须有该方法，否则不知道何时停止
    public CoffeeFactory(Integer size) {
        this.size = size;
    }

    @SneakyThrows
    @Override
    public Coffee next() {
        return (Coffee) classes[random.nextInt(classes.length)].newInstance();
    }

    @Override
    public Iterator<Coffee> iterator() {
        return new CoffeeIterator();
    }

    // 迭代器
    private class CoffeeIterator implements Iterator<Coffee>{
        // 被迭代的数量
        private Integer count = size;
        @Override
        public boolean hasNext() {
            return count > 0;
        }

        @Override
        public Coffee next() {
            // 被迭代一次，减去一次
            count--;
            // 获得调用该迭代器的next()方法
            return CoffeeFactory.this.next();
        }
    }
}

 public static void main(String[] args) {
        Factory<Coffee> factory = new CoffeeFactory();
        for (int i = 0; i < 5; i++) {
            System.out.println(factory.next());
        }
        for(Coffee coffee:new CoffeeFactory(5)){
            System.out.println(coffee);
        }
    }
/*
Coffee{id=0}
Coffee{id=1}
Coffee{id=2}
Coffee{id=3}
Coffee{id=4}
Coffee{id=5}
Coffee{id=6}
Coffee{id=7}
Coffee{id=8}
Coffee{id=9}
*/

// 创建斐波那契数列
//此处可以看到泛型不支持基本类型，但是由于自动装箱/拆箱，使用中不存在问题
class FibonacciFactory implements Factory<Integer>{
    private int num = 0;

    @Override
    public Integer next() {
        return fib(num++);
    }

    private int fib(int n){
        if (n < 2){
            return  1;
        }else {
            return fib(n-2)+fib(n-1);
        }
    }
}

// 为了使用循环语句，这里使用适配器模式
class FibonacciFactoryAdapter extends FibonacciFactory implements Iterable<Integer>{
    private int count =0;

    public FibonacciFactoryAdapter() {
    }

    public FibonacciFactoryAdapter(int count) {
        this.count = count;
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            private int size = count;
            @Override
            public boolean hasNext() {
                return size>0;
            }

            @Override
            public Integer next() {
                size--;
                return FibonacciFactoryAdapter.this.next();
            }
        };
    }
}

  public static void main(String[] args) {
        Factory<Integer> factory = new FibonacciFactory();
        for (int i = 0; i < 5; i++) {
            System.out.println(factory.next());
        }

        for (Integer num:new FibonacciFactoryAdapter(5)){
            System.out.println(num);
        }
    }
/*
1
1
2
3
5
1
1
2
3
5
*/

15.4 泛型方法

在使用泛型方法即可解决问题时，不要使用泛型类。

static方法如果要使用泛型能力，必须使其成为泛型方法。

定义泛型方法：将泛型参数列表置于返回值之前。

public class Test {
    public static void main(String[] args) {
        f(1);
        f("a");
        f(11.2);
        f(new StringBuilder());
    }
    static <T> void f(T t){
        System.out.println(t.getClass().getSimpleName());
    }
}
/*
Integer
String
Double
StringBuilder
*/

15.4.1 杠杆利用类型参数推断

本节主要是为了实现泛型的类型推断，该功能在JDK1.7中已经引入。

15.4.2 可变参数和泛型方法

public class Test {
    public static void main(String[] args) {
        f(1,2,3);
        f("a","b","c");
    }
    static <T> void f(T ...args){
      List<T> list = new ArrayList<>();
        for (T arg : args) {
            list.add(arg);
        }
        System.out.println(list);
    }
}
/*
[1, 2, 3]
[a, b, c]
*/

15.4.3用于Factory的泛型方法

public class Test {
    public static void main(String[] args) {
        System.out.println(f(new ArrayList<>(), new CoffeeFactory(), 5));
    }
    
    static<T> Collection<T> f(Collection<T> collection,Factory<T> factory,int i){
        for (int j = 0; j < i; j++) {
            collection.add(factory.next());
        }
        return collection;
    }

}
/*
[Coffee{id=0}, Coffee{id=1}, Coffee{id=2}, Coffee{id=3}, Coffee{id=4}]
*/

15.4.4通用的工厂方法

class BasicFactory<T> implements Factory<T>{
    private Class<T> aClass;
    public BasicFactory(Class<T> aClass) {
        this.aClass = aClass;

    }
    @SneakyThrows
    @Override
    public T next() {
        return aClass.newInstance();
    }
}
 public static void main(String[] args) {
       Factory<Coffee> factory = new BasicFactory<>(Coffee.class);
        for (int i = 0; i < 5; i++) {
            System.out.println(factory.next());
        }
    }

15.4.5简化元组的使用

public class Test {
    public static void main(String[] args) {
        // 没有指定接收变量的参数类型，默认为Object
        TwoTuple twoTuple = getTwoTuple(1,"a");
        Integer i = (Integer) twoTuple.a;
        ThreeTuple<String,Integer,Integer> threeTuple = getThreeTuple("make",12,111);
        String name = threeTuple.a;
    }
    
    static <A,B> TwoTuple<A,B> getTwoTuple(A a,B b){
        return new TwoTuple<>(a,b);
    }
    
    static <A,B,C> ThreeTuple<A,B,C> getThreeTuple(A a,B b,C c){
        return new ThreeTuple<>(a,b,c);
    }
}

15.4.6 一个Set实用工具

class Sets{

    // a和b的所有元素
    public static <T> Set<T> union(Set<T> a,Set<T> b){
        Set<T> set = new HashSet<>(a);
        set.addAll(b);
        return set;
    }

    // a和b的交集
    public static <T> Set<T> intersection(Set<T> a,Set<T> b){
        Set<T> set = new HashSet<>(a);
        set.retainAll(b);
        return set;
    }

    // a中去除b中的元素
    public static <T> Set<T> difference(Set<T> a,Set<T> b){
        Set<T> set = new HashSet<>(a);
        set.removeAll(b);
        return set;
    }

    // a和b的非交集元素
    public static <T> Set<T> complement(Set<T> a,Set<T> b){
        return difference(union(a,b),intersection(a, b));
    }
}

  public static void main(String[] args) {
        Set<String> a = new HashSet<>();
        for (int i = 97; i < 101; i++) {
            char c = (char) i;
            a.add(String.valueOf(c));
        }
        System.out.println(a); // [a, b, c, d]
        Set<String> b = new HashSet<>();
        for (int i = 99; i < 103; i++) {
            char c = (char) i;
            b.add(String.valueOf(c));
        }
        System.out.println(b); // [c, d, e, f]
        System.out.println(Sets.union(a,b)); // [a, b, c, d, e, f]
        System.out.println(Sets.intersection(a,b)); // [c, d]
        System.out.println(Sets.difference(a,b)); // [a, b]
        System.out.println(Sets.complement(a,b)); // [a, b, e, f]

    }

比较父子容器类间方法和接口的区别

class ContainerCom{
    // 类方法集合
    private static  Set<String> methods(Class c){
        Set<String> set = new TreeSet<>();
        for (Method method : c.getMethods()) {
            set.add(method.getName());
        }
        return set;
    }
    // 排除Object方法的类方法集合
    public static Set<String> methodWithOutObject(Class c){
        return Sets.difference(methods(c), methods(Object.class));
    }
    // 类接口集合
    public static Set<String> interfaces(Class c){
        Set<String> set = new TreeSet<>();
        for (Class anInterface : c.getInterfaces()) {
            set.add(anInterface.getSimpleName());
        }
        return set;
    }
	// 父类和子类方法/接口的区别
    public static void diff(Class superClass,Class subClass){
        System.out.println("方法区别：");
        System.out.println(Sets.difference(methodWithOutObject(superClass),methodWithOutObject(subClass)));
        System.out.println("接口区别：");
        System.out.println(Sets.difference(interfaces(superClass),interfaces(subClass)));
    }
    
}

 public static void main(String[] args) {
        ContainerCom.diff(List.class,ArrayList.class);
       diff(Collection.class,List.class);
    }

15.5 匿名内部类

class Person{
    private Person(){}
    public static Factory<Person> factory = new Factory<Person>() {
        @Override
        public Person next() {
            return new Person();
        }
    };
    
    public static Factory<Person> getFactory(){
        return new Factory<Person>() {
            @Override
            public Person next() {
                return new Person();
            }
        };
    }
}
 public static void main(String[] args) {
        Person p = Person.factory.next();
        p = Person.getFactory().next();
    }

15.6 构建复杂模型

class Person<A,B,C>{}

class PersonList<A,B,C> extends ArrayList<Person<A,B,C>>{}

  public static void main(String[] args) {
        List<Person<String,Integer,Integer>> list = new PersonList<>();
        list.add(new Person<>());
        Person<String, Integer, Integer> person = list.get(0);
    }

零售店模型

商店-走廊-货架-商品

// 商品
class Product{
    private Integer id;
    private Integer price;
    private static Random random = new Random();

    public Product(Integer id, Integer price) {
        this.id = id;
        this.price = price;
    }

    public static Factory<Product> getFactory(){
        return new Factory<Product>() {
            @Override
            public Product next() {
                int id = random.nextInt(10);
                int price = random.nextInt(100);
                return new Product(id,price);
            }
        };
    }

    @Override
    public String toString() {
        return new StringBuilder().append("商品编号：").append(id)
                .append("商品价格：").append(price).toString();
    }
}

// 货架
class Shelf extends ArrayList<Product>{
    // 一条货架要包含多少商品
    public Shelf(int productNum){
        for (int j = 0; j < productNum; j++) {
            add(Product.getFactory().next());
        }
    }
}

// 走廊
class Aisle extends ArrayList<Shelf>{
    // 一条走廊要包含多上货架，每条货架上是多少商品
    public Aisle(int shelfNum,int productNum){
        for (int i = 0; i < shelfNum; i++) {
            add(new Shelf(productNum));
        }
    }
}

// 商店
class Store extends ArrayList<Aisle> {
    public Store(int aisleNum,int shelfNum,int productNum){
        for (int i = 0; i < aisleNum; i++) {
            add(new Aisle(shelfNum,productNum));
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (Aisle aisle : this) {
            for (Shelf shelf : aisle) {
                for (Product product : shelf) {
                    sb.append(product).append("\r\n");
                }
            }
        }
        return sb.toString();
    }
}
    public static void main(String[] args) {
        Store store = new Store(1,2,3);
        System.out.println(store);
    }
/*
商品编号：8商品价格：17
商品编号：1商品价格：39
商品编号：4商品价格：48
商品编号：0商品价格：91
商品编号：1商品价格：5
商品编号：2商品价格：37
*/

15.7 擦除的神秘之处

class A<T>{}

class B<T,U>{}
  public static void main(String[] args) {
        List<Integer> integerList = new ArrayList<>();
        List<String> stringList = new ArrayList<>();
      // 在运行时类型会被擦除，他们都是List
        System.out.println(integerList.getClass() == stringList.getClass()); // true
        A<Integer> a = new A<>();
        B<A<Integer>,String> b= new B<>();
      // getTypeParameters()返回泛型参数，但是并不是具体的类型参数，并没有实际意义
        System.out.println(Arrays.toString(a.getClass().getTypeParameters())); // [T]
        System.out.println(Arrays.toString(b.getClass().getTypeParameters())); // [T, U]
    }

15.7.1 C++的方式

翻译为Java的版本：

class HasF{
    public void f(){
        System.out.println("this is F");
    }
}

class Manipulator<T extends HasF>{
    private T obj;

    public Manipulator(T obj) {
        this.obj = obj;
    }

    public void manipulate(){
        // 类型擦除会擦除到它的上一个边界(可能会有多个边界)
        /*
        可以看到，这样使用泛型和使用HasF没有什么区别，
        如果是在类内部使用，就没必要使用泛型，
        在外部类中会使用该类型，才有必要使用泛型
         */
        obj.f();
    }
}

15.7.2 迁移兼容性

为了保持兼容性，泛型在运行时会被擦除。

15.7.3 擦除的问题

擦除也存在明显的代价，泛型不能用于显示地运行时类型操作，比如转型/instanceof/new，因为所有关于参数的类型信息都丢失了。

使用泛型并不是强制的。

public class Test {
    public static void main(String[] args) {
        A a = new A();
        a.setT(1);
        Object o = a.getT();
        A<String> stringA = new A<>();
        stringA.setT("a");
        String t = stringA.getT();
    }
}

class A<T>{
    private T t;

    public T getT() {
        return t;
    }

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

15.7.4 边界的动作

class arrayMaker<T>{
    private Class<T> kind;

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

    @SuppressWarnings("unchecked")
    public T[] create(int size){
        // newInstance()方法返回Object对象，需要转型为T[],因为T是泛型，不存在类型信息，所以会产生警告信息
        return (T[]) Array.newInstance(kind,size);
    }
}

public class Test {
    public static void main(String[] args) {
        arrayMaker<String> arrayMaker = new arrayMaker<>(String.class);
        String[] strings = arrayMaker.create(5);
        System.out.println(Arrays.toString(strings));

    }
}

class ListMaker<T>{
    List<T> create(){
        return new ArrayList<>();
    }

    // 这里会产生警告
    @SuppressWarnings("unchecked")
    List<T> create2(){
        return new ArrayList();
    }
}

边界： 对象进入和离开方法的地点。

泛型的动作发生在边界处，对传递进来的值机型额外检查，对传递出去的值转型。

15.8 擦除的补偿

擦除丢失了泛型的类型信息，为了使用类型信息，需要显示的传递类型信息。

class A{}

class B extends A{}

class ClassType<T>{
    private Class<T> kind;
    // 显示传递类型信息
    public ClassType(Class<T> kind) {
        this.kind = kind;
    }

    public boolean is(Object obj){
        return kind.isInstance(obj);
    }
}

    public static void main(String[] args) {
        ClassType<B> classType = new ClassType<>(B.class);
        System.out.println(classType.is(new A())); // false
        System.out.println(classType.is(new B())); // true
    }

15.8.1 创建类型实例

内建的工厂对象

class ClassAsFactory<T>{
    public T t;

    public ClassAsFactory(Class<T> kind) {
        try {
            t = kind.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

public static void main(String[] args) {
        ClassAsFactory<String> classAsFactory = new ClassAsFactory<>(String.class);
        // 遇到无默认构造器的类会报错
       // ClassAsFactory<Integer> integerClassAsFactory = new ClassAsFactory<>(Integer.class);
    }

显式的工厂对象

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

// 具体对象
class A{
    public static class AFactory implements Factory<A>{
        @Override
        public A create() {
            return new A();
        }
    }
}

// 可接纳传入的对象
class Need<T>{
    public T t;
    // 注意：两个泛型必须对上，F代表的是工厂对象，而该工厂对象创建的对象是T
    public <F extends Factory<T>>Need(F f){
        t = f.create();
    }
}

    public static void main(String[] args) {
        Need<A> need = new Need<>(new A.AFactory());
    }

模板方法设计模式

abstract class Factory<T>{

    public T create(){
        return real();
    }

    protected abstract T real();
}

class AFactory extends Factory<String>{

    @Override
    protected String real() {
        return "a";
    }
}

  public static void main(String[] args) {
        Factory<String> factory = new AFactory();
        String s = factory.create();
    }

15.8.2 泛型数组

public class Test {
    static A<Integer>[] as;
    @SuppressWarnings("unchecked")
    public static void main(String[] args) {
        // 并不能以这样的形势创建
        // as =  new A<Integer>[5];
        // 存在警告
        // 该数组在运行时依旧是Object数组
        // 创建泛型数组的方式就是创建一个被擦除类型的新数组，然后对其转型
        as = (A<Integer>[]) new A[5];
        as[0] = new A<>();
    }
}

class A<T>{}

泛型数组包装器

class FactoryArray<T>{
    private T[] ts;

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

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

    public void set(int index,T t){
        ts[index] = t;
    }

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

 public static void main(String[] args) {
        FactoryArray<Integer> factoryArray = new FactoryArray<>(5);
        factoryArray.set(0,1);
        Integer integer = factoryArray.get(0);
        /*
        数组将跟踪它们的实际类型，而这个类型是数组被创建时确定的，
        即时已被转型为Integer[],但这只存在于编译期，
        实际上它还是Object[]类型
         */
        // Integer[] integers = factoryArray.rep();
        Object[] objects = factoryArray.rep();
    }

另一种实现方式:内部使用Object[]储存

class FactoryArray<T>{
    private Object[] objects;

    @SuppressWarnings("unchecked")
    public FactoryArray(int size){
        objects = new Object[size];
    }

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

    public void set(int index,T t){
        objects[index] = t;
    }

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

public static void main(String[] args) {
    FactoryArray<Integer> factoryArray = new FactoryArray<>(5);
    factoryArray.set(0,1);
    Integer integer = factoryArray.get(0);
    // 无论何种方式都不能推翻底层的数组类型
    // 该种方式的好处是使我们认识到无论何时底层都是Object[]类型
    // Integer[] rep = factoryArray.rep();
    Object[] rep = factoryArray.rep();
}

获得确切类型的数组

class FactoryArray<T>{
    private T[] ts;

    @SuppressWarnings("unchecked")
    // 通过传入类型，来弥补擦除的类型
    public FactoryArray(Class<T> tClass,int size){
        ts = (T[]) Array.newInstance(tClass,size);
    }

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

    public void set(int index,T t){
        ts[index] = t;
    }

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

  public static void main(String[] args) {
        FactoryArray<Integer> factoryArray = new FactoryArray<>(Integer.class,5);
        // 这里会获得确切类型的数组
        Integer[] rep = factoryArray.rep();
    }

15.9 边界

边界可以用于泛型的参数类型上设置限制条件。

interface A{}

class B implements A{}

interface C extends A{}

class D{}

interface E{}

// 限定泛型的边界为A
class X<T extends A>{}

// T可以为多个的任意一个子类或实现类，第一个可以是类或接口，其他必须是接口
class Z<T extends D & A & E>{}

// T可以为任意A接口的继承接口或实现类的子实现类或子类，因为X已经限定了边界为A；
// 如果希望子类的泛型允许是多个的子类，则基类的泛型必须是接口，否则不符合上边的原理
class Y<T extends B & C> extends X<T>{}

15.10 通配符

数组向上转型存在的问题

class Fruit{}

class Apple extends Fruit{}

class BingApple extends Apple{}

class Orange extends Fruit{}

   public static void main(String[] args) {
        Fruit[] fruits = new Apple[5];
        fruits[0] = new Apple();
        fruits[1] = new BingApple();
        fruits[2] = new Orange(); // 抛出异常：ArrayStoreException
    }
/*
在编译期该数组向上转型是允许的，但是数组储存的就是其本来的类型，因此，在向Apple[]数组存入Orange[]数组时会出现异常
*/

尝试解决数组问题的一种方案

 public static void main(String[] args) {
        /*
        该种写法是不允许的，实际上，这不是向上转型，
        尽管Apple是Fruit的子类型，但是持有Apple类型的List
        不是持有Fruit类型的List的子类型。(可以这样理解，Fruit里包含
        的不仅仅是Apple类型，当存入Orange类型时，ArrayList就不能储存该
        类型；自动转型转的是List，不能把List中存的对象也转型了)
         */
        // List<Fruit> list = new ArrayList<Apple>();
    }

解决向上转型问题

  public static void main(String[] args) {
        /*
        该种形式是允许向上转型的，<? extends Fruit>代表的意思是
        这是Fruit的子类型，但是我不知道是哪个子类型。
        虽然向上转型成功了，但是并不能向里面放入Apple对象，因为
        其并不知道是哪个子类型。
        放入Fruit对象也不可以，因为里面存入的是Fruit的子类型，存
        Fruit类型相当于向下转型，因此是不可以的。
        但是，我们可以get一个Fruit对象，因为容器中的对象肯定是
        Fruit类型
         */
        List<? extends Fruit> list = new ArrayList<Apple>();
        // list.add(new Apple());
        // list.add(new Fruit());
    }

15.10.1 编译器有多聪明

   public static void main(String[] args) {
        List<? extends Fruit> list = new ArrayList<Apple>();
        Apple apple = (Apple) list.get(0);
        int index = list.indexOf(new Apple());
        boolean flag = list.contains(new Apple());
    }
/*
可以看到indexOf()等方法是可以接收各种类型的，为什么呢，因为他们的参数类型不是泛型，而是Object
*/

模拟上述案例

class Holder<T>{
    private T t;
    public Holder(T t){
        this.t = t;
    }
    public T get(){
        return t;
    }
    public void set(T t){
        this.t = t;
    }
    public boolean equals(Object obj){
        return t.equals(obj);
    }
}

public static void main(String[] args) {
        Holder<Apple> holder = new Holder<>(new Apple());
        Apple apple = holder.get();
        holder.set(new Apple());
        holder.equals(new Object());

        Holder<? extends Fruit> holder1 = holder;
        Fruit fruit = holder1.get();
        // holder1.set(new Apple()); // 不允许
        holder1.equals(new Object());
    }

15.10.2 逆变

超类型通配符<? super MyClass>或<? super T>。

   public static void main(String[] args) {
        List<? super Apple> list = new ArrayList<Apple>();
        list.add(new Apple());
        list.add(new BingApple());
    }

总结：

<? extends MyClass>表达的含义是继承基类的某个子类，强调的含义是子类；<? super MyClass>表达的含义是基类的子类，强调的含义是基类；前者并不知道是哪个子类，因此，并不能向容器中添加对象，而后者知道基类，基类就一个，肯定就是这个基类，因此可以添加基类及子类的对象。

class Holder{
    static  <T> void a(List<T> list,T t){
        list.add(t);
    }

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

    public static void f1(){
        a(new ArrayList<Apple>(),new Apple());
        a(new ArrayList<Fruit>(),new Apple());
    }

    public static void f2(){
        b(new ArrayList<Apple>(),new Apple());
        b(new ArrayList<Fruit>(),new Apple());
    }
}
/*
书上说在f1()方法中，第二行代码不可以，在实验中是可以的
*/

15.10.3 无界通配符

<?>表示使用泛型编码，而不是使用原生类型。

class A{
    List list1;
    List<?> list2;
    List<? extends Object> list3;
    void f1(List list){
        list1 = list;
        list2 = list;
        list3 = list; // 会有警告
    }

    void f2(List<?> list){
        list1 = list;
        list2 = list;
        list3 = list;
    }

    void f3(List<? extends Object> list){
        list1 = list;
        list2 = list;
        list3 = list;
    }
}
/*
总体看，并无区别
*/

多个泛型参数，需要一个参数确定，而其他不确定时

class A{
    Map map1;
    Map<String,?> map2;
    Map<?,?> map3;
    void f(Map map){
        map1 = map;
        // 有警告
        // 为什么？map的key可能是任意类型，而map2的key是String类型，因此，可能出错
        map2 = map;
        map3 = map;
    }
}

更加详细的使用

class WildCards{
    static void rawArgs(Holder holder,Object args){
        /*
        为什么会有警告？
        Holder是一个泛型类型，这里被表示为原生类型；只要使用了原生类型，都会放弃编译期检查，因此是不安全的
         */
        holder.set(args); // unchecked警告
        holder.set(new WildCards()); // unchecked警告
        Object o = holder.get();
    }

    static void unboundArgs(Holder<?> holder, Object args){
        /*
        和上面的例子做对比，大部分人认为，这里会报警告而不是错误。
        为什么会出现错误？因为Holder表示包含任意类型，而Holder<?>表示某种具体类型，
        但是我们不知道这种类型是什么。
         */
        // holder.set(args); // Error
        Object o = holder.get();
    }

    static <T> T exact1(Holder<T> holder,T t){
        holder.set(t);
        return holder.get();
    }

    static <T> T exact2(Holder<? extends T> holder,T t){
        // holder.set(t); // Error
        return holder.get();
    }

    static <T> void exact3(Holder<? super T> holder,T t){
        holder.set(t);
        // 该类的超类并不仅仅是一个
        // T t1 = holder.get(); // Error
        // 因此，只有Object类型才是安全的
        Object object = holder.get();
    }
    	// 对exact3的解释
       public static void main(String[] args) {
        List<? super Apple> list = new ArrayList<>();
        List<? super Fruit> list1 = new ArrayList<>();
        list = list1;
    }
}

15.10.4 捕获转换

向<?>参数传递原生类型参数，其会捕获原生类型的具体类型，从而可以向需要传递具体类型的需求传递该类型。

public class Test {
    public static void main(String[] args) {
        Holder<Integer> integerHolder = new Holder<>(1);
        f2(integerHolder);
        Holder holder = new Holder("a");
        f2(holder);
        Holder<?> wildCardHolder = new Holder<>(1.0);
        f2(wildCardHolder);
    }

    static <T>void f1(Holder<T> holder){
        System.out.println(holder.get().getClass().getSimpleName());
    }

    static void f2(Holder<?> holder){
        f1(holder);
    }
}
/*
如上，f2()先接收原生类型，再向f1()传递包含具体类型的参数。
但是，实际上直接调用f1()也是同样的效果。
可能是作者写书是用的JDK5，而在JDK7中已经有了类型推断这一功能。
*/

总结

可以看到，很多通过符组合，表示的意思是，其代表某种意思，但是我们不知道这个意思是什么，其大部分用途是在方法的形参上，让它代表这个意思，然后通过实参，传入具体的类型。

15.11 问题

基类类型不能用作泛型参数

public static void main(String[] args) {
        // List<int> list = new ArrayList<>();
        // 使用包装类型代替
        List<Integer> list = new ArrayList<>();
    }

public class Test {
    public static void main(String[] args) {
        // 自动包装机制局限：在数组中无法使用
        // int[] fs = f(new int[2]);
        //  int[] fs = f(new Integer[2]);
        Integer[] fs = f(new Integer[3]);
    }
    static <T> T[] f(T[] ts){
        return ts;
    }
}

实现参数化接口

一个类不能实现同一个泛型接口的两种变体。

interface A<T>{}

class B implements A<String>{}

// 编译不能通过
// class C extends B implements A<Integer>{}

如下写法可以

interface A<T>{}

class B implements A{}

class C extends B implements A{}

转型和警告

class A<T>{
    int index = 0;
    Object[] objects;
    A(int size){
        objects = new Object[size];
    }
    void push(T t){
        objects[index++] = t;
    }


    T pop(){
        // 警告
        // 因为泛型会被擦除，所以编译器无法知道转型是否安全
        return (T) objects[index--];
    }
}

有时泛型并不能消除转型需求

  public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream inputStream = new ObjectInputStream(null);
        // readObject()必须转型，但是它也不知道在读取什么
        // 泛型并没有消除转型需求
        List<String> list = (List<String>) inputStream.readObject();
        // 引入SE5的转型方式，但是仍然会产生警告(ps:那这有什么用。。。)
        list = (List<String>) List.class.cast(inputStream.readObject());
    }

重载

class A<W, T> {
    void f(List<W> list) {}
    void f(List<T> list){}
}
/*
由于泛型擦除，上述重载方法会产生相同的类型签名
*/

基类劫持了接口

class Pet implements Comparable<Pet>{
    @Override
    public int compareTo(Pet o) {
        return 0;
    }
}

// 一旦为接口确定了泛型参数，子类就不能做改变
// class SubPet extends Pet implements Comparable<SubPet>{}

class OtherPet extends Pet implements Comparable<Pet>{}

15.12 自限定的类型

自限定

class SelfBounded<T extends SelfBounded<T>>{
    private T t;
    public T get(){
        return t;
    }
    public void set(T t){
        this.t = t;
    }

    @Override
    public String toString() {
        return t.getClass().getSimpleName();
    }
}
class A extends SelfBounded<A>{}

class C extends SelfBounded<A>{}

	// 也可以用于方法
  static <T extends SelfBounded<T>> T f(T t){
        return t;
    }

    public static void main(String[] args) {
        A a = new A();
        a.set(a);
        A a1 = a.get();
        System.out.println(a);
        C c = new C();
        c.set(a1);
    }
/*
可以限定子类的泛型参数必须是SelfBounded的子类型
*/

疑问：

class SelfBound<T extends SelfBound>{
    private T t;
    public T get(){
        return t;
    }
    public void set(T t){
        this.t = t;
    }

    @Override
    public String toString() {
        return t.getClass().getSimpleName();
    }
}
/*
如上写法也是可以达到相同效果的，这两种有什么区别
*/

参数协变

自限定类型的价值在于它们可以产生协变参数类型——方法参数类型会随子类而变化。

返回类型：

class Base{}

class Drived extends Base{}

interface OrdinaryGatter{
    Base get();
}

interface DrivedGatter extends OrdinaryGatter{
    // 返回具体类的接口，需要重写接口
    @Override
    Drived get();
}

interface OrdinaryGatter<T extends OrdinaryGatter<T>>{
    T get();
}
// 使用自限定类型不需要重写接口
interface DrivedGatter extends OrdinaryGatter<DrivedGatter>{

}

 public static void main(String[] args) {
        DrivedGatter drivedGatter = null;
        drivedGatter.get();
    }

参数：

class OrdinarySatter{
    void set(Base base){}
}

class DrivedSatter extends OrdinarySatter{
    // 无法编译
    @Override // 注释后，会重载，产生两个set方法
    void set(Drived base) {}
}

// 使用自限定后可以让子类参数产生变化
interface OrdinarySatter<T extends OrdinarySatter<T>>{
    void set(T t);
}

interface DrivedSatter extends OrdinarySatter<DrivedSatter>{
}

  static void f(DrivedSatter satter){
        satter.set(satter);
    }

15.13 动态类型安全

由于以前代码不存在泛型机制，Java工具类Collections中提供了一系列的工具。

public class Test {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add(new Dog());
        fCat(list);
        List<Dog> dogList = Collections.checkedList(new ArrayList<>(), Dog.class);
        dogList.add(new Dog());
        fCat(dogList); // ClassCastException
        List<Pet> petList = Collections.checkedList(new ArrayList<>(), Pet.class);
        petList.add(new Dog());
        petList.add(new Cat());
        fCat(petList);
    }

    static void fCat(List list){
        list.add(new Cat());
    }
}

15.14 异常

抛出泛型异常

class Failure extends Exception{}

interface Process<E extends Exception>{
    void f() throws E;
}

class RunProcess implements Process<Failure>{

    @Override
    public void f() throws Failure {
        throw new Failure();
    }
    
      <F extends Exception> void e(){
        // 并不允许catch泛型异常
        /*
        try {
        }catch (F f){
        }
        */
    }
}

15.15 混型

混型 最基本的概念是混合多个类型的能力，以产生一个表示混型中所有类的能力。

混型的价值之一就是可以将特性和行为一致地应用于多个类之上；如果在混型类中修改某些东西，这些修改会应用于混型所应用的所有类型之上。

15.15.2 与接口混合

// 时间戳接口
interface TimeStamped{
    long getStamp();
}

class TimeStampedImpl implements TimeStamped{
    @Override
    public long getStamp() {
        return new Date().getTime();
    }
}

// 序列号
interface Number{
    int getNumber();
}

class NUmberImpl implements Number{
    private static int i = 0;
    @Override
    public int getNumber(){
        return ++i;
    }
}

class Basic{
    private String val;

    public String getVal() {
        return val;
    }

    public void setVal(String val) {
        this.val = val;
    }
}
// 混合类
// 实现相应的接口
class Mixin extends Basic implements TimeStamped,Number{
    // 每个混入类型都需要有相应的域
    private TimeStamped timeStamped = new TimeStampedImpl();
    private Number number = new NUmberImpl();
    @Override
    public long getStamp() {
        // 将功能交由具体类实现
        return timeStamped.getStamp();
    }

    @Override
    public int getNumber() {
        return number.getNumber();
    }
}

 public static void main(String[] args) {
        Mixin mixin = new Mixin();
        mixin.setVal("一混型");
        System.out.println(new StringBuilder(mixin.getVal())
                .append(" ")
                .append(mixin.getNumber())
                .append(" ")
                .append(mixin.getStamp())); // 一混型 1 1604302754656
    }

15.15.3 使用装饰器模式

装饰器模式使用分层对象来动态透明地向单个对象中添加责任，装饰器类和被装饰者有相同的接口。装饰器经常用于满足各种可能的组合，但是直接子类化，会产生过多的类。

// 装饰器类
class Decorator extends Basic{
    private Basic basic;
    public Decorator(Basic basic) {
        this.basic = basic;
    }

    @Override
    public String getVal() {
        return super.getVal();
    }

    @Override
    public void setVal(String val) {
        super.setVal(val);
    }
}

class NUmberImpl extends Decorator{
    private static int i = 0;

    public NUmberImpl(Basic basic) {
        super(basic);
    }
    // 可以添加自己的方法，但是具有局限性
    public int getNumber(){
        return ++i;
    }
}

class TimeStampedImpl extends Decorator{
    public TimeStampedImpl(Basic basic) {
        super(basic);
    }
    public long getStamp() {
        return new Date().getTime();
    }
}

 public static void main(String[] args) {
        NUmberImpl nUmber = new NUmberImpl(new Basic());
        TimeStampedImpl timeStamped = new TimeStampedImpl(nUmber);
    }

15.15.4 与动态代理混合

class MixinProxy implements InvocationHandler{
    private Map<String,Object> map;
    // 要代理的对象
    // 由于动态代理的限制，每个要混入的类必须是某个接口的实现
    public MixinProxy(/*代理对象和对应Class*/Map<Object,Class> maps) throws IllegalAccessException, InstantiationException {
        map = new HashMap<>();
       for(Map.Entry<Object,Class> entry:maps.entrySet()){
           for (Method method : entry.getValue().getMethods()) {
               // 将方法名与对象绑定
               map.put(method.getName(),entry.getKey());
           }
       }
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String name = method.getName();
        return method.invoke(map.get(name),args);
    }

    // 创建实例
    public static Object newInstance(Map<Object,Class> maps) throws InstantiationException, IllegalAccessException {
        MixinProxy mixinProxy = new MixinProxy(maps);
        List<Class> list = new ArrayList<>();
        for(Map.Entry<Object,Class> entry:maps.entrySet()){
            list.add(entry.getValue());
        }
        Class[] interfaces = new Class[list.size()];
        // List转数组
        list.toArray(interfaces);
        return Proxy.newProxyInstance(list.get(0).getClassLoader(),interfaces ,mixinProxy);
    }
}

 public static void main(String[] args) throws IllegalAccessException, InstantiationException {
        Map<Object,Class> map = new HashMap<>();
        map.put(new TimeStampedImpl(),TimeStamped.class);
        map.put(new NUmberImpl(),Number.class);

       Object o = MixinProxy.newInstance(map);
     
       // 缺点是必须强转为指定的类型
       TimeStamped timeStamped = (TimeStamped) o;
        System.out.println(timeStamped.getStamp()); // 1604306931322
        Number number = (Number) o;
        System.out.println(number.getNumber()); // 1
    }

15.16 潜在类型机制

编程要具有的思想：编写尽可能广泛地应用的代码，为了实现这一点，我们需要各种途径放松代码对类型所做的限制，同时不丢失静态类型检查的好处。

但是Java中当要在泛型上执行操作时，擦除会要求擦除到泛型的边界，这就对泛型的使用做了限制。

某些其他语言提供了一种潜在类型机制，只需要实现某个方法的子集，而不是特定的类或接口。

潜在类型机制是一种代码组织和复用机制，有了它编写的代码更加容易复用。

python示例：

class Dog:
    def speak(self):
        print "Arf"
    def sit(self):
        print "Sitting"

class Robot:
    def speak(self):
        print "Click"
    def sit(self):
        print "Clank"

def perform(anything):
    anything.speak()
    anything.sit()

a = Dog()
b = Robot()
perform(a)
perform(b)
# 可以看到Dog和Robot并没有什么关系，除了他们有两个同名方法。

15.17 对缺乏潜在类型机制的补偿

尽管Java不支持泛型机制，但仍然可以创建真正的泛型代码

反射

class Mime{
    public void sit(){
        System.out.println("我坐下");
    }

    @Override
    public String toString() {
        return "我";
    }
}

class Dog{
    public void sit(){
        System.out.println("狗坐下");
    }
    public void speak(){
        System.out.println("狗叫");
    }
}

public class Test2 {

    public static void perform(Object o){
        Class<?> aClass = o.getClass();
        try {
            Method sit = aClass.getMethod("sit");
            sit.invoke(o);
        } catch (Exception e) {
            // 同时可以处理异常
            System.out.println(o+"不能坐");
        }
        try {
            Method speak = aClass.getMethod("speak");
            speak.invoke(o);
        } catch (Exception e) {
            System.out.println(o+"不能说");
        }
    }

    public static void main(String[] args) {
        perform(new Mime());
        perform(new Dog());
    }
}

将一个方法应用于序列

实现编译器检查和潜在类型机制

将任意方法应用于对象的集合。

class Shape{
    public void dis(){
        System.out.println("未固定形状");
    }
}

class Round extends Shape{
    @Override
    public void dis() {
        System.out.println("圆形");
    }
}

public class Test2 {

    public static void main(String[] args) throws NoSuchMethodException {
        List<Shape> shapeList = new ArrayList<>();
       shapeList.add(new Shape());
       shapeList.add(new Round());
        Random random = new Random();
        apply(shapeList,shapeList.get(0).getClass().getMethod("dis"));
    }
	// T代表集合中的对象，S代表集合
    // 泛型中的意思：S必须继承Iterable(代表其是集合)，后者的泛型代表，集合中存入的元素
    // 是T及其子类
    public static <T,S extends Iterable<? extends T>>void apply(S list,Method f,Object...args){
        try {
            for (T o:list){
                f.invoke(o,args);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

当你并未碰巧拥有正确的接口时

public class Test2 {
    public static void main(String[] args) throws NoSuchMethodException {
        apply(new ArrayList<>(),Shape.class,3);
    }
	
    // 该方法并不能接收MyList，尽管其也有add()方法
    // 这证明了潜在类型的价值，Java没有该机制，所以会受到特定类型的限制l
    public static <T>void apply(List<T> list,Class<? extends T> c,int num){
        try {
            for (int i = 0; i < num; i++) {
                list.add(c.newInstance());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } 
    }
}

class MyList<T>{
    public void add(T t){}
}

用适配器仿真潜在类型机制

// 接口
interface Addable<T>{
    void add(T t);
}

class Fill2{
    // 仅接受Addable
    public static <T> void fill(Addable<T> addable,Class<T> c,int num){
        try {
            for (int i = 0; i < num; i++) {
                addable.add(c.newInstance());
            }
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

// 适配器：将集合适配Addable
class AddableCollectionAdapter<T> implements Addable<T>{
    private Collection<T> collection;

    public AddableCollectionAdapter(Collection<T> collection) {
        this.collection = collection;
    }

    @Override
    public void add(T t) {
        collection.add(t);
    }
}

   public static void main(String[] args) throws NoSuchMethodException {
        Fill2.fill(new AddableCollectionAdapter<>(new ArrayList<>()),Shape.class,2);
    }

15.18 将函数对象用作策略

主要介绍了下策略模式的应用；

// 操作两个数
interface Combiner<T> {
    T combine(T x, T y);
}

// 一元函数
interface UnaryFunction<R,T>{
    R function(T t);
}

// 在一元函数基础上增加最终结果的接口
interface Collector<T> extends UnaryFunction<T,T>{
    T result();
}

// 一元谓词
interface UnaryPredicate<T>{
    boolean test(T t);
}

class IntegerAdder implements Combiner<Integer>{

    @Override
    public Integer combine(Integer x, Integer y) {
        return x+y;
    }
}

class IntegerSub implements Combiner<Integer>{
    @Override
    public Integer combine(Integer x, Integer y) {
        return x - y;
    }
}

class BigIntegerAdder implements Combiner<BigInteger>{
    @Override
    public BigInteger combine(BigInteger x, BigInteger y) {
        return x.add(y);
    }
}

class BigDecimalUlp implements UnaryFunction<BigDecimal,BigDecimal>{
    @Override
    public BigDecimal function(BigDecimal bigDecimal) {
        // 返回一个数字和距其最近的数字之间的距离
        return bigDecimal.ulp();
    }
}

// 实现比较
class GreaterThan</*实现比较接口*/T extends Comparable<T>> implements UnaryPredicate<T>{
    private T bound;

    public GreaterThan(T bound) {
        this.bound = bound;
    }

    @Override
    public boolean test(T x) {
        return x.compareTo(bound)>0;
    }
}

class MultIntegerCollector implements Collector<Integer>{
    private Integer val = 1;
    @Override
    public Integer function(Integer integer) {
        val *= integer;
        return val;
    }

    @Override
    public Integer result() {
        return val;
    }
}

// 函数处理类
class Functional{

    public static void main(String[] args) throws NoSuchMethodException, ScriptException {
        // 执行函数，获得结果
        List<Integer> integerList = Arrays.asList(1,2,3,4,5);
        Integer i = reduce(integerList,new IntegerAdder());
        System.out.println(i); // 累加 15
        i = reduce(integerList,new IntegerSub());
        System.out.println(i); // 累减 -13
        List<BigInteger> bigIntegerList = Arrays.asList(
                new BigInteger("1"),new BigInteger("2"),
                new BigInteger("3"));
        BigInteger bigInteger = reduce(bigIntegerList, new BigIntegerAdder());
        System.out.println(bigInteger); // 大整数累加 6

        // 获得函数处理后的结果
        Collector<Integer> collector = forEach(integerList, new MultIntegerCollector());
        System.out.println(collector.result()); // 120

        // 将集合执行后的结果存入List中返回
        List<BigDecimal> bigDecimalList =  Arrays.asList(
                new BigDecimal("1"),new BigDecimal("2"),
                new BigDecimal("3"));
        List<BigDecimal> transform = transform(bigDecimalList, new BigDecimalUlp());
        System.out.println(transform); // [1, 1, 1]

        // 返回符合结果的集合
        List<BigInteger> filter = filter(bigIntegerList, new GreaterThan<>(new BigInteger("2")));
        System.out.println(filter); // [3]
    }

    // 累计处理获得结果
    public static <T> T reduce(/*可迭代的集合*/Iterable<T> seq,Combiner<T> combiner){
        // 获得迭代器
        Iterator<T> iterator = seq.iterator();
        // 为什么不直接使用while？combine()方法需要两个参数，
        if (iterator.hasNext()){
            T result = iterator.next();
            while (iterator.hasNext()){
                result = combiner.combine(result,iterator.next());
            }
            return result;
        }
        return null;
    }

    // 执行一元函数
    // 通过接口定义参数，这里用到了策略模式，可以传入不同具体的实现
    public static <T> Collector<T> forEach(Iterable<T> seq,Collector<T> func){
        for (T t : seq) {
            func.function(t);
        }
        return func;
    }

    // 将集合执行后的结果存入List中返回
    public static <R,T> List<R> transform(Iterable<T> seq,UnaryFunction<R,T> func){
        List<R> result = new ArrayList<>();
        for (T t : seq) {
            result.add(func.function(t));
        }
        return result;
    }

    // 将集合中符合规则的元素存入List
    public static <T> List<T> filter(Iterable<T> seq,UnaryPredicate<T> pred){
        List<T> result = new ArrayList<>();
        for (T t : seq) {
            if (pred.test(t)){
                result.add(t);
            }
        }
        return result;
    }
}

15.19 总结

• 泛型最大的价值体现在容器类的使用中；
• 在容器中获得Object对象并转型，出现错误并无法发现并不常见；
• 将容器对象合理命名可以很好的避免这种情况；
• 如此显著和复杂的特性（泛型）并非仅仅为了解决转型的错误；
• 泛型更重要的目的在于表达性；
• 正如泛型的名字，目的是创建出更通用的代码。