java - 通用返回类型和 lambda 函数参数

Question

我目前正在研究可以处理任何网格状结构上的操作的抽象代码。我一直在尝试开发一个框架来代替具体方法，该框架接受 lambda 表达式并提供基于网格元素之间的方向关系的功能，并且在尝试将泛型类型返回到这些方法中时遇到了麻烦。

我有一个像下面这样的工作方法，它接受一个 lambda 函数，该函数在特定方向上查找网格元素，以及一个在每个元素上执行某种方法的 Consumer。

public static <E> void forEachClockwise(Direction d, Function<Direction, ? extends E> f, Consumer<? super E> c){
    /*For each of the orthogonal directions, in order:*/
        c.accept(f.apply(d));
    /*end For*/

}

不必每次调用此方法时都必须传递元素查找函数，我认为最好有一个声明了此类函数的“正交”接口(interface)，并重载 forEachClockwise 方法以接受此元素界面。

public static <O extends Orthogonal> void forEachClockwise(Direction d, O center, Consumer<O> c){
    forEachClockwise(d, center::findNextByDirection, c);
}

我在这里使用了泛型并进行了声明，以便 Consumer 方法能够访问网格元素的字段而无需进行强制转换。我担心这是一个糟糕的设计选择，因为尽管尝试了一些不同的事情，但我创建的正交接口(interface)和测试类在没有警告和强制转换的情况下还没有编译。

public interface Orthogonal {
    public <E extends Orthogonal> E findNextByDirection(Direction a);
}

我尝试过的 findNextByDirection 的两个“有效”实现是:

/* in Coordinate implements Orthogonal: */
@Override
public <E extends Orthogonal> E findNextByDirection(Direction a) {
    return (E) (/*The proper Coordinate*/);
}

和

@Override
public Coordinate findNextByDirection(Direction a) {
    return /*The proper Coordinate*/;
}
//Warning on return type declaration:
/*Type safety: The return type Element for findNextByDirection(Direction) from the type Element needs unchecked conversion to conform to E from the type Orthogonal*/

最理想的是，我希望有一个 forEachClockwise (和其他方法)可以接受的方法，它返回调用它的同一类的元素，而不进行强制转换。坐标的 findNextByDirection 应该返回一个坐标，地址应该返回一个地址，单元格应该返回单元格等。我看过的其他问题和答案讨论了如何摆脱使用通用返回类型的方法，但我还没有找到有关如何使用此类方法作为 lambda 参数的任何提示。

我还没有尝试过的几件事是创建一个新的 findByDirection 方法，该方法接受某种正交和方向作为参数，或者使用正交中定义的某些方法调用 forEachClockwise 方法，尽管这些方法听起来合理我尝试过什么。我见过的另一种可行的方法是为接口(interface)提供自己的泛型类型，但将每个正交类声明为“MyClass 实现正交”感觉明显错误且违背目的

我是否从一开始就完全错误地设计了这个界面，并期望泛型做一些他们没有设计目的的事情？或者是否有更简单的方法让类调用正确的方法并一般返回其自己类型的元素？

完整代码:

package test;

import java.util.function.Consumer;
import java.util.function.Function;


public enum Direction {
    NORTH, EAST, SOUTH, WEST;

    public static <O extends Orthogonal> void forEachClockwise(Direction d, O center, Consumer<O> c){
        forEachClockwise(d, center::findNextByDirection, c);
    }

    public static <X> void forEachClockwise(Direction d, Function<Direction, ? extends X> f, Consumer<? super X> c){
        c.accept(f.apply(d));
        forEachExcept(d, f, c);
    }

    public static <X> void forEachExcept(Direction d, Function<Direction, ? extends X> f, Consumer<? super X> c){
        for(int i=0; i<3; i++){
            d = Direction.getClockwise(d);
            c.accept(f.apply(d));
        }
    }

    public static Direction getClockwise(Direction d){
        switch(d){
        case EAST:
            return SOUTH;
        case NORTH:
            return EAST;
        case SOUTH:
            return WEST;
        case WEST:
            return NORTH;
        default:
            return null;
        }
    }

}

interface Orthogonal {
    public <E extends Orthogonal> E findNextByDirection(Direction a);
}






class Coordinate implements Orthogonal{

    int x;
    int y;

    public Coordinate(int x, int y){
        this.x = x;
        this.y = y;
    }

    public int getX(){
        return x;
    }

    public int getY() {
        return y;
    }


    @Override //Warning on "Coordinate" below.  Compiler suggests writing
              //entire <E extends Orthogonal> method signature
    public Coordinate findNextByDirection(Direction a) {
        switch(a){
            case NORTH:
                return new Coordinate(x+1, y);
            case SOUTH:
                return new Coordinate(x-1, y);
            case EAST:
                return new Coordinate(x, y+1);
            case WEST:
                return new Coordinate(x, y-1);
            default:
                return null;
        }
    }
}

Answer 1

让我们假设有两个类实现 Orthogonal -Coordinate和Area 。

public <E extends Orthogonal> E findNextByDirection(Direction a);

您在这里声明的是一个模板化方法。该声明基本上说:“给定特定上下文，此方法将始终返回预期类型 - 如果将结果分配给 Coordinate 变量，则该方法将返回 Coordinate ，如果分配给 Area -它将返回 Area 等等 - 只要预期的是实现 Orthogonal 的类型“

但是，当您尝试在 Coordinate 中实现它时如public Coordinate findNextByDirection(Direction a) ，您不再 promise 返回给定上下文中预期的任何内容 - 您现在只返回 Coordinate ，从而破坏了接口(interface)中声明的契约。更糟糕的是，如果你仔细想想，一开始就没有办法真正履行这份契约(Contract)。

你应该做的是声明你的接口(interface)通用( Orthogonal<E> )并删除 <E extends Orthogonal>来自方法声明。

如果是声明class Coordinate implements Orthogonal<Coordinate>感觉“明显错误”，其实不应该。这是常见的做法，在 SDK 本身中广泛使用(例如，请参阅Comparable)。

如果您觉得有必要findNextByDirection返回Orthogonal ，您可以将返回类型声明为 Orthogonal<E> 。您甚至应该能够在 Coordinate 中实现您的方法如public Coordinate findNextByDirection(Direction a)由于 Java 的类型协变，没有任何警告。