初识Java 18-6 泛型

潜在类型机制

支持潜在类型机制的语言

Python的潜在类型机制

C++的潜在类型机制

Java中的直接潜在类型机制

潜在类型机制的替代方案

反射

将方法应用于序列中的每个元素

Java 8的潜在类型机制（间接实现）

潜在类型机制的使用例（Suppliers）

总结

本笔记参考自：《On Java 中文版》

潜在类型机制

通过泛型，我们应该可以向“将代码写得更通用一点”这一理念更进一步。特别是在编写简单的Java泛型时，泛型可以在不了解具体类型的情况下执行方法。然而，随着对Java泛型的了解逐渐深入，类型擦除无疑使泛型的作用打了折扣，并限制了“泛型”这一概念。

一些语言会提供潜在类型机制（又称结构化类型机制），它还有一个更有意思的名称：鸭子类型机制。比方说，“如果某件事物走路像鸭子，说话也像鸭子，那么就可以把它看做鸭子”。

与泛型不同，潜在类型机制只对方法本身有所要求，而不需要实现特别的类或接口。

潜在类型机制可以超越类的层次结构，调用不属于某个公共接口的方法。

支持潜在类型机制的语言

有许多语言支持潜在类型机制，例如Python、C++和Go等。

Python的潜在类型机制

先看看Python中的潜在类型机制：

【例子：Python中的潜在类型机制】

class Dog:
    def speak(self):
        print("汪！")
    def sit(self):
        print("坐着")
    def reproduce(self):
        pass
    
class Robot:
    def speak(self):
        print("锵！")
    def sit(self):
        print("咔")
    def oilChange(self):
        pass
    
def perform(anything):
    anything.speak()
    anything.sit()
    
a = Dog()
b = Robot()
perform(a)
perform(b)

程序执行的结果是：

在perform(anything)中并不包含任何关于anything的类型信息，anything只是一个标识符。在后台，anything相当于一个被隐藏的接口，它包含了perform()要求的操作。但我们无需显式地表明它，因为它是潜在的。

而如果向perform()传入不支持操作的对象，就会报错：

----------

C++的潜在类型机制

同样可以用C++来实现上面的例子：

【例子：C++中的潜在类型机制】

#include<iostream>
using namespace std;

class Dog {
public:
    void speak() {
        cout << "汪！" << endl;
    }

    void sit() {
        cout << "坐着" << endl;
    }
};

class Robot {
public:
    void speak() {
        cout << "锵！" << endl;
    }

    void sit() {
        cout << "咔" << endl;
    }

    void oilChange() {}
};

template<class T> void perform(T anything) {
    anything.speak();
    anything.sit();
}

int main() {
    Dog d;
    Robot r;
    perform(d);
    perform(r);
}

程序执行的结果相同：

若试图传入错误的类型，编译器也会报错。不同与Python，C++会在运行时抛出错误（尽管C++的错误信息出了名的冗长）。但这两门语言都保证了类型不会错用。

----------

也可以使用Go实现这个例子：

【例子：Go中的潜在类型机制】

package main
import "fmt"

type Dog struct{}
func (this Dog) speak() {
	fmt.Printf("汪！\n")
}
func (this Dog) sit(){
	fmt.Printf("坐着\n")
}
func (this Dog) reproduce(){
}

type Robot struct{}
func (this Robot) speak() {
	fmt.Printf("锵！\n")
}
func (this Robot) sit(){
	fmt.Printf("咔\n")
}
func (this Robot) oilChange(){
}

func perform(speaker interface {speak(); sit()}){
	speaker.speak()
	speaker.sit()
}

func main(){
	perform(Dog{})
	perform(Robot{})
}

程序会得到相同的结果：

Java中的直接潜在类型机制

Java的泛型加入得较晚，因此没有支持潜在类型机制。因此，若要在Java中实现上面所述的效果，通常会需要使用接口（并且使用边界）：

【例子：通过接口模拟潜在类型机制】

import reflection.pets.Dog;

class PerformingDog extends Dog implements Performs {
    @Override
    public void speak() {
        System.out.println("汪！");
    }

    @Override
    public void sit() {
        System.out.println("坐下");
    }

    public void reproduce() {
    }
}

class Robot implements Performs {
    @Override
    public void speak() {
        System.out.println("锵！");
    }

    @Override
    public void sit() {
        System.out.println("咔");
    }

    public void oilChange() {
    }
}

class Communicate {
    // 通过边界，调用接口的方法：
    public static <T extends Performs>
    void perform(T performer) {
        performer.speak();
        performer.sit();
    }
}

public class DogsAndRobots {
    public static void main(String[] args) {
        Communicate.perform(new PerformingDog());
        Communicate.perform(new Robot());
    }
}

程序执行的结果是：

然而，仔细考虑这种做法会发现，Communicate.perform()并不需要使用到泛型，它可以直接使用Performs接口：

class Communicate {
    public static void perform(Performs performer) {
        performer.speak();
        performer.sit();
    }
}

说到底，无论是PerformingDog还是Robot都已经强制实现了Performs接口。

潜在类型机制的替代方案

尽管Java并没有（直接）支持潜在类型机制，但我们依旧可以想办法创建出真正意义上的泛型代码，实现方法的跨层次应用。

反射

一个方案是使用反射：

【例子：使用反射创建泛型代码】

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

// 这个类没有实现Perform接口：
class Mime {
    public void walkAgainstTheWind() {
    }

    public void sit() {
        System.out.println("假装坐着");
    }

    public void pushInvisibleWalls() {
    }

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

class SmartDog {
    public void speak() {
        System.out.println("汪！");
    }

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

    public void reproduce() {
    }
}

class CommunicateReflectively {
    public static void perform(Object speaker) {
        Class<?> spkr = speaker.getClass();
        try {
            try {
                Method speak = spkr.getMethod("speak");
                speak.invoke(speaker);
            } catch (NoSuchMethodException e) {
                System.out.println(speaker + "没法说话");
            }

            try {
                Method sit = spkr.getMethod("sit");
                sit.invoke(speaker);
            } catch (NoSuchMethodException e) {
                System.out.println(speaker + "无法坐下");
            }
        } catch (SecurityException |
                 IllegalAccessException |
                 IllegalArgumentException |
                 InvocationTargetException e) {
            throw new RuntimeException(speaker.toString(), e);
        }
    }
}

public class LatentReflection {
    public static void main(String[] args) {
        CommunicateReflectively.perform(new SmartDog());
        CommunicateReflectively.perform(new Robot());
        CommunicateReflectively.perform(new Mime());
    }
}

程序执行的结果是：

在这里，SmartDog、Robot和Mime之间没有任何的直接联系，我们直接通过反射动态调用speak()和sit()。

将方法应用于序列中的每个元素

还可以进一步地开发反射。假设我们需要为一个序列中的每个元素应用方法，只使用接口仍是不够的，因此我们可以这样做：

【例子：将一个方法应用于序列】

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

public class Apply {
    public static <T, S extends Iterable<T>>
    void apply(S seq, Method f, Object... args) {
        try {
            for (T t : seq)
                f.invoke(t, args);
        } catch (IllegalAccessException |
                 IllegalArgumentException |
                 InvocationTargetException e) {
            throw new RuntimeException(e); // 可能会因为不正确的使用该方法导致异常
        }
    }
}

apply()方法可以接受任意数量的序列元素，并将方法f()应用于所有元素。这种做法有一个好处，f.invoke()可以接受任意长度的序列，因此可以认为apply()也可以做到这点。

除此之外，apply()方法使用了for-in语法。这表示着S可以是任何实现了Iterable接口的类。

接下来就对apply()方法进行测试：

【例子：apply()方法的使用例】

首先创建一个简单的继承结构，这个结构包含一个父类Shape和一个子类Square。

===父类Shape：

public class Shape {
    private static long counter = 0;
    private final long id = counter++;

    @Override
    public String toString() {
        return getClass().getSimpleName() + " " + id;
    }

    public void rotate() {
        System.out.println(this + " rotate");
    }

    public void resize(int newSize) {
        System.out.println(this + " resize " + newSize);
    }
}

==子类Square：

public class Square extends Shape {}

接下来的就是测试类ApplyTest。

===ApplyTest：

import onjava.Suppliers;

import java.util.ArrayList;
import java.util.List;

public class ApplyTest {
    public static void main(String[] args)
            throws Exception {
        List<Shape> shapes =
                Suppliers.create(ArrayList::new, Shape::new, 3);
        Apply.apply(shapes,
                Shape.class.getMethod("rotate"));
        Apply.apply(shapes,
                Shape.class.getMethod("resize", int.class), 7);

        System.out.println();
        List<Square> squares =
                Suppliers.create(ArrayList::new, Square::new, 3);
        Apply.apply(squares,
                Shape.class.getMethod("rotate"));
        Apply.apply(squares,
                Shape.class.getMethod("resize", int.class), 7);

        System.out.println();
        Apply.apply(new FilledList<>(Shape::new, 3),
                Shape.class.getMethod("rotate"));
        Apply.apply(new FilledList<>(Square::new, 3),
                Shape.class.getMethod("rotate"));
    }
}

程序执行的结果是：

首先解释Suppliers.create()，看如下代码：

这行代码等价于，将Shape类的构造器作为生成器，生成3个对象，并将结果放入一个ArrayList对象中。

尽管反射可以使代码看起来很优雅，但要注意，反射的运行速度通常会慢于非反射的实现。究其原因，反射在运行时处理了太多东西。尽管我们不应该只因为这个理由放弃使用反射，但这无疑是我们必须考虑的一点。

现在考虑Java 8加入的函数式方式，下面的例子通过它重写了ApplyTest：

【例子：使用函数式方式重写ApplyTest】

import java.util.stream.Stream;

public class ApplyFunctional {
    public static void main(String[] args) {
        Stream.of(Stream.generate(Shape::new).limit(2),
                        Stream.generate(Square::new).limit(2))
                .flatMap(c -> c) // 将所有元素扁平化，合成一条流
                .peek(Shape::rotate)
                .forEach(s -> s.resize(7));

        System.out.println();
        new FilledList<>(Shape::new, 2)
                .forEach(Shape::rotate);
        new FilledList<>(Square::new, 2)
                .forEach(Shape::rotate);
    }
}

程序执行的结果是：

这种重写方式已经抛弃了Apply.apply()了。

这么做的好处是，它更加简洁、可读性高并且不会抛出异常。因此现在可以这么说，我们只需要在某些只能使用反射来解决的场景中使用反射就好了。

Java 8的潜在类型机制（间接实现）

Java 8带来的未绑定方法引用可以在某种程度上实现潜在类型机制。

【例子：使用方法引用实现潜在类型机制】

import reflection.pets.Dog;

import java.util.function.Consumer;

class PerformingDogA extends Dog {
    public void speak() {
        System.out.println("汪！");
    }

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

