Question

说我有以下类/接口：

public Interface stackInt {
       public Node pop();
       public void push();
}

class Node {
     Node next;
     int Data;
     Node(int n){...}
     Node() {next=null, Data=null}
}

class bigNode extends Node {
      String Data2;
      Double Data3;
      Node(int n, String s, Double d) {Data=n; Data2=s; Data3=d}
}


public class Stack implements StackInt {
       Node head, tail, next;
       Stack(int n) {
            ....constructor...
       }
       Stack() {
            head=tail=next=null; (() constructor so can be extended)
       }

       generic pop() and push() implementations;

       public String toString() {
            //return string concatanateion of all data values
       }
}


public class bigStack extends Stack implements StackInt {
       //EXACT SAME AS STACK, BUT WITH bigNode instead of Node. bigNode(,,) 
        different constructor, but for example, the only difference for pop wooud
        return bigNode instead of Node.

 }

根据良好的OOP设计，我有以下问题：

1）bigStack是否也应该实现StackInt，因为它已经扩展了Stack？ 2）无论如何都不要覆盖所有方法;例如我要返回的pop方法一个bigNode而不仅仅是一个Node（我也想要Data2和Data3访问），或者都是那些没有完全相同的原型/功能的方法必须被覆盖？

从设计的角度来看，这看起来合情合理吗？

Node和Stack在一个文件中，bigNode和bigStack在另一个文件中，StackInt在第三个，然后main（）在另一个文件中。

main（）在自己的包中，其余的在com.xxx.DSImpl中吗？

Answer 1

您需要研究Java泛型：

public interface StackInt<T> {
       public T pop();
       public void push(T node);
}

public class Stack<T> implements StackInt<T>
{
    ...
}

在主...

Stack<Node>    nodeStack    = new Stack<Node>();
Stack<BigNode> bigNodeStack = new Stack<BigNode>();

Answer 2

无论您是否明确说出，

bigStack都会实施StackInt。你可以做两件事：

阻止bigStack扩展Stack。
阻止Stack实施StackInt。

让bigStack.pop()返回bigNode（从设计的角度来看）是可以的，但让bigStack.push()仅接受bigNode作为参数是不行的，因为会违反Liskov substitution principle。

Int 通常被视为 Integer 的缩写，而不是 Interface 的缩写。使用一致的大写。

合理实现从单个超类继承的各种DS

2 个答案: