空接口以合并多个接口

假设您有两个接口：

interface Readable {
    public void read();
}

interface Writable {
    public void write();
}

在某些情况下，实现对象只能支持其中之一，但在很多情况下，实现将支持两个接口。使用界面的人员将必须执行以下操作：

// can't write to it without explicit casting
Readable myObject = new MyObject();

// can't read from it without explicit casting
Writable myObject = new MyObject();

// tight coupling to actual implementation
MyObject myObject = new MyObject();

这些选项都不是十分方便，甚至在考虑将其作为方法参数时更是如此。

一种解决方案是声明一个包装接口：

interface TheWholeShabam extends Readable, Writable {}

但这有一个特定的问题：同时支持Readable和Writable的所有实现都必须实现TheWholeShabam，以使其与使用该界面的人员兼容。即使除了保证两个接口的存在之外，它什么也没有提供。

有没有解决此问题的解决方案，还是应该使用包装器接口？

更新

实际上，经常需要使对象既可读又可写，因此仅将参数中的关注点分开并不总是一个干净的解决方案。

更新2

（被提取为答案，因此更易于评论）

更新3

请注意，此操作的主要用例不是流（尽管也必须支持它们）。流在输入和输出之间做出了非常具体的区分，并且职责之间有明确的区分。而是想像一个字节缓冲区，您需要一个可以写入和读取的对象，一个附加了非常特定状态的对象。存在这些对象是因为它们对于异步I / O，编码，

更新4

我尝试的第一件事与以下建议相同（请检查接受的答案），但事实证明它太脆弱了。

假设您有一个必须返回类型的类：

public <RW extends Readable & Writable> RW getItAll();

如果调用此方法，则常规RW由接收对象的变量确定，因此您需要一种描述此var的方法。

MyObject myObject = someInstance.getItAll();

这将起作用，但是再次将其与实现联系在一起，并且实际上可能在运行时抛出classcastexceptions（取决于返回的内容）。

另外，如果要使用RW类型的类变量，则需要在类级别定义泛型。

是的，您可以将您的方法参数声明为扩展了Readable和的未指定类型Writable：

public <RW extends Readable & Writable> void process(RW thing);

方法声明看起来很糟糕，但是使用它比知道统一接口要容易。

如果有一个地方，你需要myObject同时作为Readable与Writable您可以：

• 重构那个地方？阅读和写作是两回事。如果一种方法兼有，那么它可能就不遵循单一责任原则。

• 传递myObject两次，作为Readable和作为Writable（两个参数）。该方法在乎是同一对象还是什么不是对象？

当您不需要可读性或可写性但两者都需要时，当前没有答案可以解决这种情况。您需要保证在写入A时，您可以从A读取该数据，而不是写入A并从B读取数据，只是希望它们实际上是同一对象。用例很多，例如在所有要使用ByteBuffer的地方。

无论如何，我几乎已经完成了我正在处理的模块，目前我选择了包装器接口：

interface Container extends Readable, Writable {}

现在您至少可以执行以下操作：

Container container = IOUtils.newContainer();
container.write("something".getBytes());
System.out.println(IOUtils.toString(container));

我自己的容器实现（当前为3个）都实现了Container而不是单独的接口，但是如果有人在实现中忘记了这一点，IOUtils提供了一种实用程序方法：

Readable myReadable = ...;
// assuming myReadable is also Writable you can do this:
Container container = IOUtils.toByteContainer(myReadable);

我知道这不是最佳解决方案，但由于容器仍然是一个相当大的用例，因此它仍然是目前的最佳解决方案。

给定一个通用的MyObject实例，您总是需要知道它是否支持读取或写入。因此，您将获得如下代码：

if (myObject instanceof Readable)  {
    Readable  r = (Readable) myObject;
    readThisReadable( r );
}

在简单的情况下，我认为您无法对此进行改进。但是，如果readThisReadable要在读取文件后将Readable 写入另一个文件，它将变得很尴尬。

所以我可能会这样做：

interface TheWholeShabam  {
    public boolean  isReadable();
    public boolean  isWriteable();
    public void     read();
    public void     write();
}

readThisReadable现在readThisWholeShabam，将此参数作为参数可以处理实现TheWholeShabam的任何类，而不仅仅是MyObject。 而且它可以写，如果它是可写的，如果它是不是不会写。（我们有真正的“多态性”。）

因此，第一组代码变为：

TheWholeShabam  myObject = ...;
if (myObject.isReadable()
    readThisWholeShebam( myObject );

您可以通过readThisWholeShebam（）进行可读性检查，在此处保存一行。

这确实意味着我们以前的Readable-only必须实现isWriteable（）（返回false）和write（）（不执行任何操作），但是现在它可以遍及以前无法企及的所有地方，并且可以处理TheWholeShabam的所有代码对象将处理它，而无需我们进一步努力。

另一件事：如果您可以处理不读取的类中对read（）的调用，以及不浪费内容就不进行写入的类中对write（）的调用，则可以跳过isReadable（）和isWriteable （） 方法。如果可行，这将是最优雅的处理方式。