подкласс minStack, использующий один объект для минимального стека и обычного стека

Question

Я работаю через книгу CTCI и нашел этот ответ непонятным. Цель состоит в том, чтобы создать структуру данных стека, которая может выдвигать, выталкивать и минировать (получить минимальный элемент в стеке) в O (1). Я закодировал класс, который имеет два стека, один для хранения минимумов, а другой работает как обычный стек. Код ниже. Это работает, насколько мне известно из тестирования.

   public static class StackWithMin extends Stack<Integer>{
      Stack<Integer> stack;
      Stack<Integer> minStack;

      public StackWithMin(){
         stack = new Stack<Integer>();
         minStack = new Stack<Integer>();
      }

      public void push(int value){
         if(value <= min()){
            minStack.push(value); 
         }
         stack.push(value);
      }

      public Integer pop(){
         int value = stack.pop();
         if(value == min()){
            minStack.pop();
         }
         return value;
      }
      public int min(){
         if(minStack.isEmpty()){
            return Integer.MAX_VALUE;
         }
         return minStack.peek();  
      }
   }

Однако ответ, приведенный в книге, мне не совсем понятен. Я прошел два курса по Java, но последние два провел на C, поэтому мои концепции ООП немного устарели. Класс имеет только одно поле стека и использует супер вызов для обновления «обычного» стека и вызов s2 для обновления минимального стека. Глядя на это в Java, визуализатор показывает только один объект стека, который, очевидно, хранит два разных стека. Эта реализация работает, но я не уверен, почему именно. Разъяснение будет оценено!

public class Q2 /* MinStack */ extends Stack<Integer> {
    private Stack<Integer> min = new Stack<Integer>();

    public void push(int item) {
        if (min.isEmpty() || item < min()) {
            min.push(item);
        }
        super.push(item);
    }

    public Integer pop() {
        int item = super.pop();
        if (item == min()) {
            min.pop();
        }
        return item;
    }

    public Integer min() {
        return min.peek();
    }

Answer 1

Этот код действительно генерирует два стека. Тот факт, что класс Q2 расширяет класс Stack<Integer>, означает, что все, что существует в родительском классе, существует и в классе Q2, включая «обычный» стек, но просто для доступа к нему в Java вам нужно использовать super ключевое слово.

Это изображение может объяснить эту концепцию ООП, включающую родительский класс (все, что существует в «Bird», существует в «AngryBird»):

Теперь, поскольку ваш Q2 класс, «включающий» стек и функционирующий как стек, вы создаете новый второй стек для минимального значения в качестве члена вашего класса.

Если вам интересно, что «не так» в вашем решении, то, что вы на самом деле не используете базовый класс, ваш код будет работать даже без оператора extends Stack<Integer>.