小宏ye

泛型

当每一章阅读的时候，首先这个概念为什么会出现，有什么用，而根据这个概念的运用，为什么这么用，有什么好处。我觉得这个对理解概念的东西会事半功倍。

简单泛型（基本都是介绍设计代码的用法）

泛型接口

泛型方法

匿名内部类（可以在匿名内部类中使用泛型）、构建复杂模型（其实也就是多维元组）

擦除（这才是我们应该需要去记住的东西）

擦除的补偿

边界

通配符

捕获异常

自限定的类型

动态类型安全（如何使用）

异常（当一种工具使用，不做详解）

混型（混合多个类）

潜在类型机制（需要知道）

缺乏潜在类型机制的补偿

总结

简单泛型（基本都是介绍设计代码的用法）

public class Holder3 {
  private T a;
  public Holder3(T a) { this.a = a; }
  public void set(T a) { this.a = a; }
  public T get() { return a; }
  public static void main(String[] args) {
    Holder3 h3 =
      new Holder3(new Automobile());
      Automobile a = h3.get(); // No cast needed
  }
}

上面例子使用了泛型可以返回任意一个对象，这就是一个简单泛型的使用。这样带给我们什么好处呢，假设我们有一个苹果类跟一个毛巾类，而我们需要做一个洗东西的类，这个时候可以将苹果对象跟毛巾对象传入洗类中，苹果跟毛巾是两种不同的东西，那么就没办法使用多态了，这个时候就需要写一个洗毛巾跟一个洗苹果的类，显得过于繁琐，使用泛型就可以做一个公用的类传入苹果或者是毛巾了，显得代码更加简洁。

元组类库(就是一个对象持有多个对象)

元组（又称为数据传送对象或者是信使），并且进行读取并且在进行初始化操作之后不能添加新的对象。下面是一个三维元组继承一个二维元组，这样final定义了C类是初始化之后无法修改，也可以使用private进行修饰。如果你想别人使用这个类可以直接调用C作为赋值就可以使用public final进行修饰，final会保护数据不会被修改。

public class ThreeTuple extends TwoTuple {
  public final C third;
  public ThreeTuple(A a, B b, C c) {
    super(a, b);
    third = c;
  }
  public String toString() {
    return "(" + first + ", " + second + ", " + third +")";
  }
}

一个堆栈类（其实是泛型的一个使用，做一个类型堆栈的，也就是像堆砖头一样取对象是后放的先出）

public class LinkedStack {
  private static class Node {
    U item;
    Node next;
    Node() { item = null; next = null; }
    Node(U item, Node next) {
      this.item = item;
      this.next = next;
    }
    boolean end() { return item == null && next == null; }
  }
  private Node top = new Node(); // End sentinel
  public void push(T item) {
    top = new Node(item, top);
  }	
  public T pop() {
    T result = top.item;
    if(!top.end())
      top = top.next;
    return result;
  }
  public static void main(String[] args) {
    LinkedStack lss = new LinkedStack();
    for(String s : "Phasers on stun!".split(" "))
      lss.push(s);
    String s;
    while((s = lss.pop()) != null)
      System.out.println(s);
  }
} /* Output:
stun!
on
Phasers
*///:~

书中这个例子就是，把Node通过pop()赋值给自己，然后默认item与next为null，而end()作为一个哨兵机制判断是否为null，然后取Node对象时，将最上层对象赋值给top，一直循环直到end()判断为null，就可以作为一个栈堆类来使用。

RandomList（一个工具类，返回List中随机的某一个元素，同样也可以改造成Map、Set，下面例子理解一下就可以明白了）

public class RandomList {
  private ArrayList storage = new ArrayList();
  private Random rand = new Random(47);
  public RandomList(List list){storage=list;}
  public void add(T item) { storage.add(item); }
  public T select() {
    return storage.get(rand.nextInt(storage.size()));
  }
  public static void main(String[] args) {
    RandomList rs = new RandomList();
    for(String s: ("The quick brown fox jumped over " +
        "the lazy brown dog").split(" "))
      rs.add(s);
    for(int i = 0; i < 11; i++)
      System.out.print(rs.select() + " ");
  }
    RandomList rs = new RandomList(rs);
  for(int i = 0; i < 11; i++)
      System.out.print(rs.select() + " ");
  }
}

