Java泛型(11)：潜在类型机制

泛型的目标之一就是能够编写尽可能广泛应用的代码。

为了实现这一点，我们需要各种途径来放松对我们的代码将要作用的类型所做的限制，同时不丢失静态类型检查的好处。即写出更加泛化的代码。

Java泛型看起来是向这个方向迈进了一步。但是还是有一定的限制：

（1）当你在编写或使用只是持有对象<T>的泛型时，这些代码可以适用于任何类型。这些代码就可以真正应用于任何地方，因此相当泛化。

（2）当要在泛型类型上执行操作时，就会产生问题，因为擦除要求指定可能会用到的泛型类型的边界，以安全的调用代码中的泛型对象上的具体方法。

这是对泛化的明显限制。因为必须限制你的泛型类型，使它们继承特定类或实现特定接口。

某些编程语言（Python、C++）提供一种解决方案称为潜在类型机制，它只要求泛型代码实现某个方法的子集，而不是特定类或接口。

尽管Java不支持潜在类型机制，但这并不意味着有界泛型代码不能在不同的类型层次结构之间应用，只不过需要付出一些额外的努力。

（0）以下面例子作为原型：

 interface Performs {
     void speak();
     void sit();
 }
 class Dog implements Performs {
     @Override public void speak() { System.out.println("Dog Speaking..."); }
     @Override public void sit() { System.out.println("Dog Sitting..."); }
     public void run() { System.out.println("Dog Running..."); }
 }
 class Robot implements Performs {
     @Override public void speak() { System.out.println("Robot Speaking..."); }
     @Override public void sit() { System.out.println("Robot Sitting..."); }
     public void calc() { System.out.println("Robot Calculating..."); }
 }
 class Actions {
     public static void perform(Performs p) {
         p.speak();
         p.sit();
     }
 }
 public class DogsAndRobots {
     public static void main(String[] args) {
         Actions.perform(new Dog());
         Actions.perform(new Robot());
     }
 }

（1）反射

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;

 class Dog1 {
     public void speak() { System.out.println("Dog1 Speaking..."); }
     public void sit() { System.out.println("Dog1 Sitting..."); }
     public void run() { System.out.println("Dog1 Running..."); }
 }
 class Robot1 {
     public void speak() { System.out.println("Robot1 Speaking..."); }
     public void sit() { System.out.println("Robot1 Sitting..."); }
     public void calc() { System.out.println("Robot1 Calculating..."); }
 }
 class Actions1 {
     public static void perform(Object obj) {
         Class<?> objClass = obj.getClass();
         try {
             Method speak = objClass.getMethod("speak");
             speak.invoke(obj);
             Method sit = objClass.getMethod("sit");
             sit.invoke(obj);
         } catch (NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
             e.printStackTrace();
         }
     }
 }
 public class DogsAndRobots1 {
     public static void main(String[] args) {
         Actions1.perform(new Dog1());
         Actions1.perform(new Robot1());
     }
 }

（2）将一个方法应用于序列 (apply方法可以接受任何实现Iterable接口的事物，然而，这样的代码还是不够泛化。)

 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.List;

 class Dog2 {
     public void speak() { System.out.println("Dog2 Speaking..."); }
     public void sit() { System.out.println("Dog2 Sitting..."); }
     public void run(int length) { System.out.println("Dog2 runs " + length + " miles."); }
 }

 class SmartDog extends Dog2 {}

 class Actions2 {
     // PECS
     public static <T, S extends Iterable<? extends T>> void apply(S seq, Method f, Object... args) {
         seq.forEach(p -> {
             try {
                 f.invoke(p, args);
             } catch (IllegalAccessException | InvocationTargetException e) {
                 e.printStackTrace();
             }
         });
     }
 }

 class FilledList<T> extends ArrayList<T> {
     // PECS
     public FilledList(Class<? extends T> type, int size) throws Exception {
         for(int i = 0; i < size; i++) {
             add(type.newInstance());
         }
     }
 }

 public class DogsAndRobots2 {
     public static void main(String[] args) throws Exception {
         List<Dog2> dog2s = new ArrayList<>();
         for (int i = 0; i < 3; i++) {
             dog2s.add(new Dog2());
         }
         Actions2.apply(dog2s, Dog2.class.getMethod("speak"));
         Actions2.apply(new FilledList<>(SmartDog.class, 2), SmartDog.class.getMethod("run", int.class), 1);
     }
 }

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

 import java.util.*;

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

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

 class SimpleQueue<T> implements Iterable<T> {
     private LinkedList<T> storage = new LinkedList<T>();
     public void add(T t) { storage.offer(t); }
     public T get() { return storage.poll(); }
     public Iterator<T> iterator() {
         return storage.iterator();
     }
 }

 class Dog3 {
     public void speak(){ System.out.println("Dog2 Speaking..."); }
     public void sit() { System.out.println("Dog2 Sitting..."); }
     public void run(int length) { System.out.println("Dog2 runs " + length + " miles."); }
 }

 class BigDog extends Dog3 {}
 class SmallDog extends Dog3 {}

 class Fill {
     // Classtoken version:
     public static <T> void fill(Addable<T> addable, Class<? extends T> classToken, int size) {
         for (int i = 0; i < size; i++)
             try {
                 addable.add(classToken.newInstance());
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
     }

     // Generator version:
     public static <T> void fill(Addable<T> addable, Generator<T> generator, int size) {
         for (int i = 0; i < size; i++)
             addable.add(generator.next());
     }
 }

 // To adapt a base type, you must use composition.
 // Make any Collection Addable using composition:
 class AddableCollectionAdapter<T> implements Addable<T> {
     private Collection<T> c;

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

     public void add(T item) {
         c.add(item);
     }
 }

 // A Helper to capture the type automatically:
 class Adapter {
     public static <T> Addable<T> collectionAdapter(Collection<T> c) {
         return new AddableCollectionAdapter<>(c);
     }
 }

 // To adapt a specific type, you can use inheritance.
 // Make a SimpleQueue Addable using inheritance:
 class AddableSimpleQueue<T> extends SimpleQueue<T> implements Addable<T> {
     public void add(T item) { super.add(item); }
 }

 public class DogsAndRobots3 {
     public static void main(String[] args) {
         List<Dog3> dog3s = new ArrayList<>();
         // Adapt a Collection:
         Fill.fill(new AddableCollectionAdapter<>(dog3s), BigDog.class, 3);
         // Helper method captures the type:
         Fill.fill(Adapter.collectionAdapter(dog3s), SmallDog.class, 2);
         for(Dog3 elem : dog3s) {
             System.out.println(elem.getClass().getSimpleName());
         }
         System.out.println("----------------------");
         // Use an adapted class:
         AddableSimpleQueue<Dog3> dog3Queue = new AddableSimpleQueue<>();
         Fill.fill(dog3Queue, BigDog.class, 4);
         Fill.fill(dog3Queue, SmallDog.class, 1);
         for(Dog3 elem : dog3Queue) {
             System.out.println(elem.getClass().getSimpleName());
         }
         //        BigDog
         //        BigDog
         //        BigDog
         //        SmallDog
         //        SmallDog
         //        ----------------------
         //        BigDog
         //        BigDog
         //        BigDog
         //        BigDog
         //        SmallDog
     }
 }