如何从另一个类（java）调用 peek() 方法？

Question

我在 A 类中有我的堆栈及其相应的方法。 现在在 B 类中，我想创建一个新堆栈，调用 A 类中的方法。具体来说，我想做的是查看 A 类中堆栈的元素，然后将我喜欢的元素添加到新堆栈中在 B 班。有人可以帮帮我吗？我对此很陌生！ 附：我确实想知道如何跨班级做到这一点；我可以弄清楚如何在同一个类中做到这一点，但我正在努力扩大我对跨类调用方法的理解。谢谢！

编辑： 有人问我参考的代码： newStack.push(oldStack.(StackOne).peek());

我没有这个权利，但这里是元素： StackOne 是我的第一个类的名称，我在其中创建了第一个堆栈，而 oldStack 在该类中。 我想从 StackTwo（我的第二堂课）中看看这些元素。如果我喜欢一个元素，我会将它从 oldStack 推送到 newStack（最终导致类似于我上面发布的内容，但这不起作用）。

Answer 1

这是一个将堆栈封装在其中的类。

MyStack.java

import java.util.Stack;

public class MyStack<T> {
    private Stack<T> stack;

    public MyStack() {
        stack = new Stack<T>();
    }

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

    public void push(T item) {
        stack.push(item);
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        MyStack<String> myStackA = new MyStack<String>();
        MyStack<String> myStackB = new MyStack<String>();

        myStackA.push("Hello");
        myStackA.push("Hi");

        myStackB.push(myStackA.peek());

        System.out.println(myStackA.peek()); //prints Hi
        System.out.println(myStackB.peek()); //prints Hi
    }
}

Answer 2

我制作了一个程序，您可以使用它了解如何从位于一个类（在我的情况下为 A）中的堆栈上获取/查看值，以将其存储到位于另一个类（在我的情况下为 B）的其他堆栈中。

import java.util.*;
class A{
    public Stack st;
        public A(){
        st = new Stack();
    }
    public void pushA(Integer a){
    st.push(new Integer(a));
    }
    public Integer popA(){
    return (Integer)st.pop();
    }
    public Integer peekA(){
    return (Integer)st.peek();
    }
}
class B{
    public Stack st;
    public B(){
        st = new Stack();
    }
    public void pushB(Integer b){
    st.push(b);
    }
    public Integer popB(){
    return (Integer)st.pop();
    }
    public Integer peekB(){
    return (Integer)st.peek();
    }
}
class Main{
    public static void main(String ar[]){
    A stackOfA = new A();
    stackOfA.pushA(12);
    stackOfA.pushA(34);
    stackOfA.pushA(66);
    B stackOfB = new B();
    stackOfB.pushB(stackOfA.peekA());
    System.out.println("A:"+stackOfA.st);
    System.out.println("B:"+stackOfB.st);
    }
}

输出：

A:[12, 34, 66]
B:[66]