Java基础异常-自定义异常

java中怎么自定义异常呢？

两步：

• 第一步：编写一个类继承Exception或者RuntimeException
• 第二步：提供两个构造方法，一个无参数的，一个带有String参数的。

示例代码01：

public class MyException extends Exception{
    public MyException(){

    }
    public MyException(String s){
        super(s);
    }
}

示例代码02

public class ExceptionTest15 {
    public static void main(String[] args) {

        //创建异常对象（这里只是new了，并没有抛出异常！）
        MyException e = new MyException("用户名不能为空！");
        //打印异常堆栈信息
        e.printStackTrace();

        //打印异常简单信息
        String m = e.getMessage();
        System.out.println(m);
    }
}

运行结果：

模拟栈代码异常：

Mystack.java

public class MyStack {

        // 向栈当中存储元素，我们这里使用一维数组模拟。存到栈中，就表示存储到数组中。
        // 因为数组是我们学习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;

        /**
         * 无参数构造方法。默认初始化栈容量10.
         */
        public MyStack() {
            // 一维数组动态初始化
            // 默认初始化容量是10.
            this.elements = new Object[10];
            // 给index初始化
            this.index = -1;
        }

        /**
         * 压栈的方法
         * @param obj 被压入的元素
         */
        public void push(Object obj) throws MyStackOperationException {
            if(index >= elements.length - 1){
                // 改良之前
                //System.out.println("压栈失败，栈已满！");
                //return;

                // 创建异常对象
                //MyStackOperationException e = new MyStackOperationException("压栈失败，栈已满！");
                // 手动将异常抛出去！
                //throw e; //这里捕捉没有意义，自己new一个异常，自己捉，没有意义。栈已满这个信息你需要传递出去。

                //合并（手动抛出异常）
                throw new MyStackOperationException("栈已满，压栈失败！");
            }
            // 程序能够走到这里，说明栈没满
            // 向栈中加1个元素，栈帧向上移动一个位置。
            index++;
            elements[index] = obj;
            // 在声明一次：所有的System.out.println()方法执行时，如果输出引用的话，自动调用引用的toString()方法。
            System.out.println("压栈" + obj + "元素成功，栈帧指向" + index);
        }

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

        // set和get也许用不上，但是你必须写上，这是规矩。你使用IDEA生成就行了。
        // 封装：第一步：属性私有化，第二步：对外提供set和get方法。
        public Object[] getElements() {
            return elements;
        }

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

        public int getIndex() {
            return index;
        }

        public void setIndex(int index) {
            this.index = index;
        }
    }

MyStackOperationException.java

/**
 * 栈操作异常：自定义异常！
 */
public class MyStackOperationException extends Exception{//编译时异常

    public MyStackOperationException(){

    }

    public MyStackOperationException(String s){
        super(s);
    }
}

ExceptionTest16.java

public class ExceptionTest16 {
    public static void main(String[] args) {

        //创建栈对象
        MyStack Stack = new MyStack();
        try {
            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());
        } catch (MyStackOperationException e) {
            //打印异常简单信息
            System.out.println(e.getMessage());
        }

        try {
            Stack.pop();
            Stack.pop();
            Stack.pop();
            Stack.pop();
            Stack.pop();
            Stack.pop();
            Stack.pop();
            Stack.pop();
            Stack.pop();
            Stack.pop();
            //栈已空，弹栈失败！
            Stack.pop();
        } catch (MyStackOperationException e) {
            //打印异常简单信息
            System.out.println(e.getMessage());
        }
    }
}

运行结果：