incendi0
commented
4 years ago Chapter 2. Subtyping and Wildcards
2.1 Subtyping and the Substitution Principle
Subtyping具有传递性。A是B的子类，B是C的子类，A也是C的子类。引用类型都是Object的子类，类型也是自己的子类。
Substitution Principle: a variable of a given type may be assigned a value of any subtype of that type, and a method with a parameter of a given type may be invoked with an argument of any subtype of that type.
泛型是invariant（不变），List\<Integer>和List\<Number>没有父类子类的关系，当然List\<Integer>是Collection\<Integer>的子类；数组有covariant（协变）的性质，Integer[]是Number[]的子类。
如果想要List表现出类似数组的父子类关系，可以使用wildcards（通配符）。
2.2 Wildcards with extends
interface Collection<E> {
boolean addAll(Collection<? extends E> c);
}?被称为通配符，? extends E表示E的任何一个子类。
List<Integer> ints = new ArrayList<>();
ints.add(1);
// List<Number> nums = ints; // wrong!
List<? extends Number> nums = ints; // OK, List<Integer>是List<? extends Number>的子类
nums.add(3.14); // wrong!
原则上，对于包含具有? extends E类型的类（结构体），只能从结构体取值，不能把值放入结构体，除非null。
2.3 Wildcards with super
public static <T> void copy(List<? super T> dst, List<? extends T> src) {
for (int i = 0; i < src.size(); i++) {
dst.set(i, src.get(i));
}
}? super T表示T的任何一个父类。
类似的，对于包含具有? super T类型的类（结构体），不能从结构体取值（除非Object），只能把值放入结构体。
2.4 The Get and Put Principle
The Get and Put Principle: use an extends wildcard when you only get values out of a structure, use a super wildcard when you only put values into a structure, and don’t use a wildcard when you both get and put.
又称为PECS，即producers extends, consumers super，参照2.3中的代码示例。
String类型是final的，意味着无法继承String类，但是List\<String>并不等同于List\<? extends String>，事实上，前者是后者的子类。The Get and Put Principle告诉我们，我们可以把String加到List\<String>，但不能加到List\<? extends String>，所以两者类型不同，同时，当需要后者的时候，我们总能传入前者类型的值，所以前者是后者的子类。
2.5 Arrays
Integer[] ints = new Integer[] {1, 2, 3};
Number[] nums = ints; // OK，因为nums是ints的子类
nums[2] = 3.14; // wrong! ArrayStoreException，因为当一个数组第一次被分配的时候，已经被标记上具化(reified)的类型，此处是Integer，数组每次赋值的时候检查发现具化类型和赋值类型不兼容（double不能存入Integer数组中），就抛出ArrayStoreException泛型是不变的，数组是协变的。
通配符为泛型引入了协变(covariant)，S是T的子类，List\<S>是List\<? extends T>的子类。
通配符为泛型引入了逆变(contravariant)，S是T的父类，List\<S>是List\<? super T>的子类。
泛型可以把问题暴露在编译器，数组的问题暴露在运行期
前者的优势：
- 问题及早暴露；
- 运行时不需要时刻去检查类型是否兼容；
- 集合类型多，API丰富。
选择后者的场景：
- 原生类型效率高，不需要装箱，同时也不会做类型检查，因为原生类型没有子类；
- 性能好
为什么要把数组设计成协变的呢？
在泛型出现之前是有必要的，比如你想写一个方法，但是所有的类型都能用，比如下面的sort和fill方法。
public static void sort(Object[] a);
public static void fill(Object[] a, Object val);2.6 Wildcards Versus Type Parameters
interface Collection<E> {
boolean contains(Objecat o);
boolean containsAll(Collection<?> c);
}Collection\<?>表示Collection\<? extends Object>
interface Collection<E> {
boolean contains(E o);
boolean containsAll(Collection<? extends E> c);
}2.7 Wildcard Capture
public static void reverse(List<?> list) {
List<Object> tmp = new ArrayList<Object>(list);
for (int i = 0; i < list.size(); i++) {
list.set(i, tmp.get(list.size()-i-1)); // compile-time error
}
}public static void reverse(List<?> list) {
rev(list);
}
private static <T> void rev(List<T> list) {
List<T> tmp = new ArrayList<T>(list);
for (int i = 0; i < list.size(); i++) {
list.set(i, tmp.get(list.size()-i-1));
}
} 另外一个原因需要知道通配符捕捉的原因是编译器报错，通配符表示未知类型，编译器可能会打印出类似capture of ?的错误信息，比如上面错误代码的编译错误。
2.8 Restrictions on Wildcards
通配符不能出现在类实例化顶层表达式(new)，应用The Get and Put Principle，我们只能往这个类get值(extend)或者put值(super)，但是类一般我们是要同时做到put和get。
List<?> list = new ArrayList<?>(); // compile-time error
Map<String, ? extends Number> map = new HashMap<String, ? extends Number>(); // compile-time errorList<List<?>> lists = new ArrayList<List<?>>();
lists.add(Arrays.asList(1,2,3));
lists.add(Arrays.asList("four","five"));
assert lists.toString().equals("[[1, 2, 3], [four, five]]");通配符不能出现在泛型方法调用的时候
class Lists {
public static <T> List<T> factory() { return new ArrayList<T>(); }
}
List<?> list = Lists.factory(); // OK
List<?> list = Lists.<Object>factory(); // OK
List<?> list = Lists.<?>factory(); // compile-time error
List<List<?>> = Lists.<List<?>>factory(); // ok, nested wildcards are permitted通配符不能出现在implements或者extends的时候，原因是子类实例化需要调用父类构造函数，所以实例化的限制也会出现。
class AnyList extends ArrayList<?> {...} // compile-time error
class AnotherList implements List<?> {...} // compile-time error
class NestedList extends ArrayList<List<?>> {...} // ok
[x] Chapter 2. Subtyping and Wildcards
[x] Chapter 3. Comparison and
[x] Chapter 4. Declarations
[x] Chapter 6. Reification
[x] Chapter 7. Reflection
[x] Chapter 9. Design Patterns
// TODO