Question

我不得不重构一个项目中的几个类，并对如何解决覆盖问题提出疑问。

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

SwitchChannel曾经有一个名为blockUntilGetMessageLength()的方法，我不得不搬到名为ActiveSocket的新班级。

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

我的问题是如何解决@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;
}

Answer 1

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

使用此实例，您可以blockUntilGetMessageLength的{{1}}方法调用ActiveSocket blockUntilGetMessageLength方法。

您必须删除AccSysChannel注释

Answer 2

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;
}
}

Answer 3

很容易......你做不到。 Java不支持多重继承。您可以使用不同的设计模式，可能是Decorator或其他东西，或者使SwitchChannel继承自ActiveSocket，但您不能使用分割继承。

将文件移动到另一个类，并且无法使重写的方法正常工作

3 个答案: