目录标题
 
要求：
1定义属性
1.1定义Object类型一维数组
1.2栈帧，永远指向栈元素
   
2压栈
2.1（1）和（2）本质上一样，注意分清楚是先自加1，在赋值
2.2注意：所有的System.out.println()方法执行时，如果输出引用的话，自动调用引用的toString()方法
2.3完整压栈代码
2.4测试结果
   
3弹栈
4完整代码
4.1栈类
4.2测试类
4.3执行结果
  
 

 
要求：
 
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执行结果
 
可以看出栈的特点，后进先出
 

package MyStack;

public class MyStack {
    Object[] objs;
    int index=0;
    //默认的Object{]数组长度为10；
    //index为栈帧，index的数据表示当前栈中有多少个元素
    //当index=objs.length-1的时候，表示栈中元素已满
    //当index=0的时候，表示栈中元素为0个

    //默认的栈空间为10个
    public MyStack() {
        Object[] objs = new Object[10];
    }

    //根据传入的int类型数据开辟栈空间
    public MyStack(int x){
        Object[] objs = new Object[x];
    }

    //压栈操作，每传入一个未知类型数据，index加1
    public void push(Object objs){
        //检验栈帧的值
        if(index==10){
            System.out.println("栈中的数据已满，请先弹栈再继续操作");
            return;
        }
        //将传入的数据输入一维数组objs
        this.objs[index] = objs;
        index++;

    }

    //弹栈操作，将栈中的数据清除
    public void pop(){
        if(index==0){
            System.out.println("栈中的数据已空！请输入数据后再弹栈！");
            return;
        }

        this.objs[index] = null;
        index -- ;
    }
}
 
 
 
package MyStack;

public class Test {
    public static void main(String[] args) {
        MyStack myStack = new MyStack();

        //myStack的一维数组还未创建?
        System.out.println(myStack.objs);

        //---------------------
        System.out.println("=============");
        myStack.objs = new Object[10];
        System.out.println(myStack.objs.length);
        for (int i = 0; i <myStack.objs.length ; i++) {
            System.out.println(myStack.objs[i]+" "+i);
        }

        //弹栈操作
        myStack.pop();
        System.out.println("--------------------");
        for (int i = 0; i < 10 ; i++) {
            myStack.push("30.0");
            System.out.println(myStack.index);
        }
        myStack.push("20");
    }
}
 
       在"MyStack"类中设定了无参传入的情况下，应该创建一个默认长度为10的一维数组，可是在测试的时候，却并没有创建默认一维数组呢？

栈
 
栈是一种重要的数据结构，是限定仅在表尾进行插入或删除操作的线性表。表尾称为栈顶，表头称为栈底。栈的修改是按照后进先出的原则的。栈可以用顺序表和链表实现，在这里用链表实现最基本的入栈，弹栈操作。
 
代码
 
#include<iostream>
#include<cstdlib>
using namespace std;
typedef struct data
{
	int data;
}datas;
struct stack
{
	struct stack* base;
	struct stack* top;
	struct stack* next;
	struct data* info;
};
stack* InitStack()//初始化
{
	struct stack* s;
	s = new stack;
	s->base = s->top;
	return s->base;
}
stack* PushStack(struct stack* s)//压栈
{
	int e;//栈元素
	struct stack* base,*top;
	cout << "请输入入栈数据,输入-1表示结束" << endl;
	while (true)
	{
		cin >> e;
		if (e == -1)
			break;
		else
		{
			base = new stack;
			top = new stack;
			top->info = new datas;
			top->info->data = e;
			top->next = s;
			s = top;
		}
	}
	return s;
}
stack* PopStack(struct stack* s)//弹栈
{
	struct stack* s1;
	cout << "请输入需要弹出的个数" << endl;
	int n;
	cin >> n;
	for(int i=0;i<n;i++)
	{
		s1 = new stack;
		s1 = s;
		cout << "弹出的是:" << s->info->data << endl;
		s = s->next;
		free(s1);
	}
	return s;
}
int main()
{
	struct stack* s,*s1,*s2;
	s = InitStack();
	s1 = PushStack(s);
	s2 = PopStack(s1);
	system("pause");
	return 0;
}


 
运行效果
 

