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
    }
}