Question

我有块使用函数step()执行计算。块可以连接到彼此connect(Block)。

interface Block {
    void connect(Block b);
    void step();
}

然而，在具体的块实现中（例如在step中）它应该是从连接的块可能read：

class ABlockImpl implements Block {
    private Block src; // link to the block this block is connected to
    public void connect(Block b) {
        src = b;
    }

    public void step() {
        double x = src.read(); // XXX src is of type Block and there is no read() in Block
        /* ... */
    }

    public double read() {
        return 3.14;
    }
}

由于read()中没有Block，因此无法编译。对于客户端，“公共”块接口就足够了，我只需要在内部read。我可以将read添加到Block界面，但对我来说这感觉不对。

由于Block有多种不同的实现，因此在调用src之前，我无法将ABlockImpl强制转换为read。

是否有其他方法可以“隐藏”read？

Answer 1

您可以拥有公共界面和本地包

public interface MyPublicInterface {

}

interface MyDirectInterface extends MyPublicInterface {

}

class MyImpl implements MyDirectInterface {

    public void add(MyPublicInterface mpi) {
         MyDirectInterface mdi = (MyDirectInterface) mpi;
         // use mdi
    }

}

Answer 2

您可以在abstract和阻止的具体实现之间创建interface图层，并为其命名，例如BlockAdapter。

即：

interface Block {
    void connect(Block b);
    void step();
    double read();
}

...

public abstract class BlockAdapter implements Block { 
    double read() {
          return -1; // ? something like that
    }
}

...

public class ABlockImpl extends BlockAdapter { ... }

Answer 3

我认为没有一种解决方案能够为您提供您想要的产品，但可能与您有所关系：

interface Block {
    void connect(Block b);
    void step();
}

interface ReadableBlock extends Block {
    double read();
}

方法read()仍然需要公开，但您可以让外部代码仅通过Block接口引用实现，而实现本身来自ReadableBlock

public cass ABlockImpl implements ReadableBlock {
    ....
}

Block b = new ABlockImpl();

我怎样才能同时提供两个接口（一个＆＃34;公共＆＃34;和＆＃34;扩展＆＃34;一个）？

3 个答案: