我正在构建一个库包，它有一个接口 PropTransformer 它将由30多个类实现。我在这里上这样的课 ShapeTransformer ```
public interface PropTransformer<T, R> {
R transform(T t);
T reverseTransform(R r);
}

public class ShapeTransformer implements PropTransformer<List, Set> {

@Override
public Set<String> transform(final List<String> list) {
    // transform code
}

@Override
public List<String> reverseTransform(final Set<String> set) {
    // reverseTransform code
}

}

可以使用 `new` 操作符，但由于许多转换可以在用户端完成，所以许多示例化将显得臃肿。比如：

new ShapeTransformer().transform(...);
new TemperatureTransformer().transform(...);
...

我可以考虑创建一个实用程序类 `Transformer` 这将为变压器提供一个直接的调用，比如

public class Transformer<T, R> {

private static ShapeTransformer shapeTransformer = new CompatibleDevicesTransformer();

public static Set<String> shapeTransform(final List<String> list) {
    return shapeTransformer.transform(list);
}

public static List<String> shapeReverseTransform(final Set<String> set) {
    return shapeTransformer.reverseTransform(set);
}

}

库用户可以像这样使用它

Transformer.shapeTransform(...)

这种方法的问题：
它不会扩展，因为transformer类将随着实现的transformer数量的增加而不断增长 `PropTransformer` .
这种重复工作是通过在中添加静态方法和变量来完成的 `Transformer` 班
有没有更干净/更好的方法来实现这一点？如果可能，是否通过方法引用和/或功能接口？
像这样的

Transformer t = new Transformer();
t.transform(ShapeTransformer::transform);
t.transform(TemperatureTransformer::transform);

（^这只是为了让你了解我在找什么。我不一定建议让变形金刚方法成为静态的）