2

我不得不在一个项目中重构几个类，并且有一个关于如何解决覆盖问题的问题。

我有一个名为的类AccSysChannel，它继承自另一个名为的类，SwitchChannel并有一个blockUntilGetMessageLength()用 a 表示的方法@Override（下面的代码）。

SwitchChannel曾经有一个方法被调用blockUntilGetMessageLength()，我不得不转移到一个名为ActiveSocket.

我现在的问题是我不知道如何使用现在的@Override blockUntilGetMessageLength()方法。由于`AccSysChannel 类中包含许多其他方法，仍然必须保持其从 l 的继承。AccSysChannelActiveSocketAccSysChannelSwitchChanne

我的问题是如何解决这个@Override问题？希望这是有道理的。任何帮助/方向将不胜感激。谢谢你。

这是我blockUntilGetMessageLength()的AccSysChannel：

....

@Override
protected int blockUntilGetMessageLength() {
    byte[] b = new byte[2];
    byte[] other = new byte[14];
    int size = -1;
    String otherStr;

    try {
        Iterator<ActiveSocket> it = activeSockets.iterator();
        while (it.hasNext()) {
            ActiveSocket activeSocket = it.next();
            DataInputStream dataInputStream = activeSocket.getDataInputStream(); 
            if (dataInputStream.markSupported()) {
                while (size == -1) {
                    dataInputStream.mark(14);
                    dataInputStream.readFully(other, 0, 14);
                    dataInputStream.reset();
                    otherStr = new String(other);
                    LOGGER.trace("Checking slice of the message: " + otherStr);
                    size = otherStr.indexOf("<AT");
                    if (size == -1){
                        size = otherStr.indexOf("<DSCREDIT");
                    }
                    LOGGER.trace("Found tag at index: " + size);
                    switch (size) {
                        case 0:
                        case 1:
                            // intentional fallthrough
                        case -1:
                            if (size == 0 || size == 1) {
                                size = -1;
                            }
                            dataInputStream.readFully(other, 0, 10);
                            break;
                        default:
                            // consume the bytes preceding the size bytes
                            dataInputStream.readFully(other, 0, size - 2);
                            // read the size bytes
                            dataInputStream.readFully(b, 0, 2);
                            size = (((((int) b[0]) & BYTEMASK) << BYTESHIFT) | (((int) b[1]) & BYTEMASK));
                            LOGGER.trace("Setting size to: " + size);
                    }
                }
            }
        }
    } catch (IOException ex) {
        if (this.shouldTerminate) {
            return 0;
        } else {
            Iterator<ActiveSocket> it = activeSockets.iterator();
            while (it.hasNext()) {
                ActiveSocket activeSocket = it.next();
                Socket socket = activeSocket.getSocket();
                LOGGER.warn(FormatData.formatStack(ex));
                synchronized (socket) {
                    socket.notify();
                }
            }
            return 0;
        }
    }
    return size;
}
4

3 回答 3

2

众所周知，在 Java 中，我们不能扩展 2 个类。所以在这里我们将不得不使用组合。与AccSysChannel 扩展一样SwitchChannel，将 的实例ActiveSocket作为 的属性AccSysChannel。

使用此实例，您可以从 的方法调用blockUntilGetMessageLength方法。ActiveSocketblockUntilGetMessageLengthAccSysChannel

您将不得不删除@Override注释

于 2013-09-13T12:37:33.797 回答
1

Java不支持多重继承，因为它导致的问题多于解决的问题。相反，Java 支持多接口继承，它允许一个对象从不同的接口继承许多方法签名，条件是继承对象必须实现这些继承的方法。

我建议改用接口，您可以轻松解决问题

例子：

BlockUntilGetMessageLengthItf.java

 public interface BlockUntilGetMessageLengthItf {
  public int blockUntilGetMessageLength();
 }

ActiveSocket.java

public class ActiveSocket{

public ActiveSocket(BlockUntilGetMessageLengthItf ref) {
    // call local
    blockUntilGetMessageLength();

    // call to AccSysChannel  
    ref.blockUntilGetMessageLength();
}

private int blockUntilGetMessageLength(){
    // ....
    return 0;
}
}

AccSysChannel.ajva

public class AccSysChannel extends SwitchChannel implements BlockUntilGetMessageLengthItf{

public static void main(String[] args) {
    new AccSysChannel().init();
}

private void init() {

    BlockUntilGetMessageLengthItf ref  = this;

    new ActiveSocket(ref);      

}

@Override
public int blockUntilGetMessageLength() {
    // TODO Auto-generated method stub
    return 0;
}
}
于 2013-09-13T12:35:59.420 回答
0

这很容易......你不能。Java 不支持多重继承。您可以使用不同的设计模式，可能是装饰器或其他东西，或者SwitchChannel从继承ActiveSocket，但您不能拆分继承。

于 2013-09-13T12:31:37.633 回答