具有最大代码重用性的链表节点实现答案

【问题标题】：Linked list node implementation with maximum code reuse具有最大代码重用性的链表节点实现
【发布时间】：2017-08-09 13:13:37
【问题描述】：

目前作为练习 SOLID 原则和基本数据结构的练习，我正在尝试实现具有尽可能多的代码重用的链表类型结构。目前，我有：

package structures.linked;

public class SingleNode<T> {

    private T data;
    private SingleNode<T> next;

    public SingleNode(T data, SingleNode<T> next) {
        this.data = data;
        this.next = next;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public SingleNode<T> getNext() {
        return next;
    }

    public void setNext(SingleNode<T> next) {
        this.next = next;
    }

}

还有……

package structures.linked;

public class DoubleNode<T> extends SingleNode<T> {

    private DoubleNode<T> prev;

    public DoubleNode(T data, DoubleNode<T> next, DoubleNode<T> prev) {
        super(data, next);
        this.prev = prev;
    }

    public DoubleNode<T> getPrev() {
        return prev;
    }

    public void setPrev(DoubleNode<T> prev) {
        this.prev = prev;
    }

    public DoubleNode<T> getNext() {
        return (DoubleNode<T>) super.getNext();
    }

    public void setNext(DoubleNode<T> next) {
        super.setNext(next);
    }
}

在我看来，DoubleNode<T> 内部的getNext() 违反了 Liskov 的替换原则。是这样吗？有没有更好的方法来实现这一点，同时仍然重用 SingleNode<T> 中的代码并且不违反 SOLID 原则？

【问题讨论】：

嘿马修，我认为像这样的问题更适合codereview.stackexchange.com
@Kuba 肯定会在那边发帖，谢谢！

标签： java oop linked-list

【解决方案1】：

您可以通过使用带有附加泛型参数的抽象类来做到这一点：

public abstract class AbstracteNode<T, B extends AbstracteNode<T, ?>> {
    private T data;
    private B nextNode;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public void setNext(B inNextNode){
        this.nextNode = inNextNode;
    }

    public B getNext() {
        return nextNode;
    }
}

然后使用 B 的正确类型对其进行扩展：（在 SingleNode 的情况下，您这样做只是因为使用它的开发人员只需提供 T）

public class SingleNode<T> extends AbstracteNode<T, SingleNode<T>>{}

和

public class DoubleNode<T> extends AbstracteNode<T, DoubleNode<T>> {
    private DoubleNode<T> previousNode;

    public DoubleNode<T> getPrevious() {
        return previousNode;
    }

    public void setPrevious(DoubleNode<T> inPreviousNode) {
        this.previousNode = inPreviousNode;
    }
}

现在您的测试应该可以在没有代码重复和强制转换的情况下运行：

public class Test {
    public static void main(String argv[]){
        SingleNode<Integer> singleNode = new SingleNode<>();
        SingleNode<Integer> nextForSingle = singleNode.getNext();

        DoubleNode<Double> doubleNode = new DoubleNode<>();
        DoubleNode<Double> previousForDouble = doubleNode.getPrevious();
        DoubleNode<Double> nextForDouble = doubleNode.getNext();
    }
}

【讨论】：