Java基础异常-自定义异常

拼搏现实的明天。 2023-10-08 16:46 9阅读 0赞

## 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);
        }
    }

#### 运行结果： ####

![在这里插入图片描述][0d535a25c42c4e96aa7796eaad59296a.png]

### 模拟栈代码异常： ###

#### 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());
            }
        }
    }

#### 运行结果： ####

![在这里插入图片描述][dfc1a15c2b7343d4bb2a67fea6604f3d.png]

[0d535a25c42c4e96aa7796eaad59296a.png]: https://img-blog.csdnimg.cn/0d535a25c42c4e96aa7796eaad59296a.png
[dfc1a15c2b7343d4bb2a67fea6604f3d.png]: https://img-blog.csdnimg.cn/dfc1a15c2b7343d4bb2a67fea6604f3d.png