Java数组实现压栈弹栈操作【基础版】

要求：

1.栈可以存储java中的任何引用类型的数据
2.在这个栈中提供push方法模拟压栈（栈满了，要有提示信息）
3.在栈中提供给pop方法模拟弹栈。（栈空了。也要有提示信息）
4.编写测试程序，new 栈对象，调用push 和pop方法来模拟压栈弹栈的动作
5.假设栈的默认初始化容量是10,（请注意无参构造方法的编写方式）

栈类：MyStcck

1定义属性

1.1定义Object类型一维数组

向栈当中存储元素，我们这里使用一维数组模拟。存到栈中，就表示存储到数组中
因为数组是我们学习java的第一个容器
为什么选择Object类型数据？因为这个栈可以存储java中任何引用类型的数据
new Animal()对象可以放进去，new person()对象也可以放进去。因为Animal和Person的超级父类就是Object
包括String也可以存储进去，因为String父类也是Object

private Object[] elements;  //属性私有化

1.2栈帧，永远指向栈元素

那么这个默认称呼是指应该是多少。注意：最初的栈是空的，一个元素都没有
private int index = 0;  //如果index采用0，表示栈帧指向了底部元素的上方
private int index = -1;  //如果index采用1，表示栈帧指向了底部元素

  private int index = -1;

2压栈

2.1（1）和（2）本质上一样，注意分清楚是先自加1，在赋值

（1）

this.index++;
elements[index] = obj; 

（2）

elements[++index] = obj 

2.2注意：所有的System.out.println()方法执行时，如果输出引用的话，自动调用引用的toString()方法

//声明：所有的System.out.println()方法执行时，如果输出饮用的话，自动调用引用的toString()方法
        System.out.println("压栈"+ obj + "成功，栈帧指向" + index);

2.3完整压栈代码

public void push(Object obj){
        if(this.index >= this.elements.length - 1){
            System.out.println("压栈失败，栈已满！");
        }
        //程序能走到这里，说明栈没满
        this.index++;
        elements[index] = obj;         //以上两句可以写成elements[++index] = obj  先自加一后赋值
        //再声明一次：所有的System.out.println()方法执行时，如果输出引用的话，自动调用引用的toString()方法
        System.out.println("压栈"+ obj + "成功，栈帧指向" + index);
    }

2.4测试结果

3弹栈

public void pop(){
        if(index <0){
            System.out.println("弹栈失败，栈已空！");
            return;
        }
        //程序能够执行到此处，说明栈没有空
        System.out.print("弹栈" + elements[index] + "元素成功");
        //栈帧向下移动一位
        index--;
        System.out.println("栈帧指向" + index);
    }

4完整代码

4.1栈类

package com.power.Javase.array.homework;
/*
要求：
1.栈可以存储java中的任何引用类型的数据
2。在这个栈中提供push方法模拟压栈（栈满了，要有提示信息）
3.在栈中提供给pop方法模拟贪占。（栈空了。也要有提示信息）
4。编写测试程序，new 站对象，调用push 和pop方法来模拟压栈弹栈的动作
5.假设栈的默认初始化容量是10,（请注意无参构造方法的编写方式）
 */

public class MyStcck {
    //向栈当中存储元素，我们这里使用一维数组模拟。存到栈中，就表示存储到数据中心
    //因为数组是我们学习java的第一个容器
    //为什么选择Object类型数据？因为这个站可以存储java中任何引用类型的数据
    // new Animal()对象可以放进去，new person()对象也可以放进去。因为Animal和Person的超级父类就是Object
    //包括String也可以存储进去，因为String父类也是Object
    private Object[] elements;  //属性私有化

    //栈帧，永远指向栈部元素
    //那么这个默认称呼是指应该是多少。注意：最初的栈是空的，一个元素都没有
    //private int index = 0;  //如果index采用0，表示栈帧指向了顶部元素的上方
    //private int index = -1;  //如果index采用1，表示栈帧指向了顶部元素
    private int index = -1;

    public MyStcck() {
        //一维数组动态初始化
        //栈的默认初始化容量是10
        this.elements = new Object[10];
        //给index动态初始化
        this.index = -1;
    }

    /**
     * 压栈的方法
     *
     * @param obj
     */
    public void push(Object obj){
        if(this.index >= this.elements.length - 1){
            System.out.println("压栈失败，栈已满！");
        }
        //程序能走到这里，说明栈没满
        this.index++;
        elements[index] = obj;         //以上两句可以写成elements[++index] = obj  先自加一后赋值
        //再声明一次：所有的System.out.println()方法执行时，如果输出饮用的话，自动调用引用的toString()方法
        System.out.println("压栈"+ obj + "成功，栈帧指向" + index);
    }

    /**
     * 从数组中望外取元素
     * 每去一个元素，栈帧减一
     */
    public void pop(){
        if(index <0){
            System.out.println("弹栈失败，栈已空！");
            return;
        }
        //程序能够执行到此处，说明栈没有空
        System.out.print("弹栈" + elements[index] + "元素成功");
        //栈帧向下移动一位
        index--;
        System.out.println("栈帧指向" + index);
    }



    //set和get也许用不上，但是你必须写上，这是规矩
    //封装：第一步：属性私有化，第二步：对外提供setter和getter
    public Object[] getElements() {
        return elements;
    }

    public void setElements(Object[] elements) {
        this.elements = elements;
    }
}

4.2测试类

package com.power.Javase.array.homework;

public class MyStackTest {
    public static void main(String[] args) {
        //创建一个栈对象，初始化容量是10个
        MyStcck stack = new MyStcck();

        //调用方法压栈
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());
        stack.push(new Object());

        //压这个元素失败了
        //stack.push(new Object());
        //System.out.println("================================");

        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();
        stack.pop();stack.pop();


    }
}

4.3执行结果

可以看出栈的特点，后进先出