异常详解.

我会带着你远行 2023-09-30 10:10 6阅读 0赞

> 一、异常概述
> 
> 二、java中异常以类和对象形式存在
> 
> 三、异常的两种处理方式
> 
> 四、方法声明位置上使用throws 【编译时的异常】
> 
> 五、异常捕捉和throws【摆烂】联合使用 （重点了解）
> 
> 六、哪里的代码执行,哪里的代码不执行【重点了解】
> 
> 七、try catch深入理解【重点了解】 \{有异常 catch就行\}
> 
> 八、异常对象的常用方法
> 
> 九、finally子句的使用【重点~】
> 
> 十、java中如何自定义异常

## 一、异常概述 ##

> 1、 什么是异常： 程序执行过程中的不正常情况  
> 异常的作用： 增强程序的健壮性  
> 2、JVM虚拟机可以打印出我们下面代码的异常,然后供我们修改错误 增强代码的健壮性  
> Exception in thread "main" java.lang.ArithmeticException: / by zero  
> at com.bjpowernode.javase.exception.ExceptionTest01.main(ExceptionTest01.java:12)

**代码演示如下：**

package com.bjpowernode.javase.exception;
    // 异常程序
     /*
    public class ExceptionTest01 {
        public static void main(String[] args) {
            int a=10;
            int b =0;
            int c =a/b;
            System.out.println(c);
        }
    }
     */
    
    // 修改后的程序(随手修改)
    public class ExceptionTest01 {
        public static void main(String[] args) {
            int a =10;
            int b =1;
            if (b==0){
                return;
            }
            int c =10/b;
            System.out.println(a+"/"+b+"="+c); // 10/1=10
    
        }
    }

## 二、java中异常以类和对象形式存在 ##

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16][]

**从上述文档当中可知异常也是一种类,里面也有构造方法**

**我们测试以下当我们实例化异常对象的时候会得到什么样的结果： 代码演示如下：**

package com.bjpowernode.javase.exception;
    
    public class ExceptionTest02 {
        public static void main(String[] args) {
            // 通过”异常类“实例化”异常对象“
            NumberFormatException numberFormatException =new NumberFormatException("数字格式化异常");
            System.out.println(numberFormatException);
            // 输出结果： java.lang.NumberFormatException: 数字格式化异常
    
            NullPointerException nullPointerException =new NullPointerException("空指针异常开始了");
            System.out.println(nullPointerException);
            // 输出结果： java.lang.NullPointerException: 空指针异常开始了
        }
    
    }

**通过上述的代码演练我们可以得出结论如下代码演示：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

## 三、异常的两种处理方式 ##

> 第一种方式:  
> 在方法声明的位置上，使用throws关键字，抛给上一级。  
> 谁调用我，我就抛给谁。抛给上一级。  
> 第二种方式:  
> 使用try. ....catch语句进行异常的捕捉。  
> 这件事发生了，谁也不知道，因为我给抓住了。
> 
> 举个例子:  
> 我是某集团的一个销售员，因为我的失误，导致公司损失了1000元，  
> "损失1000元"这可以看做是一个异常发生了。我有两种处理方式,  
> 第一种方式:我把这件事合诉我的领导\[异常上抛\]  
> 第二种方式:我自己掏腰包把这个钱补上。\[异常的捕捉\]
> 
> jun-->junker---> junk-----> CEO  
> 思考:  
> 异常发生之后，如果我选择了上抛，抛给了我的调用者，调用者需要  
> 对这个异常继续处理，那么调用者处理这个异常同样有两种处理方式\[抛给上一级、捕捉\]。  
>

package com.bjpowernode.javase.exception;
    // 异常程序
    
    public class ExceptionTest01 {
        public static void main(String[] args) {
            /*
            程序执行到此处发生了ArithmeticException异常,
            底层new了一个ArithmeticException对象,然后抛出了,
            由于是main方法调用了10/0,所以这个异常ArithmeticException抛给了
            main方法,main方法没有处理,将这个异常自动抛给了JVM
            JVM最终终止程序的执行
             */
            System.out.println(10/0);    // 10/0 这是算术异常,这个异常是运行时异常,你在编译阶段,
    // 可以处理 也可以不处理,编译器不管
    
            // 这里的hello world没有输出,没有执行  原因如上述
            System.out.println("hello world");
        }
    }