泛型接口

简单讲解下下面例子，Gennerator是一个生成器接口，而使用泛型成为了一个泛型接口，这个时候，生成器时可以复用的，CoffeeGenerator可以返回Coffee,假设我还有一个Tea类也去实现这个Gennerator生成器，而在我们进行调用时，可以根据多态调用到我们传入的Coffee或者是Tea，生成对应的Coffee或者是Tea对象。假如我们不使用泛型接口，那么我们要做到复用生成器，首先需要编写Gennerator抽象类，继承，但是这样的话，没有办法多重继承，可能会让我们的代码更加复杂。

public interface Generator { T next(); } ///:~

public class CoffeeGenerator
implements Generator, Iterable {
  private Class[] types = { Latte.class, Mocha.class,
    Cappuccino.class, Americano.class, Breve.class, };
  private static Random rand = new Random(47);
  public CoffeeGenerator() {}
  // For iteration:
  private int size = 0;
  public CoffeeGenerator(int sz) { size = sz; }	
  public Coffee next() {
    try {
      return (Coffee)
        types[rand.nextInt(types.length)].newInstance();
      // Report programmer errors at run time:
    } catch(Exception e) {
      throw new RuntimeException(e);
    }
  }
  class CoffeeIterator implements Iterator {
    int count = size;
    public boolean hasNext() { return count > 0; }
    public Coffee next() {
      count--;
      return CoffeeGenerator.this.next();
    }
    public void remove() { // Not implemented
      throw new UnsupportedOperationException();
    }
  };	
  public Iterator iterator() {
    return new CoffeeIterator();
  }
  public static void main(String[] args) {
    CoffeeGenerator gen = new CoffeeGenerator();
    for(int i = 0; i < 5; i++)
      System.out.println(gen.next());
    for(Coffee c : new CoffeeGenerator(5))
      System.out.println(c);
  }
}

泛型方法

首先对于泛型方法的使用，在返回类型前加上泛型，如果不加，当T作为参数编译器会报错

public  T f(T x) {
    return x;
  }

同时泛型方法也可以跟可变参数共存

public  void f(T... x) {
    //code
  }

泛型方法可以自动做“类型参数推断（type argument inference）”,也就是说当你传入一个参数，如果是String，会自动将参数转换为String。但是这里需要注意的是，当执行String result = f("String");类型参数推断会自动将返回值转换为String。但是看下面例子

public void show(String a){}

执行show( f("String"));时会编译器报错，因为当你返回时作为参数，因为没有赋值，所以赋值给Object变量，导致编译会出问题。这个时候就需要转换，show( f("String"))在调用前加入泛型说明。

类型参数推断有什么用呢，看下面，类型参数推断可以在赋值是自动转化省去了一些功夫，但是假设别人需要去使用New类，也需要时间去理解代码的含义，所以“很讽刺”，使用本意是让代码看起来通俗易懂，假设这个New很复杂，需要去花大量的时间去理解含义，所以“很难说它为我们带来了多少好处”，这也是杠杆利用类型参数判断，根据场景权衡。

public class New {
  public static  Map map() {
    return new HashMap();
  }
  public static  List list() {
    return new ArrayList();
  }
  public static  LinkedList lList() {
    return new LinkedList();
  }
  public static  Set set() {
    return new HashSet();
  }	
  public static  Queue queue() {
    return new LinkedList();
  }
  // Examples:
  public static void main(String[] args) {
    Map> sls = New.map();
    List ls = New.list();
    LinkedList lls = New.lList();
    Set ss = New.set();
    Queue qs = New.queue();
  }
}

书中还有很多用法，这里不列举了，我们需要了解的泛型方法的意义，使用方法以及类型推断能够给我们带来的好处，就不必强记一些用法了，想透自然会懂。

匿名内部类（可以在匿名内部类中使用泛型）、构建复杂模型（其实也就是多维元组）

擦除（这才是我们应该需要去记住的东西）

何为擦除，看下面，c1和c2应该是不相同的两种类型

  Class c1 = new ArrayList().getClass();
  Class c2 = new ArrayList().getClass();

但是,输出结果发生结果为true，这就奇怪了

System.out.println(c1 == c2);//true

