小编Aub*_*ron的帖子

是否可以使用空方法并在子类中重写它？这就是我的代码中的样子.

public class Rook() {

    public void voidCastleRight() { }

}

public class ShortRook() extends Rook {

    @Override
    public void voidCastleRight() {
        getPlayer().setkSC(false); //void King Side Castling (Short Castle)
    }

}

public class LongRook() extends Rook {

    @Override
    public void voidCastleRight() {
        getPlayer().setqSC(false); //void Queen Side Castling (Long Castle)
    }
}

上下文是国际象棋引擎.它是用Java编写的,它必须搜索下一个"最佳"移动,以便给出一个状态.因此,一切都尽可能高效地实施是很重要的,因为许多方法将被称为数百万次.因此,我想要这个Rooks的等级,而不是一个Rook类,我必须检查Rook在哪一侧并检查Rook是否处于其初始位置等等.

首次创建Board时,会有ShortRook和LongRook.随着游戏的进行,有可能因为典当促销而将更多的白嘴鸦引入游戏中.这些将是鲁克的实例.

voidCastleRight()每当移动Rook时都会调用该方法.由于Pawn升级而存在的车辆不应该在移动时使城堡无效(空方法).自游戏开始以来存在的鲁克斯应该在移动时使城堡权利无效(子类中的方法).

我还编写了一个解析器,它接受FENStrings并将它们转换为Board,反之亦然.当鲁克斯不在他们的初始位置时,没有办法分辨出Short-LongRook和LongRook.这不是问题,因为无论如何城堡权利已经废除,它们可以被解析为鲁克的实例.因此,如果我将一个Short或LongRook对象输入Rook,只要它已经使相关的城堡无效(即它已经移动),那么它会没有问题吗？通过这种方式,当城堡已经无效时,它不会毫无疑问地无效.我不关心这些解析器方法的复杂性,因为它们不会在搜索中使用.

虽然有些人可能会认为这些想法是微观优化"这是所有邪恶的根源",但是当这种方法被称为几百万次时,这些优化可能会得到回报.我也更关注OOP范式.

PS:我知道Java不是用于此应用程序的最佳语言,它无关紧要.我知道对象创建(在Java中)很昂贵.我将确保在搜索过程中没有创建任何对象.

由于最近在我的 Windows 机器上更新了 Docker，Docker Desktop 开始向我的etc\hosts文件中添加条目。我不确定是哪个版本引入了它，但我目前在 Docker 桌面社区 2.1.0.1 (31799) 上。

我希望我的etc\hosts文件只包含以下条目：

127.0.0.1 localhost host.docker.internal

但时不时，Docker Desktop 会添加额外的条目，导致：

127.0.0.1       localhost host.docker.internal
# Added by Docker Desktop
10.4.123.44 host.docker.internal
10.4.123.44 gateway.docker.internal
# To allow the same kube context to work on the host and the container:
127.0.0.1 kubernetes.docker.internal
# End of section

如果我删除它们，它们最终会重新出现。如何防止 Docker 添加这些条目？

假设我有一个Serializable接口,如下所示

public interface SomeInterface extends Serializable {

     public SomeClass getSomething(String someParameter);

}

会SomeClass自动进行Serializable吗？令我们惊讶的是,即使SomeClass没有实现Serializable ,我们的RMI应用程序也能正常运行.

为什么是这样？

我有一个类似于以下方法:

public double[] foo(double[] doubleArray) { 
    DoubleStream stream = Arrays.stream(doubleArray);

    return stream.map(s -> s / stream.sum()).toArray();
}

这种方法的复杂性是什么？多少次会DoubleStream的sum方法被执行？一次或O(n)多次,有n = doubleArray.length？

假设我有一个如下界面.

interface CardHolder : IEnumerable<Card>
{
    /// <summary> ...
    void PutCard(Card card);

    /// <summary> ...
    void PutCards(Card[] card);

    /// Some more methods...
}

我实现如下.

public class ArrayCardHolder : CardHolder
{
    private Card[] _cards;
    private int _size = 0;

    public ArrayCardHolder(int capacity)
    {
        _cards = new Card[capacity];
    }

    public void PutCard(Card card)
    {
        if (IsFull())
            throw new Exception("This CardHolder is full. Capacity: " + Capacity());

        _cards[_size++] = card;
    }

    public void PutCards(Card[] cards)
    {
        if (_size + cards.Length > _cards.Length)
            throw …