用java为堆栈正确编写面向对象的代码

我试图以一种面向对象的方式编写代码。在这种特殊情况下，我希望在O（1）时间内跟踪堆栈的最小值。我知道怎么做，我的想法，我的想法是，有另一个堆栈，跟踪每次推送和弹出的最小值

我已经将每个类嵌套在程序类中，该类称为minStack，这似乎不是正确的做法，但是，当我创建minStack实例并调用其变量时，对于常规堆栈来说效果很好。我创建了一个类，它扩展了一个名为StackWithMin的堆栈，但我不知道如何调用它的值。我应该创建StackWithMin的新实例吗？如果是这样，我该怎么做？我在主函数上方的代码末尾执行了此操作，但peek（）始终返回null

class minStack {

public class Stack {

    Node top;
    Object min = null;

    Object pop() {
        if(top != null) {
            Object item = top.getData();
            top = top.getNext();
            return item;
        }
        return null;
    }

    void push(Object item) {
        if(min == null) {
            min = item;
        }
        if((int)item < (int)min) {
            min = item;
        }
        Node pushed = new Node(item, top);
        top = pushed;
    }

    Object peek() {
        if(top == null) {
            //System.out.println("Its null or stack is empty");
            return null;
        }   
        return top.getData();
    }

    Object minimumValue() {
        if(min == null) {
            return null;
        }
        return (int)min;
    }
}

public class Node {
    Object data;
    Node next;

    public Node(Object data) {
        this.data = data;
        this.next = null;
    }

    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }

    public void setNext(Node n) {
        next = n;
    }

    public Node getNext() {
        return next;
    }

    public void setData(Object d) {
        data = d;
    }

    public Object getData() {
        return data;
    }
}

public class StackWithMin extends Stack {
    Stack s2;

    public StackWithMin() {
        s2 = new Stack();
    }

    public void push(Object value) {
        if((int)value <= (int)min()) {
            s2.push(value);
        }
        super.push(value);
    }

    public Object pop() {
        Object value = super.pop();
        if((int)value == (int)min()) {
            s2.pop();
        }
        return value;
    }

    public Object min() {
        if(s2.top == null) {
            return null;
        }
        else {
            return s2.peek();
        }
    }
}

Stack testStack = new Stack();
StackWithMin stackMin = new StackWithMin();

public static void main(String[] args) {
    minStack mStack = new minStack();
    //StackWithMin stackMin = new StackWithMin();
    mStack.testStack.push(3);
    mStack.testStack.push(5);
    mStack.testStack.push(2);
    mStack.stackMin.push(2);
    mStack.stackMin.push(4);
    mStack.stackMin.push(1);
    System.out.println(mStack.testStack.peek());
    System.out.println(mStack.stackMin.peek());
    mStack.testStack.pop();


}

}