而得出的结论：，虽然看起来两个List操作起来会不同，但是真正代码上，其实泛型擦除了ArrayList()和ArrayList()的String、Integer成为了默认的List类型，而不是两种不同的类型。其实用通俗点的话就是，使用泛型是让编译器去规范传入的类型参数，有问题报错而不是在启动程序之后才报错。下面具体理解擦除和如何去处理。

首先，擦除给我们带来什么影响。

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

class Manipulator {
  private T obj;
  public Manipulator(T x) { obj = x; }
  // Error: cannot find symbol: method f():
  // public void manipulate() { obj.f(); }
}

public class Manipulation {
  public static void main(String[] args) {
    HasF hf = new HasF();
    Manipulator manipulator =
      new Manipulator(hf);
    manipulator.manipulate();
  }
}

注释的manipulate()方法调用obj.f()方法是不通过的，这是什么原因。尽管编译器知道有HasF有f()方法，照理来说它应该可以进行匹配把f()映射到obj.f()上可以编译通过，但是由于泛型的擦除导致了这个参数变为了Object，而c++是可以的，但JAVA又是受到了C语言的启发，所以这相对于C++甚至是C#来说是有缺陷的，这也会导致我们可能在做一些操作上需要添加上一个边界来让编译器去进行映射，如下通过extends来规定一个范围，一个边界，编译器才能去进行映射。

class Manipulator2 {
  private T obj;
  public Manipulator2(T x) { obj = x; }
  public void manipulate() { obj.f(); }
}

但是这样的话我完全可以使用 Manipulator2(HasF x)不使用泛型也可以实现，这个得好处只能是说作为一个返回值可以通过上面说的泛型的类型推断来返回一个确切的HasF类型（他自己活着其导出类）。

擦除来实现迁移兼容性

简单来说c++在编译期，会把你传入泛型有几个类型就帮你生成多少份模板，拿简单的例子，public void manipulate(T a) { a.f(); },你传入一个A类型跟一个B类型，在编译之后，会帮你生成两份模板，A.f()跟B.f()，这样就可以做到运行期确切类型信息的调用，虽然这样做你传入类型越多生成模板也多，不利于代码共享。而C#更加完善了，“首先在编译时，c#会将泛型编译成元数据，即生成.net的IL Assembly代码。并在CLR运行时，通过JIT（即时编译），将IL代码即时编译成相应类型的特化代码。”，这样代码共享就优化了。

那既然JAVA是受到c语言的启发，那么为什么不能做得更好呢，你想想在写代码的时候，我明明知道两个类型的确切信息，虽然这他们不是同一类型，但是他们的共同的信息可以被一个泛型类调用，但是JAVA泛型擦除阻止了这个情况，导致泛型的泛化性受到了限制。原因很简单，为了“迁移兼容性”。

class SimpleHolder{
    private Object obj;

    public Object getObj() {
        return obj;
    }

    public void setObj(Object obj) {
        this.obj = obj;
    }
}

SimpleHolder holder = new SimpleHolder();
holder.setObj("Item");
String s = (String)holder.getObj();

class GenericHolder{
    private T obj;

    public T getObj() {
        return obj;
    }

    public void setObj(T obj) {
        this.obj = obj;
    }
}

GenericHolder holder = new GenericHolder();
holder.setObj("Item");
String s = holder.getObj();
//上面一个泛型跟一个非泛型在JVM是的汇编码是一样的看下面，这样也就说，擦除可以让非泛型跟泛型代码很好的共存，不会影响到现有非泛型的汇编块！
aload_1
invokevirtual // Method get: ()Object
checkcast // class java/lang/String
astore_2
return

JAVA在SE5之后才推出泛型，那么SE5之前的类库以及大量的代码如果不通过擦除那么在JVM的汇编码将无法兼容通过泛型编写的代码，也就是说不通过擦除，SE5之前的很多类库将不能在新的版本之后运行，而类库对效率提升有很大帮助，而且推出JAVA推出泛型前已经有了很多的类库，这样做的代价太大，同时也避免了JVM的大换血。

擦除的补偿

既然擦除让我们在运行期需要确切类型信息的操作（instanceof关键字，new，转型等）都无法工作

补偿一：如果想使用instanceof可以使用T.isInstance(类型)。

补偿二：new不成功，一部分是因为擦除，一部分是编译器无法验证泛型是否有默认构造器。可以使用工厂对象Class通过类型便签Class class = T.newInstance()，但是如果你传入的类型没有默认构造器则会出问题，但是在编译的时候无法检测，等你运行时才会报错。

1.这样可以通过显式工厂对象（如果使用newInstance()这是在运行时才会执行，所以是隐式的），也可以叫做工厂设计模式

interface FactoryI {
  T create();
}

class Foo2 {
  private T x;
  public > Foo2(F factory) {
    x = factory.create();
  }
  // ...
}

//通过IntegerFactory工厂返回 new Integer(0)，然后传入上面的x=new Integer(0)，这样如果你在下面的工厂类写错了，在写代码的时候就会报错了，编码了运行才报错的尴尬。
class IntegerFactory implements FactoryI {
  public Integer create() {
    return new Integer(0);
  }
}	


public class FactoryConstraint {
  public static void main(String[] args) {
    new Foo2(new IntegerFactory());
  }
}

2.通过模板方法设计模式

//在构造自己的时候调用自己的方法创建一个自己编写的返回类型
abstract class GenericWithCreate {
  final T element;
  GenericWithCreate() { element = create(); }
  abstract T create();
}

泛型数组使用ArrayList来代替，如果真的想用到数组，你要知道的因为擦除，所以T[]实际上就是Object[]，要牢记这点，不然当运行起来可能会让我们折返回来重构代码。

边界


class HoldItem {
  T item;
  HoldItem(T item) { this.item = item; }
  T getItem() { return item; }
}

class Colored2 extends HoldItem {
  Colored2(T item) { super(item); }
  java.awt.Color color() { return item.getColor(); }
}
class ColoredDimension2
extends Colored2 {
  ColoredDimension2(T item) {  super(item); }
  int getX() { return item.x; }
  int getY() { return item.y; }
  int getZ() { return item.z; }
}

Colored2 这是我们之前的用法为了让T能够调用HasColor的方法，在 Colored2 再重用extend，Colored2 extends HoldItem，就可以调用HasColor跟HoldItem的信息，下面也一样，知道就行。

通配符

先展示数组的一种特殊行为：

class Fruit {}
class Apple extends Fruit {}
class Jonathan extends Apple {}
class Orange extends Fruit {}

    Fruit[] fruit = new Apple[10];
    fruit[0] = new Apple(); // OK
    fruit[1] = new Jonathan(); // OK
 // Compiler allows you to add Fruit:
      fruit[0] = new Fruit(); // ArrayStoreException
 // Compiler allows you to add Oranges:
      fruit[0] = new Orange(); // ArrayStoreException

Fruit[] fruit = new Apple[10]，将Apple数组赋予其基类Fruit数组的引用。编译器知道Apple是Fruit的导出类所以编译通过，并且fruit[0] = new Apple()，fruit[1] = new Jonathan()，可以将Apple或它的导出类赋值给自己编译器也能编译通过， fruit[0] = new Fruit()，fruit[0] = new Orange()编译器能通过上面这个，因为编译器知道这是向Apple数组赋予Fruit数组的引用，那Fruit和它自己的导出类Orange当然属于数组存放的类型，那么当然这样写是可以的。但是到真正运行的时候，数组机制知道这个引用需要处理的Apple数组，所以只能是Apple即他的导出类可以转型，尽管Fruit是Apple的基类，数组机制不管，他只知道我处理的是Apple类型。

这个不难理解，也容易排查，但是使用泛型可以把这种运行时才会出异常挪到了编译的时候。

  Fruit[] fruit = new Apple[10];
 // Compile Error: incompatible types:
  List flist = new ArrayList();

数组赋予可以，但是在使用泛型容器的时候就失败，因为编译器通过泛型它只知道Fruit的List不是Apple的List，尽管我们知道两个类型有继承关系，但是编译器不知道，所以禁止了这样的赋予引用，也就在编译期防止了上面的情况。如果想让他通过，你必须让编译器知道可以改成 List<？ entends Fruit> flist = new ArrayList()，但是请注意？ entends Fruit只是告诉编译器一个边界，当你flist.add(new Apple()); flist.add(new Fruit());这都是编译器禁止的，因为编译器知道这个边界，但是add()传入的参数也是？ entends Fruit表示任何来自Fruit的类型，但是也正是任何类型，编译器无法保证这个转型的安全性，所以禁止了。