## 四、方法声明位置上使用throws 【编译时的异常】 ##

package com.bjpowernode.javase.exception;
    
    /*
    以下代码报错的原因是什么？
        因为doSome()方法声明的位置上使用了：throws ClassNotFoundException
        而 ClassNotFoundException是编译时异常,必须编写代码时处理,没有处理 编译器会报错
     */
    public class ExceptionTest03 {
        public static void main(String[] args) {
            // main方法中调用doSome()方法
            // 因为doSome()方法声明位置上有：throws ClassNotFoundException
            // 我们调用doSome()方法的时候必须对这种异常进行预先的处理
            // 如果不处理,编译器就会报错
            // 编译器报错信息：未报告的异常错误java.lang.ClassNotFoundException; 必须对其进行捕获或声明以便抛出
            // doSome();
        }
    
        /*
        doSome方法在方法声明的位置上使用了：throws ClassNotFoundException
        这个代码表示：doSome()方法在执行的过程中,有可能出现ClassNotFoundException异常,
        叫做类没找到异常    这个异常的直接父类是：Exception,所以ClassNotFoundException属于编译时异常
         */
        public static void doSome() throws ClassNotFoundException{
            System.out.println("dosome.....");
        }
    }

**对上述的异常进行处理操作代码如下所示：**

package com.bjpowernode.javase.exception;
    
    public class ExceptionTest04 {
    
        // 第一种处理方式：
        // 在方法声明的位置上继续使用：throws 来完成异常的继续上抛,跑给调用者
        // 上抛类似于推卸责任（继续把异常传递给调用者）
        /*
        public static void main(String[] args) throws ClassNotFoundException {
    
            doSome();   // 此处main()方法把异常继续throws给了JVM 但JVM并没有终止程序的运行 依然能输出dosome....
            // 这是因为doSome()方法当中并没有语法等上的错误
            // 假设doSome()方法当中是 System.out.println(10/0); 那么JVM就会终止程序的运行抛出异常
        }
         */
    
        // 第二种处理方式：
        // try.....catch进行捕捉
        public static void main(String[] args){
            try {
                doSome();   // ALT + 回车键 一键捕捉异常
    
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
        }
    
        public static void doSome() throws ClassNotFoundException{
            System.out.println("dosome....");
        }
    }

## 五、异常捕捉和throws【摆烂】联合使用 （重点了解） ##

**代码演示如下所示：**

package com.bjpowernode.javase.exception;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    public class ExceptionTest05 {
        public static void main(String[] args) {
            // 一般情况下不建议在main方法上使用throws【摆烂方法哈哈哈】,因为这个异常真正的发生了,一定会抛给JVM,JVM只有终止
            // 异常处理机制的作用就是增强程序的健壮性,怎么能做到,异常发生了也不影响程序的执行,所以一般在main方法中使用try.....catch方式,不用摆烂
            try {
                m1();   // ALT+回车键 一键生成
            } catch (FileNotFoundException e) {
                // catch是捕捉异常之后走的分支
                System.out.println("文件不存在,可能路径有点错误~");
    
            }
        }
    
        public static void m1() throws FileNotFoundException {
            // 同下：【继续摆烂】
            m2();
        }
    
        public static void m2() throws FileNotFoundException {
            // 编译器报错原因：未报告的异常错误java.io.FileNotFoundException; 必须对其进行捕获或声明以便抛出
            // 我们在这里调用m3()方法的时候没有对异常进行处理 因此需要处理异常   【继续摆烂】
            m3();
        }
        public static void m3() throws FileNotFoundException {
            // 调用SUN jdk中某个类的构造方法
            // 这个类没有接触过,后期IO流的时候就知道了
            // 我们只是借助这个类学习一下异常处理机制
            // 创建一个输入流对象 该流指向一个文件
            /*
            编译报错的原因：
                第一：这里调用了FileInputStream类当中的一个构造方法：public FileInputStream(String name)
                第二：这个构造方法的声明位置上有： throws FileNotFoundException [通过源码查看]
                第三：通过类的继承结构看到：FileNotFoundException父类是IOException,IOException的父类是Exception
                最终我们可以得知：FileNotFoundException是编译时异常 因此我们需要在编译阶段就行异常处理
            处理方式：
                第一种在方法声明的位置上使用throws继续上抛    【摆烂】
                第二种使用try.....catch
             */
          new FileInputStream("D:\\java course\\day01\\HelloWorld.java");
    
        }
    }

#### **补充： 加强理解编译阶段异常和运行阶段异常 \[编译阶段异常需要在编译的时候进行异常的处理,运行阶段的异常可处理也可以不处理\]** ####

package com.bjpowernode.javase.exception;
    
    public class ExceptionTest01 {
        public static void main(String[] args) {
            // 100/0这是算术异常,这个异常是运行时异常,你在编译阶段,可以处理,也可以不处理 编译器不管
            // System.out.println(100/0);
    
            // 你处理也可以
            try {
                System.out.println(100 / 0);
            } catch (ArithmeticException e){
                System.out.println("这是个算术异常 是运行阶段的异常~");
                // 这是个算术异常 是运行阶段的异常~
            }
        }
    }

## 六、哪里的代码执行,哪里的代码不执行【重点了解】 ##

**代码演示如下：**

package com.bjpowernode.javase.exception;
    
    // 当new对象里面的路径正确的时候就会输出"以上出现异常的话,....."
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    public class ExceptionTest06 {
        public static void main(String[] args) {
            try {
                FileInputStream fis =new FileInputStream("D:\\java course\\day01\\HelloWorld.java");    // 路径正确
                System.out.println("以上出现异常的话,这里无法被运行"); // 比如对象里面路径正确的时候就会执行这里的代码、不执行"文件不存在"的代码
            }
            catch (FileNotFoundException e){    // 捕捉路径是否异常没异常输出上面的 异常输出下面的
                System.out.println("文件不存在");    // 对象里面的路径地址要是不正确的话 就会输出此处的代码 不输出try里面的代码
            }
            System.out.println("hello world");  // 这个代码在外面异不异常都会输出
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

## 七、try catch深入理解【重点了解】 \{有异常 catch就行\} ##

> 深入try.....catch  
> 1、catch后面的小括号中的类型可以是具体的异常类型,也可以是该异常类型的父类型  
> 如：FileNotFoundException e 可以写成 Exception e
> 
> 2、catch可以写多个,建议catch的时候,精确的一个一个处理,这样有利于程序的调试
> 
> 3、catch写多个的时候,从上到下,必须遵守从小到大(父类 Exception最大)

**代码演示如下：**

package com.bjpowernode.javase.exception;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    /*
    深入try.....catch
        1、catch后面的小括号中的类型可以是具体的异常类型,也可以是该异常类型的父类型
            如：FileNotFoundException e 可以写成 Exception e
    
        2、catch可以写多个,建议catch的时候,精确的一个一个处理,这样有利于程序的调试
    
        3、catch写多个的时候,从上到下,必须遵守从小到大(父类 Exception最大)
     */
    
    public class ExceptionTest07 {
    
        public static void main(String[] args) {
                try {   // 尝试着判断异常是否发生 没发生异常就不进入catch分支当中
                    //  创建输入流
                    FileInputStream fis =new FileInputStream("D:\\java course\\day01\\HelloWorld.java");
                    // 读文件
                    fis.read(); // read()的方法也抛出了一个IOException异常 需要进行编译时处理
                }
    
                    catch (FileNotFoundException e){    // 捕捉异常进行处理
                        System.out.println("文件不存在");
                }
                catch (IOException a){  // 对read()抛出的异常进行精确处理
    
                }
                System.out.println("hello world");
            }
        }
    
        // 3、catch写多个的时候,从上到下,必须遵守从小到大(父类 Exception最大)
    
    /*public class ExceptionTest07 {
    
        public static void main(String[] args) {
            try {   // 尝试着判断异常是否发生 没发生异常就不进入catch分支当中
                //  创建输入流
                FileInputStream fis =new FileInputStream("D:\\java course\\day01\\HelloWorld.java");
                // 读文件
                fis.read(); // read()的方法也抛出了一个IOException异常 需要进行编译时处理
            }
    
            catch (IOException a){  // IOException 比 FileNotFoundException大 当最大的在上时 能把上面的异常全部处理干净 下面就不用再catch
    
            }
            catch (FileNotFoundException e){    // 可以不写了 上面已经捕捉过异常了
                System.out.println("文件不存在");
            }
            System.out.println("hello world");
        }
    }*/

## 八、异常对象的常用方法 ##

**代码演示如下：**

package com.bjpowernode.javase.exception;
    
    /*
    异常对象有两个非常重要的方法：
        获取异常简单的描述信息：
        String msg =exception.getMessage();
    
        打印异常追踪的堆栈信息：
        exception.printStackTrace();
     */
    public class ExceptionTest08 {
        public static void main(String[] args) {
    
            NullPointerException msg =new NullPointerException("空指针异常awfawgtaw");
            // 获取异常简单的描述信息
            String s =msg.getMessage();
            System.out.println(s);
            // 打印异常追踪的堆栈信息
            msg.printStackTrace();
        }
    
    }

**运行结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

## 应用： 【重点了解】 ##

**代码演示如下：(当路径不正确的时候抛出异常)**

package com.bjpowernode.javase.exception;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    public class ExceptionTest09 {
        public static void main(String[] args) {
            try {
                m1();
                System.out.println("没有出现异常的情况,下面catch分支中代码不再执行");   // 看new对象里面的路径是否正确 不正确FileInputStream类中的构造方法就会抛出异常就走catch分支捕捉异常
            } catch (FileNotFoundException e) { // 当捕捉到异常时：
                //  打印异常追踪的堆栈信息：
                e.printStackTrace();
            }
            
            // 这里的程序不耽误执行,保证了程序代码的健壮性,《服务器不会因为遇到异常而关机》
            System.out.println("hello world");
        }
    
        private static void m1() throws FileNotFoundException {
            m2();
        }
    
        private static void m2() throws FileNotFoundException {
            m3();
        }
    
        private static void m3() throws FileNotFoundException {
            new FileInputStream("D:\\java course\\day01\\Test01.javaewty"); // 假设路径不正确  不正确FileInputStream()构造方法就会把异常抛出来
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

## 九、finally子句的使用【重点~】 ##

> finally语句通常使用在哪些情况下呢?  
> 通常在finally语句块中完成资源的释放/关闭。  
> 因为finally中的代码比较有保障。  
> 即使try语句块中的代码出现异常, finally中代码也会正常执行。

#### 分析以下代码有什么问题： ####

package com.bjpowernode.javase.exception;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    
    public class ExceptionTest10 {
        public static void main(String[] args) {
    
            try {       // 尝试判断是否有异常 有的话进入catch分支,没有的话在该分支当中继续跑代码程序~
                // 创建输入流对象
                FileInputStream msg =new FileInputStream("D:\\java course\\day01\\Test01.java");  // 对抛出的异常进行处理
                // 如果没有发现异常 这个try分支当中就可以跑起来一系列程序了,例如：读文件等.....
    
                String s =null;
                s.toString();   // 假如在跑程序的时候出现了其他的异常 如空指针异常(运行时异常 可以catch处理也可以不处理)
    
    
                // 流使用完之后需要关闭,因为流是占用空间资源的
    
                msg.close();    // 那么这里就不会进行关闭流处理,因为当String s出现异常的时候会终止下面的代码 进入catch分支捕捉异常(这个close()也要进行异常处理)
    
            } catch (FileNotFoundException e) {     // 捕捉异常的 没有异常的话就不执行该分支了
                // 打印异常追踪信息
                e.printStackTrace();
            }
        }
    }

#### 思考：那么我们流使用完之后该怎么关闭最安全呢？【重重重重重点了解】 ####

**代码演示如下：**

package com.bjpowernode.javase.exception;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    
    public class ExceptionTest10 {
        public static void main(String[] args) {
            FileInputStream msg =null;  // 这里要写一个成员变量,这样在finally分支中才能使用
    
            try {
                // 创建输入流对象 【第一步】
                msg=new FileInputStream("D:\\java course\\day01\\Test01.java");    //msg相当于成员变量 因为成员变量在各方法体中都能使用
                // 跑程序.....
                String s =null; // 跑程序当中出现了空指针异常
                s.toString();
    
                System.out.println("hello world"); // 此处会因为上面发生了空指针异常而终止hello world程序的运行
    
             // 注意：catch分支捕捉到异常之后代码继续往下执行 增强了代码的健壮性
            } catch (FileNotFoundException e) {
                // 打印异常追踪信息
                e.printStackTrace();
            } catch (NullPointerException e){   // 对运行时异常也可以捕捉异常
                System.out.println("捕捉到了空指针异常~");
                // 打印异常追踪信息
                e.printStackTrace();
            } finally {
                System.out.println("测试流关闭代码是否执行[是]：原来finally中的代码真的一定执行呦~");
                // 流的关闭放到这里比较保险
                // finally中的代码是一定会执行的
    
                // 流关闭之前需要判断一个msg这个引用是否为null
                // 因为msg=new FileInputStream("D:\\java course\\day01\\Test01.java"); 有可能msg =null; 然后再调用close()方法的话会出现空指针异常
                // 那么就无法执行下面的代码了 无法关闭流了 所以我们需要先判断一下
                if (msg!=null){
                try {
                    msg.close();    // 这里：public void close() throws IOException  close()方法也抛出了一个编译时异常 所以需要我们处理
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            }
        }
    }

**运行结果如下：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 5][]

## 补充：try和finally可以联合使用 ##

**代码演示如下：**

package com.bjpowernode.javase.exception;
    
    public class ExceptionTest11 {
        public static void main(String[] args) {
            /*
            try 和 finally,没有catch可以吗？ 可以
                try 不能单独使用
                try finally可以联合使用
    
            以下代码的执行顺序：
                先执行try.....
                再执行finally.....
                最后执行return(return语句只要执行 方法必然结束)
             */
            try {
                System.out.println("try....");
                return;
            }
            finally {
                System.out.println("finally....");  // 有return返回 finally当中的代码也能正常执行
            }
            // System.out.println("hello world"); // return语句只要执行 方法必然结束（main方法体结束）
        }
    }

**输出结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 6][]

#### 思考：那么谁能拿捏finally呢？ 如下所示： ####

package com.bjpowernode.javase.exception;
    
    public class ExceptionTest11 {
        public static void main(String[] args) {
            
            try {
                System.out.println("try....");  // 输出结果：try....
    
                // 退出JVM 只有这个方法能够治住finally
                System.exit(0);
            }
            finally {
                System.out.println("finally....");  
     }      
        }
    }

## 十、java中如何自定义异常 ##

> 1、SUN提供的JDK内置的异常肯定是不够的用的。在实际的开发中，有很多业务,  
> 这些业务出现异常之后, JDK中都是没有的。和业务挂钩的。那么异常类我们程序员可以自己定义吗?  
> 可以
> 
> 2、java中怎么自定义异常呢？  
> 两步：【死记硬背即可】  
> 第一步：编写一个类继承Exception或者RuntimeException (编译时异常、运行时异常)  
> 第二步：提供两个构造方法,一个无参数的,一个带有String参数的

**手动定义一个异常：**

package com.bjpowernode.javase.exception;
    
    // 手动定义一个异常
    public class ExceptionTest12 extends Exception {
        public ExceptionTest12(){
    
        }
        public ExceptionTest12(String s){
            super(s);
        }
    }

**调用异常类：**

package com.bjpowernode.javase.exception;
    
    public class ExceptionTest13 {
        public static void main(String[] args) {
            // 创建异常对象(只new了异常对象,并没有手动抛出)
            ExceptionTest12 s =new ExceptionTest12("用户名不能为空");
            // 打印异常堆栈信息
            s.printStackTrace();
    
            // 获取异常简单描述信息
            String msg =s.getMessage();
            System.out.println(msg);
        }
    }

**输出结果如下所示：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 7][]

## 异常在实际开发中的作用【重点】 ##

**手动定义一个异常类：**

**调用异常类：**

package com.bjpowernode.javase.exception;
    
    public class Stack {
        // 模仿压栈弹栈
            // 向栈中储存元素
            // Object类型数组,因为都继承Object 所以可以储存任意类型的数据
            private Object[] elements;  // 默认为null
    
            // 栈帧：永远指向栈顶元素
            // 为0的时候：表示栈帧指向了数组里面的第一个元素顶部
            // 为-1时候：表示数组里面是空的
            // 注意：最初的栈是空的,一个元素也没有
            private int index;
    
            // 无参构造
            public Stack() {
                // 假设这个数组当中可以储存10个元素
                // 给elements初始化
                this.elements=new Object [10];
                // 给index初始化
                this.index =-1;
            }
    
            // 定义一个压栈的方法 压栈肯定是有一个参数传进来压
            public void push(Object obj) throws ExceptionTest12{
                // 先判断栈是否满了
                if (this.index>=this.elements.length-1){
                    // System.out.println("栈已满,压栈失败~");
                    // return;
    
                    // 栈满的时候抛给用户一个异常(和上面两行代码一样 只不过更加高端)
                    // 创建异常对象
                    ExceptionTest12 msg =new ExceptionTest12("栈已满,压栈失败~");
                    // 手动将异常抛出去
                    throw msg;  // 把new ExceptionTest12();这个异常类抛出去,因为ExceptionTest12这个类的父类是Exception 是编译时异常,
                                // 需要我们在编写代码的时候捕捉异常或者【摆烂】throws异常 在这里我们希望把异常信息抛给调用者,所以不用try.....catch
                }
                // 程序能执行到这里 说明栈没有满
                index++;    // 栈帧依次往上加
                elements[index] =obj; // 将调用的obj对象添加到数组当中 [栈帧也可以看成下标] 栈帧每加1 就添加一个对象到数组当中
                System.out.println("元素："+obj+"压栈成功,栈帧为："+index);
            }
    
            // 定义一个弹栈方法
            public void pop(){
                // 先判断栈是否为空
                if (index<0){   // 栈帧小于0 说明数组里面没有元素
                    System.out.println("栈为空,弹栈失败");
                    return;
                }
                // 程序能执行到这里说明栈没有空
                System.out.print("弹栈"+elements[index]+"元素成功");  // 由上面压栈可知这时的栈帧为9 elements[index]是下标为9的元素
                index--;
                System.out.println("栈帧为："+index); // 弹栈成功后栈帧就要减1 所以先-- 再输出栈帧
            }
    
    
            // 虽然有可能用不到关卡,但以后写代码的时候也要写
    
            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;
            }
        }

**代码测试：**

package com.bjpowernode.javase.exception;
    
    // 程序测试
    public class TestStack {
        public static void main(String[] args) {
            Stack stack =new Stack();
    
            // 调用压栈方法
            for (int i=0;i<11;i++){
                try {
                    stack.push(new Object());   // 因为push方法声明位置上有： throws ExceptionTest12 抛出的异常【父类Exception编译时异常】
                } catch (ExceptionTest12 e) {   // 所以我们调用push()方法的时候必须对这种异常进行预先的处理
                    // 打印异常追踪的堆栈信息(方便我们知道异常(错误)在哪)
                    e.printStackTrace();
    
                    // 打印异常简单的描述信息
                    String s =e.getMessage();
                    System.out.println(s);
                }
            }
        }
    }

**运行结果：**

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 8][]

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/1bd587cd03434e5481d964f70c8e838e.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 1]: https://img-blog.csdnimg.cn/42037cba28994932ae0a482b97633f6c.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 2]: https://img-blog.csdnimg.cn/eac43c631a754946acf14b99d896b58a.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 3]: https://img-blog.csdnimg.cn/6181e0688ff0495482f0142d96398e1d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 4]: https://img-blog.csdnimg.cn/84b56f0362434878a7a836ec5b0d2b8c.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 5]: https://img-blog.csdnimg.cn/c23dceba7bf348d9b03a810db86c95d4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 6]: https://img-blog.csdnimg.cn/cc89bc2d6ee24cb9932bf45dbc4b1035.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 7]: https://img-blog.csdnimg.cn/e89d4e9273ce4a51a7614325e806947a.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAbHdqXzA3_size_20_color_FFFFFF_t_70_g_se_x_16 8]: https://img-blog.csdnimg.cn/13c37f23f8334f21a5eee03ac9c6e388.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAbHdqXzA3,size_20,color_FFFFFF,t_70,g_se,x_16