0

假设我有以下类/接口：

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 而不仅仅是一个节点（我也想要 Data2 和 Data3 访问），还是所有这些没有完全相同原型/功能的方法都必须被覆盖？

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

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

main() 在它自己的包中，其余的可能在 com.xxx.DSImpl 中？

4

2 回答 2

2

你需要研究 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>();
于 2013-10-27T17:24:45.670 回答
0

bigStackimplements StackInt，无论您是否明确表示。你可以做两件事：

  • 防止bigStack延伸Stack。
  • 防止Stack实施StackInt。

let bigStack.pop()return a 是可以的（从设计的角度来看），但是 let accept only as parameter 是bigNode不行的，因为这会违反Liskov 替换原则。bigStack.push()bigNode

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

于 2013-10-27T17:27:17.807 回答