萌新代码，面向过程，勿喷，对栈内存理解不深！
 希望一些对于此类作业烦恼的同级生有些许帮助，也可以在评论区提供帮助和修改以及错误的地方！
 思路
 先进后出，优先解决压栈的问题，之后解决弹栈和main方法
 功能
 1）随时模拟压栈
 2）随时模拟弹栈
 3）防止异常和各种错误
 4）随时可以遍历“栈”中存在的变量的方法，压栈弹栈栈帧清晰可见！
 使用演示：
 压栈：
 
 栈满检测：
 
 遍历栈内存和栈帧：
 
 只要栈中有变量就会输出栈帧：
 
 
弹栈：
 
 栈空检测：（没有变量，栈帧不输出！）
 
 源码：
 
import java.util.Scanner;
public class MoveTest01 {
    //局部变量供栈方法的遍历数组使用
    static int i;
    //创建Object[]数组，作为栈，并且限制“内存上限”为5;
    static Object[] os = new Object[5];
    //创建数组，模拟入栈
    static num[] l = {new A(),new B(),new C(),new D(),new E(),new F()};

    public static void main(String[] args) {
        int a =0;//遍历Object[]数组时的控制
        boolean c = true;//控制循环
        boolean d = true;//检测栈内存使用量防止异常
        Scanner s = new Scanner(System.in);
        do {
            System.out.println("===========================");
            System.out.print("请选择”压栈““弹栈”或“列出栈内存中储存的变量指向的方法”，输入“退出”将会结束程序！:");
            String z = s.next();
            //判定用户输入
            if (z.equals("压栈")) {
                //防止数列超限
                if(a > (os.length - 1)){
                    d = false;
                    System.out.println("栈内存已满！请弹栈后压栈！");
                }
                if(d){
                  //调用num[]数组模拟入栈
                  l[a].leng();
                  a++;
                }
                //防止if(d)锁死
                d = true;
            } else if (z.equals("弹栈")) {
                //调用pop方法，模拟弹栈，并初始化计数
                pop();
                a = 0;
                i = 0;
            } else if (z.equals("退出")) {
                //结束do...while循环体
                c = false;
            } else if (z.equals("列出栈内存中储存的变量指向的方法")) {
                int index = -1;//创建栈帧
                if(os[0] == null){
                    System.out.println("栈内没有已装载的变量！");
                }
                for (int k = os.length - 1; k > -1; k--) {
                    //判定如果Object[]数组内的各个属性，如果不等于null则输出声明
                    if(!(os[k] == null)){
                        index++;
                        System.out.println("栈内存中已入栈的变量的方法有：" + os[k]);
                    }
                }
                //如果栈帧的值不为0，则输出结果
                if(!(index == -1)){
                    System.out.println(os[index] + "《== 栈帧指向");
                }
            }
        }while (c);
    }
    //模拟栈
    public static void Zhan(Object o){
        if(i < os.length) {
            //给Object[]数组赋值
            os[i] = o;
            System.out.println("目标：" + os[i] + "的所有变量已压入栈内！");
            i++;
        }
    }

    public static void push(String c){
        //接收下面类传来的参数并赋值给Zhan()
        Zhan(c);
    }

    public static void pop(){
        //检测数组第一位的值是不是空，如果是则输出消息
        if(os[0] == null){
            System.out.println("栈内没有已装载的变量！无法弹栈！");
        }
        //模拟弹栈
        for(int k = (os.length - 1);k >= 0;k--){
            //遍历数组，将数组内不是null的值全部输出并初始化为null
            if(!(os[k] == null)) {
                System.out.println(os[k] + "的所有变量：已弹出内存！");
                os[k] = null;
            }
        }
    }
}
class num{
    public void leng(){
        //让下面的方法有个共同的父类，并且调用时统一输出自己的名字给栈
        MoveTest01.push(getClass().getName());
    }
}
//即将入方法区的方法，假设里面有变量（也可以直接把这些方法看成变量）；
class A extends num{
    public A() {}
}
class B extends num{
    public B() {}
}
class C extends num{
    public C() {}
}
class D extends num{
    public D() {}
}
class E extends num{
    public E() {}
}
class F extends num{
    public F() {}
}