数组模拟栈内存_异常处理1

package mycodes.exception.test2;
/*
 * 这个类是用数组模拟栈内存（方式1：控制下标），通过异常处理提示用户栈满栈空
 */
public class Stack1 {
    private String[] arr;
    private int p = 0;

    public Stack1(int len) {
        arr = new String[len];
    }

    // 压栈
    public void push(String str) throws StackException {
        // 不要在这里写循环
        if (p < arr.length)
            arr[p++] = str;
        else {
            throw new StackException("栈已满，无法继续压栈");
        }
    }

    // 弹栈
    public String pop() throws StackException {
        // 不要在这里写循环
        if (p > 0) {
            String str = arr[--p];
            arr[p] = null;
            return str;
        } else
            throw new StackException("栈空，无法弹栈");
    }
}

package mycodes.exception.test2;

public class StackException extends Exception {

    public StackException(){}
    public StackException(String msg){
        super(msg);
    }
    public StackException(String msg,Throwable e){
        super(msg,e);
    }
}

package mycodes.exception.test2;
/*
 * 本类用于测试 通过数组模拟栈内存的类 Stack1
 */
public class TestStack12 {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //Stack s = new Stack(10);
        Stack1 s = new Stack1(10);
        //压栈
        try {
            for(int i = 1;i<9;i++){
                s.push("abc"+i);
            }
        } catch (StackException e) {
            e.printStackTrace();
        }
        // 弹栈
        try {
            for(int i = 0;i<14;i++){
                String str =s.pop();
                System.out.println("弹栈-->" +str );
            }
        } catch (StackException e) {
            e.printStackTrace();
        }    
    }
}