    public void reproduce() {
    }
}

class RobotA {
    public void speak() {
        System.out.println("锵！");
    }

    public void sit() {
        System.out.println("咔");
    }

    public void oilChange() {
    }
}

class CommunicateA {
    public static <P> void perform(
            P performer, Consumer<P> action1, Consumer<P> action2) {
        action1.accept(performer);
        action2.accept(performer);
    }
}

public class DogsAndRobotMethodReferences {
    public static void main(String[] args) {
        CommunicateA.perform(new PerformingDogA(),
                PerformingDogA::speak, PerformingDogA::sit);
        CommunicateA.perform(new RobotA(),
                RobotA::speak, RobotA::sit);
        CommunicateA.perform(new Mime(),
                Mime::walkAgainstTheWind, Mime::pushInvisibleWalls);
    }
}

程序执行结果是：

因为CommunicateA.perform()没有对P做出限制，因此它可以是任何类型。perform()只要求提供可供Consumer<P>使用的方法。因此我们可以向其中传入任何与其签名一致的方法。

然而，和真正的潜在类型机制相比，这种做法需要我们显式地提供perform()会用到的方法引用。

但这种方式也有更好的一点，它其实不会对传入其中的方法名做出要求。在这个意义上，这种方法要更加通用。

潜在类型机制的使用例（Suppliers）

现在可以通过潜在类型机制创建Suppliers（这个类在之前的笔记中也曾出现）。这个类的方法都用于填充集合：

【例子：潜在类型机制的使用例】

import java.util.Collection;
import java.util.function.BiConsumer;
import java.util.function.Supplier;
import java.util.stream.Stream;

public class Suppliers {
    // 根据factory创建一个新的集合，并且填充它：
    public static <T, C extends Collection<T>> C
    create(Supplier<C> factory, Supplier<T> gen, int n) {
        return Stream.generate(gen)
                .limit(n)
                .collect(factory, C::add, C::addAll);
    }

    // 填充已存在的集合coll：
    public static <T, C extends Collection<T>>
    C fill(C coll, Supplier<T> gen, int n) {
        Stream.generate(gen)
                .limit(n)
                .forEach(coll::add);
        return coll;
    }

    // 使用到未绑定方法引用adder，可以生成更加通用的方法：
    public static <H, A> H fill(
            H holder, BiConsumer<H, A> adder,
            Supplier<A> gen, int n) {
        Stream.generate(gen)
                .limit(n)
                .forEach(a -> adder.accept(holder, a));
        return holder;
    }
}

在第一个fill()方法中，我们返回了coll（即传入的容器的类型信息），这样就能保证不会丢失类型信息了。

第二个fill()方法使用了未绑定的方法引用adder。通过adder.accept()，我们可以将操作a应用于对象holder。

接下来可以尝试使用Suppliers了。

【例子：使用Suppliers】

import onjava.Suppliers;

import java.util.ArrayList;
import java.util.List;

class Customer {
    private static long counter = 1;
    private final long id = counter++;

    @Override
    public String toString() {
        return "Customer " + id;
    }
}

class Teller {
    private static long counter = 1;
    private final long id = counter++;

    @Override
    public String toString() {
        return "Teller " + id;
    }
}

class Bank {
    private List<BankTeller> tellers =
            new ArrayList<>();

    public void put(BankTeller bt) {
        tellers.add(bt);
    }
}

public class BankTeller {
    public static void serve(Teller t, Customer c) {
        System.out.println(t + " 服务于 " + c);
    }

    public static void main(String[] args) {
        // 使用create()：
        RandomList<Teller> tellers =
                Suppliers.create(
                        RandomList::new, Teller::new, 4);

        // 演示第一个fill()：
        List<Customer> customers = Suppliers.fill(
                new ArrayList<>(), Customer::new, 12);
        customers.forEach(c ->
                serve(tellers.select(), c));

        // 演示潜在类型机制：
        Bank bank = Suppliers.fill(
                new Bank(), Bank::put, BankTeller::new, 3);
        // 或使用第二个fill()：
        List<Customer> customers2 = Suppliers.fill(
                new ArrayList<>(), List::add, Customer::new, 12);
    }
}

程序执行的结果是：