Java接口实现报错：未重写SomethingCollection的add(Something)方法

Let's walk through exactly what's causing this error and how to fix it, plus a couple of extra tweaks to make your code more reliable.

Why the Error Happens #

The SomethingCollection interface defines an add(Something something) method, but your List class has an add(Node node) method. In Java, method overriding requires an exact match of the method signature—including parameter types.

Even though Node implements Something, your add(Node) is a separate overloaded method, not an implementation of the interface's add(Something). The compiler sees that List hasn't fulfilled the interface's requirement, hence the error.

Step 1: Fix the add Method Signature #

Update your add method to accept a Something parameter instead of Node. Since your List is built on Node instances, add a safety check to ensure the input is a Node before casting:

public void add(Something something) {
    // Ensure we only add Node instances (our List relies on Node's next pointer)
    if (!(something instanceof Node)) {
        throw new IllegalArgumentException("Only Node objects can be added to this List");
    }
    Node node = (Node) something;
    
    // Handle empty list case to fix uninitialized maxValue bug
    if (head == null) {
        maxValue = node.getValue();
    } else if (node.getValue() > maxValue) {
        maxValue = node.getValue();
    }
    
    node.setNext(head);
    head = node;
}

I added a check for empty lists here—your original code would have had issues if the first node had a negative value (since maxValue defaults to 0).

Step 2: Fix the removeMaxValue Method #

Your removeMaxValue returns Node, which is fine (Java allows covariant return types for overridden methods). But there are two bugs to fix:

1. The original code had a code path with no return value (if the loop finishes without finding the max, which shouldn't happen but the compiler flags it).
2. Storing maxValue can lead to outdated state if nodes are removed. Instead, dynamically find the max node each time:

public Node removeMaxValue() {
    if (head == null) {
        return null;
    }

    Node current = head;
    Node prev = null;
    Node maxNode = head;
    Node maxPrev = null;

    // Traverse to find the node with the highest value
    while (current != null) {
        if (current.getValue() > maxNode.getValue()) {
            maxNode = current;
            maxPrev = prev;
        }
        prev = current;
        current = current.getNext();
    }

    // Remove the max node from the list
    if (maxPrev == null) {
        // Max node is the head
        head = maxNode.getNext();
    } else {
        maxPrev.setNext(maxNode.getNext());
    }

    // Update maxValue for future operations
    if (head != null) {
        maxValue = head.getValue();
        current = head;
        while (current != null) {
            if (current.getValue() > maxValue) {
                maxValue = current.getValue();
            }
            current = current.getNext();
        }
    }

    return maxNode;
}

Step 3: Fix maxValue Initialization #

In your default List() constructor, maxValue is uninitialized (defaults to 0). Update it to start with the smallest possible integer so the first added node's value will always be larger:

public List() {
    this.head = null;
    this.maxValue = Integer.MIN_VALUE;
}

For the constructor that takes a Node, traverse the input list to find the actual max value (not just the head's value):

public List(Node p) {
    this.head = null;
    this.maxValue = Integer.MIN_VALUE;
    
    // Copy the input nodes to avoid modifying the original list
    Node temp = p;
    while (temp != null) {
        add(new Node(temp.getValue()));
        temp = temp.getNext();
    }
}

Quick Recap #

• Always match method signatures exactly when implementing interfaces—small differences (like parameter types) break overriding.
• Be cautious with stored state like maxValue—it can easily get out of sync when modifying the list. Dynamic lookup avoids this issue for simple lists.

内容的提问来源于stack exchange，提问作者Ofir Sasson