class minStack{
公共类堆栈{
节点顶部；
Object min=null；
对象pop（）{
如果（顶部！=null）{
对象项=top.getData（）；
top=top.getNext（）；
退货项目；
}
返回null；
}
无效推送（对象项）{
if（min==null）{
最小值=项目；
}
如果（（内部）项目<（内部）最小值）{
最小值=项目；
}
节点按下=新节点（项目，顶部）；
顶部=推动；
}
对象peek（）{
if（top==null）{
//System.out.println（“其null或堆栈为空”）；
返回null；
}   
返回top.getData（）；
}
对象最小值（）{
if（min==null）{
返回null；
}
返回（int）min；
}
}
公共类节点{
对象数据；
节点下一步；
公共节点（对象数据）{
这个数据=数据；
this.next=null；
}
公共节点（对象数据，节点下一步）{
这个数据=数据；
this.next=next；
}
公共void setNext（节点n）{
next=n；
}
公共节点getNext（）{
下一步返回；
}
公共void setData（对象d）{
数据=d；
}
公共对象getData（）{
返回数据；
}
}
公共类StackWithMin扩展堆栈{
堆栈s2；
公共StackWithMin（）{
s2=新堆栈（）；
}
公共无效推送（对象值）{
如果（（int）value，我建议创建像这样的通用接口
Stack

interface Stack<T> {

    void push(T item);

    T pop();

    T peek();
}

现在我们来讨论存储最小值的部分。我们可以扩展我们的
SimpleStack
类，并使用另一个
SimpleStack
添加字段。但是我认为这最好是对
堆栈进行另一个实现，并存储两个值堆栈和最小值堆栈。下面的示例是。我对ow使用
Comparator
来比较对象，所以您可以使用任何其他对象类型

class StackWithComparator<T> implements Stack<T> {

    private Comparator<T> comparator;
    private SimpleStack<T> mins = new SimpleStack<>();
    private SimpleStack<T> data = new SimpleStack<>();

    public StackWithComparator(Comparator<T> comparator) {
        this.comparator = comparator;
    }

    public void push(T item) {
        data.push(item);
        if (mins.peek() == null || comparator.compare(mins.peek(), item) >= 0) {
            mins.push(item);
        } else {
            mins.push(mins.peek());
        }
    }

    public T pop() {
        mins.pop();
        return data.pop();
    } 

    public T peek() {
        return data.peek();
    }

    public T min() {
        return mins.peek();
    }
}

类StackWithComparator实现堆栈{
专用比较器；
private SimpleStack mins=new SimpleStack（）；
私有SimpleStack数据=新SimpleStack（）；
带比较器的公共堆栈（比较器比较器）{
这个比较器=比较器；
}
公共无效推送（T项）{
数据推送（项目）；
if（mins.peek（）==null | | comparator.compare（mins.peek（），item）>=0）{
分钟推送（项目）；
}否则{
分钟推送（分钟窥视（））；
}
}
公共广播电台{
mins.pop（）；
返回data.pop（）；
} 
公共T peek（）{
返回data.peek（）；
}
公营部门{
return mins.peek（）；
}
}

现在您可以像这样使用这两种实现

SimpleStack<Integer> s1 = new SimpleStack<>();
s1.push(1);
s1.push(2);
s1.push(3);

System.out.println(s1.pop()); // print 3
System.out.println(s1.pop()); // print 2
System.out.println(s1.pop()); // print 1

StackWithComparator<Integer> s2 = new StackWithComparator<>(new Comparator<Integer>() {
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1, o2);
    }
});
s2.push(1);
s2.push(2);
s2.push(3);
s2.push(0);
s2.push(4);

System.out.println(s2.min() + " " + s2.pop()); // print 0 4
System.out.println(s2.min() + " " + s2.pop()); // print 0 0
System.out.println(s2.min() + " " + s2.pop()); // print 1 3
System.out.println(s2.min() + " " + s2.pop()); // print 1 2
System.out.println(s2.min() + " " + s2.pop()); // print 1 1

SimpleStack s1=新的SimpleStack（）；
s1.推动（1）；
s1.推动（2）；
s1.推（3）；
System.out.println（s1.pop（））；//打印3
System.out.println（s1.pop（））；//打印2
System.out.println（s1.pop（））；//打印1
StackWithComparator s2=新的StackWithComparator（新的比较器（）{
公共整数比较（整数o1，整数o2）{
返回整数。比较（o1，o2）；
}
});
s2.推（1）；
s2.推（2）；
s2.推（3）；
s2.推（0）；
s2.推（4）；
System.out.println（s2.min（）+“”+s2.pop（））；//打印0 4
System.out.println（s2.min（）+“”+s2.pop（））；//打印0
System.out.println（s2.min（）+“”+s2.pop（））；//打印13
System.out.println（s2.min（）+“”+s2.pop（））；//打印12
System.out.println（s2.min（）+“”+s2.pop（））；//打印1
这就是我要找的，谢谢，T的相对接口，这意味着我们可以用任何类型的数据类型对它进行观察，这很酷。谢谢你。
SimpleStack<Integer> s1 = new SimpleStack<>();
s1.push(1);
s1.push(2);
s1.push(3);

System.out.println(s1.pop()); // print 3
System.out.println(s1.pop()); // print 2
System.out.println(s1.pop()); // print 1

StackWithComparator<Integer> s2 = new StackWithComparator<>(new Comparator<Integer>() {
    public int compare(Integer o1, Integer o2) {
        return Integer.compare(o1, o2);
    }
});
s2.push(1);
s2.push(2);
s2.push(3);
s2.push(0);
s2.push(4);

System.out.println(s2.min() + " " + s2.pop()); // print 0 4
System.out.println(s2.min() + " " + s2.pop()); // print 0 0
System.out.println(s2.min() + " " + s2.pop()); // print 1 3
System.out.println(s2.min() + " " + s2.pop()); // print 1 2
System.out.println(s2.min() + " " + s2.pop()); // print 1 1