那既然如此，下面这个例子就比较好理解了，我在其中加入了理解。

public class Holder {
  private T value;
  public Holder() {}
  public Holder(T val) { value = val; }
  public void set(T val) { value = val; }
  public T get() { return value; }
  public boolean equals(Object obj) {
    return value.equals(obj);
  }	
  public static void main(String[] args) {
    Holder Apple = new Holder(new Apple());
    Apple d = Apple.get();
    Apple.set(d);
    // Holder Fruit = Apple; //Cannot upcast 这里就是跟刚开始说的一样，编译器只知道Holder 不是Holder，尽管我们自己知道这两个类型是关联的，但是编译器不知道！
    Holder fruit = Apple; // OK  给定一个边界，让编译器知道是任何继承Fruit的类型，那Holder编译器就知道属于一种类型，所以允许了这样的赋值。
    Fruit p = fruit.get();
    d = (Apple)fruit.get(); // Returns 'Object' 好了，上面说了泛型通过? extends Fruit知道边界，但是擦除返回Object，而这本身给自己赋值当然能够通过编译和运行
    try {
      Orange c = (Orange)fruit.get(); // No warning
    } catch(Exception e) { System.out.println(e); }
    // fruit.set(new Apple()); //Cannot call set() 但是下面这两行，就跟我们刚才那段话编译器知道这个边界，但是add()传入的参数也是？ entends Fruit表示任何来自Fruit的类型，但是也正是任何类型，编译器无法保证这个转型的安全性，所以禁止了，set也一样只知道参数也是？ entends Fruit，所以编译器不让通过
    // fruit.set(new Fruit()); // Cannot call set()
    System.out.println(fruit.equals(d)); // OK 而这里传入的Object，当然可以
  }
} /* Output: (Sample)
java.lang.ClassCastException: Apple cannot be cast to Orange
true
*///:~

逆变（超类型通配符）

上面说到List<？ entends Fruit> flist = new ArrayList()这个通配符无法add()，这个时候可以使用“逆变”List<？ super Fruit> flist = new ArrayList(),那这样flist.add(new Apple()); flist.add(new Fruit());就是允许的。

如果使用泛型方法的协变与通配符配合，在调用的时候可以顺畅很多，这里就不做解释了（懒~~）。

public class GenericReading {
  static  T readExact(List list) {
    return list.get(0);
  }
  static List apples = Arrays.asList(new Apple());
  static List fruit = Arrays.asList(new Fruit());
  // A static method adapts to each call:
  static void f1() {
    Apple a = readExact(apples);
    Fruit f = readExact(fruit);
    f = readExact(apples);
  }
  // If, however, you have a class, then its type is
  // established when the class is instantiated:
  static class Reader {
    T readExact(List list) { return list.get(0); }
  }	
  static void f2() {
    Reader fruitReader = new Reader();
    Fruit f = fruitReader.readExact(fruit);
    // Fruit a = fruitReader.readExact(apples); // Error:
    // readExact(List) cannot be
    // applied to (List).
  }
  static class CovariantReader {
    T readCovariant(List list) {
      return list.get(0);
    }
  }
  static void f3() {
    CovariantReader fruitReader =
      new CovariantReader();
    Fruit f = fruitReader.readCovariant(fruit);
    Fruit a = fruitReader.readCovariant(apples);
  }	
  public static void main(String[] args) {
    f1(); f2(); f3();
  }
} ///:~

无界通配符（<？>）

书里长篇大论，这里做个总结方便大家理解。

List跟List，前者是原生List，后者是泛型List，尽管后者通过擦除使得两者都是可以这样表示List

泛型

简单泛型（基本都是介绍设计代码的用法）

泛型接口

泛型方法

匿名内部类（可以在匿名内部类中使用泛型）、构建复杂模型（其实也就是多维元组）

擦除（这才是我们应该需要去记住的东西）

擦除的补偿

边界

通配符

捕获异常

自限定的类型

动态类型安全（如何使用）

异常（当一种工具使用，不做详解）

混型（混合多个类）

潜在类型机制（需要知道）

缺乏潜在类型机制的补偿

总结

你可能感兴趣的:(编程思想学习)