异常

印度阿三17 2019-09-08

展开全文

第一章　　异常

1、Throwable类是java语言中的所有错误和异常的基类。

已知直接子类：

Error， Exception

2、

　　java.lang.Throwable:类是 Java 语言中所有错误或异常的超类。
　　　　Exception:编译期异常,进行编译(写代码)java程序出现的问题
　　　　　　RuntimeException:运行期异常,java程序运行过程中出现的问题
　　　　　　异常就相当于程序得了一个小毛病(感冒,发烧),把异常处理掉,程序可以继续执行(吃点药,继续革命工作)
　　　　Error:错误
　　　　　　错误就相当于程序得了一个无法治愈的毛病.必须修改源代码,程序才能继续执行

代码示例：

 1 public class Demo01Exception {
 2     public static void main(String[] args) /*throws ParseException*/ {
 3         //Exception:编译期异常,进行编译(写代码)java程序出现的问题
 4         /*SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//用来格式化日期
 5         Date date = null;
 6         try {
 7             date = sdf.parse("1999-0909");//把字符串格式的日期,解析为Date格式的日期
 8         } catch (ParseException e) {
 9             e.printStackTrace();
10         }
11         System.out.println(date);*/
12 
13         //RuntimeException:运行期异常,java程序运行过程中出现的问题
14         /*int[] arr = {1,2,3};
15         //System.out.println(arr[0]);
16         try {
17             //可能会出现异常的代码
18             System.out.println(arr[3]);
19         }catch(Exception e){
20             //异常的处理逻辑
21             System.out.println(e);
22         }*/
23 
24         /*
25             Error:错误
26             OutOfMemoryError: Java heap space
27             内存溢出的错误,创建的数组太大了,超出了给JVM分配的内存
28          */
29         //int[] arr = new int[1024*1024*1024];
30         //必须修改代码,创建的数组小一点
31         int[] arr = new int[1024*1024];
32         System.out.println("后续代码");
33     }

3、异常的产生过程解析

第二章　　异常的处理

　　Java异常处理的五个关键字：try、catch、finally、throw、throws

2.1 throw关键字

　　作用:
　　　　可以使用throw关键字在指定的方法中抛出指定的异常
　　使用格式:
　　　　throw new xxxException("异常产生的原因");
　　注意:
　　　　1.throw关键字必须写在方法的内部
　　　　2.throw关键字后边new的对象必须是Exception或者Exception的子类对象
　　　　3.throw关键字抛出指定的异常对象,我们就必须处理这个异常对象
　　　　　　　　throw关键字后边创建的是RuntimeException或者是 RuntimeException的子类对象,我们可以不处理,默认交给JVM处理(打印异常对象,中断程序)
　　　　　　　　throw关键字后边创建的是编译异常(写代码的时候报错),我们就必须处理这个异常,要么throws,要么try...catch

代码示例：

 1 public class Demo03Throw {
 2     public static void main(String[] args) {
 3         //int[] arr = null;
 4         int[] arr = new int[3];
 5         int e = getElement(arr,3);
 6         System.out.println(e);
 7     }
 8     /*
 9         定义一个方法,获取数组指定索引处的元素
10         参数:
11             int[] arr
12             int index
13         以后(工作中)我们首先必须对方法传递过来的参数进行合法性校验
14         如果参数不合法,那么我们就必须使用抛出异常的方式,告知方法的调用者,传递的参数有问题
15         注意:
16             NullPointerException是一个运行期异常,我们不用处理,默认交给JVM处理
17             ArrayIndexOutOfBoundsException是一个运行期异常,我们不用处理,默认交给JVM处理
18      */
19     public static int getElement(int[] arr,int index){
20         /*
21             我们可以对传递过来的参数数组,进行合法性校验
22             如果数组arr的值是null
23             那么我们就抛出空指针异常,告知方法的调用者"传递的数组的值是null"
24          */
25         if(arr == null){
26             throw new NullPointerException("传递的数组的值是null");
27         }
28 
29         /*
30             我们可以对传递过来的参数index进行合法性校验
31             如果index的范围不在数组的索引范围内
32             那么我们就抛出数组索引越界异常,告知方法的调用者"传递的索引超出了数组的使用范围"
33          */
34         if(index<0 || index>arr.length-1){
35             throw new ArrayIndexOutOfBoundsException("传递的索引超出了数组的使用范围");
36         }
37 
38         int ele = arr[index];
39         return ele;
40     }
41 }

2.2 Objects非空判断

　　还记得我们学习过一个类Objects吗，曾经提到过它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），那么在它的源码中，对对象为null的值进行了抛出异常操作。

　　Obects类中的静态方法
　　public static <T> T requireNonNull(T obj):查看指定引用对象不是null。
　　源码:

public static <T> T requireNonNull(T obj) {
    if (obj == null)
        throw new NullPointerException();
    return obj;
}

代码示例：

 1 public class Demo04Objects {
 2     public static void main(String[] args) {
 3         method(null);
 4     }
 5 
 6     public static void method(Object obj){
 7         //对传递过来的参数进行合法性判断,判断是否为null
 8         /*if(obj == null){
 9             throw new NullPointerException("传递的对象的值是null");
10         }*/
11 
12         //Objects.requireNonNull(obj);
13         Objects.requireNonNull(obj,"传递的对象的值是null");
14     }
15 }

2.3 声明异常throws

　　声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。
　　关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

　　声明异常格式：

修饰符 返回值类型 方法名(参数) throws 异常类名1,异常类名2…{ }

　　throws关键字：处理异常的第一种方式，交给别人处理

　　作用：

　　　　当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象

　　　　可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理（自己不处理，给别人处理），最终交给JVM处理 --> 中断处理

　　使用格式：在方法声明时使用

　　　　修饰符返回值类型方法名（参数列表） throws AAAException,BBBException...{

　　　　　　　　throws new AAAException("产生原因");

　　　　　　　　throws new BBBException("产生原因");

　　　　}

　　注意：

　　　　1、throws关键字必须写在方法声明处

　　　　2、throws关键字后边声明的异常必须是Exception或是Exception的子类

　　　　3、方法内部如果抛出了多个异常对象，那么throws后边也必须声明多个异常

　　　　4、调用了一个声明抛出异常的方法，我们就必须处理声明的异常

　　　　　　　　要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM

　　　　　　　　要么try...catch自己处理异常

代码示例：

 1 public class Demo05Throws {
 2 
 3     /*
 4         FileNotFoundException extends IOException extends Exception
 5         如果抛出的多个异常对象有子父类关系，那么直接声明父类即可
 6      */
 7     //public static void main(String[] args) throws FileNotFoundException,IOException {
 8     //public static void main(String[] args) throws IOException {
 9     public static void main(String[] args) throws Exception {
10         //readFile("c:\\a.txt");
11         //readFile("d:\\a.txt");
12         readFile("d:\\a.tx");
13     }
14 
15     /*
16         定义一个方法，对传递的文件路径进行合法性判断
17         如果路径不是"c:\\a.txt"，那么我们就抛出文件找不到异常对象，告知方法的调用者
18         注意：
19 
20      */
21 
22     public static void readFile(String fileName) throws FileNotFoundException,IOException {
23         if (!fileName.equals("c:\\a.txt")){
24             throw new FileNotFoundException("传递的路径不是c:\\a.txt");
25         }
26 
27         /*
28             如果传递的路径，不是.txt结尾
29             那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
30          */
31 
32         if (!fileName.endsWith(".txt")){
33             throw new IOException("文件的后缀名不对");
34         }
35         System.out.printf("路径没有问题，读取文件");
36     }
37 }

2.4 捕获异常try…catch

　　如果异常出现的话,会立刻终止程序,所以我们得处理异常:
　　　　1. 该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
　　　　2. 在方法中使用try-catch的语句块来处理异常。
　　try-catch的方式就是捕获异常。

捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

　　try...catch:异常处理的第二种方式,自己处理异常
　　格式:
　　　　try{
　　　　　　可能产生异常的代码
　　　　}catch(定义一个异常的变量,用来接收try中抛出的异常对象){
　　　　　　异常的处理逻辑,异常异常对象之后,怎么处理异常对象
　　　　　　一般在工作中,会把异常的信息记录到一个日志中
　　　　}
　　　　...
　　　　catch(异常类名变量名){

　　　　}
　　注意:
　　　　1.try中可能会抛出多个异常对象,那么就可以使用多个catch来处理这些异常对象
　　　　2.如果try中产生了异常,那么就会执行catch中的异常处理逻辑,执行完毕catch中的处理逻辑,继续执行try...catch之后的代码
　　　　如果try中没有产生异常,那么就不会执行catch中异常的处理逻辑,执行完try中的代码,继续执行try...catch之后的代码

　　Throwable类中定义了3个异常处理的方法
　　　　String getMessage() 返回此 throwable 的简短描述。
　　　　String toString() 返回此 throwable 的详细消息字符串。
　　　　void printStackTrace() JVM打印异常对象,默认此方法,打印的异常信息是最全面的

　　包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

代码示例：

 1 public class Demo01TryCatch {
 2     public static void main(String[] args) {
 3         try{
 4             //可能产生异常的代码
 5             readFile("d:\\a.tx");
 6             System.out.println("资源释放");
 7         }catch (IOException e){//try中抛出什么异常对象,catch就定义什么异常变量,用来接收这个异常对象
 8             //异常的处理逻辑,异常异常对象之后,怎么处理异常对象
 9             //System.out.println("catch - 传递的文件后缀不是.txt");
10 
11             /*
12                 Throwable类中定义了3个异常处理的方法
13                  String getMessage() 返回此 throwable 的简短描述。
14                  String toString() 返回此 throwable 的详细消息字符串。
15                  void printStackTrace()  JVM打印异常对象,默认此方法,打印的异常信息是最全面的
16              */
17             //System.out.println(e.getMessage());//文件的后缀名不对
18             //System.out.println(e.toString());//重写Object类的toString java.io.IOException: 文件的后缀名不对
19             //System.out.println(e);//java.io.IOException: 文件的后缀名不对
20 
21             /*
22                 java.io.IOException: 文件的后缀名不对
23                     at com.itheima.demo02.Exception.Demo01TryCatch.readFile(Demo01TryCatch.java:55)
24                     at com.itheima.demo02.Exception.Demo01TryCatch.main(Demo01TryCatch.java:27)
25              */
26             e.printStackTrace();
27         }
28         System.out.println("后续代码");
29     }
30 
31     /*
32        如果传递的路径,不是.txt结尾
33        那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
34 
35     */
36     public static void readFile(String fileName) throws IOException {
37 
38         if(!fileName.endsWith(".txt")){
39             throw new IOException("文件的后缀名不对");
40         }
41 
42         System.out.println("路径没有问题,读取文件");
43     }
44 }

2.4 finally 代码块

　　finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。
　　什么时候的代码必须最终执行？
　　　　当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。
　　finally的语法:
　　　　try...catch....finally:自身需要处理异常,最终还得关闭资源。

　　finally代码块
　　　　格式:
　　　　　　try{
　　　　　　　　可能产生异常的代码
　　　　　　}catch(定义一个异常的变量,用来接收try中抛出的异常对象){
　　　　　　　　异常的处理逻辑,异常异常对象之后,怎么处理异常对象
　　　　　　　　一般在工作中,会把异常的信息记录到一个日志中
　　　　　　}
　　　　　　...
　　　　　　catch(异常类名变量名){

　　　　　　}finally{
　　　　　　　　无论是否出现异常都会执行
　　　　　　}
　　注意:
　　　　1.finally不能单独使用,必须和try一起使用
　　　　2.finally一般用于资源释放(资源回收),无论程序是否出现异常,最后都要资源释放(IO)

　　　　3.当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。

代码示例：

 1 public class Demo02TryCatchFinally {
 2     public static void main(String[] args) {
 3         try {
 4             //可能会产生异常的代码
 5             readFile("c:\\a.tx");
 6         } catch (IOException e) {
 7             //异常的处理逻辑
 8             e.printStackTrace();
 9         } finally {
10             //无论是否出现异常,都会执行
11             System.out.println("资源释放");
12         }
13     }
14 
15     /*
16        如果传递的路径,不是.txt结尾
17        那么我们就抛出IO异常对象,告知方法的调用者,文件的后缀名不对
18 
19     */
20     public static void readFile(String fileName) throws IOException {
21 
22         if(!fileName.endsWith(".txt")){
23             throw new IOException("文件的后缀名不对");
24         }
25 
26         System.out.println("路径没有问题,读取文件");
27     }
28 }

2.5 异常注意事项

　　多个异常使用捕获又该如何处理呢？
　　　　1. 多个异常分别处理。
　　　　2. 多个异常一次捕获，多次处理。
　　　　3. 多个异常一次捕获一次处理。

　　一般我们是使用一次捕获多次处理方式，格式如下：

try{
    编写可能会出现异常的代码
}catch(异常类型A e){ 当try中出现A类型异常,就用该catch来捕获.
    处理异常的代码
    //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B e){ 当try中出现B类型异常,就用该catch来捕获.
    处理异常的代码
    //记录日志/打印异常信息/继续抛出异常
}

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果finally有return语句,永远返回finally中的结果,避免该情况。
如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出。

代码示例：

 1 public class Demo01Exception {
 2     public static void main(String[] args) {
 3         /*
 4             多个异常使用捕获又该如何处理呢？
 5             1. 多个异常分别处理。
 6             2. 多个异常一次捕获，多次处理。
 7             3. 多个异常一次捕获一次处理。
 8          */
 9 
10         //1. 多个异常分别处理。
11        /* try {
12             int[] arr = {1,2,3};
13             System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
14         }catch (ArrayIndexOutOfBoundsException e){
15             System.out.println(e);
16         }
17 
18         try{
19             List<Integer> list = List.of(1, 2, 3);
20             System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
21         }catch (IndexOutOfBoundsException e){
22             System.out.println(e);
23         }*/
24 
25         //2. 多个异常一次捕获，多次处理。
26         /*try {
27             int[] arr = {1,2,3};
28             //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
29             List<Integer> list = List.of(1, 2, 3);
30             System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
31         }catch (ArrayIndexOutOfBoundsException e){
32             System.out.println(e);
33         }catch (IndexOutOfBoundsException e){
34             System.out.println(e);
35         }*/
36 
37         /*
38             一个try多个catch注意事项:
39                 catch里边定义的异常变量,如果有子父类关系,那么子类的异常变量必须写在上边,否则就会报错
40                 ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
41          */
42         /*try {
43             int[] arr = {1,2,3};
44             //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
45             List<Integer> list = List.of(1, 2, 3);
46             System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
47         }catch (IndexOutOfBoundsException e){
48             System.out.println(e);
49         }catch (ArrayIndexOutOfBoundsException e){
50             System.out.println(e);
51         }*/
52 
53         //3. 多个异常一次捕获一次处理。
54         /*try {
55             int[] arr = {1,2,3};
56             //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
57             List<Integer> list = List.of(1, 2, 3);
58             System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
59         }catch (Exception e){
60             System.out.println(e);
61         }*/
62 
63         //运行时异常被抛出可以不处理。即不捕获也不声明抛出。
64         //默认给虚拟机处理,终止程序,什么时候不抛出运行时异常了,在来继续执行程序
65         int[] arr = {1,2,3};
66         System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3
67         List<Integer> list = List.of(1, 2, 3);
68         System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out-of-bounds for length 3
69 
70         System.out.println("后续代码!");
71     }
72 }

代码示例：

 1 /*
 2     如果finally有return语句,永远返回finally中的结果,避免该情况.
 3  */
 4 public class Demo02Exception {
 5     public static void main(String[] args) {
 6         int a = getA();
 7         System.out.println(a);
 8     }
 9 
10     //定义一个方法,返回变量a的值
11     public static int getA(){
12         int a = 10;
13         try{
14             return a;
15         }catch (Exception e){
16             System.out.println(e);
17         }finally {
18             //一定会执行的代码
19             a = 100;
20             return a;
21         }
22 
23     }
24 }

说明：调用方法后，返回值是100。为了避免永远返回finally中的结果，finally代码块中尽量不要使用return语句。

　　子父类的异常:
　　　　- 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
　　　　- 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
　　注意:
　　　　父类异常时什么样,子类异常就什么样

代码示例：

 1 /*
 2     子父类的异常:
 3         - 如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
 4         - 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
 5     注意:
 6         父类异常时什么样,子类异常就什么样
 7  */
 8 public class Fu {
 9     public void show01() throws NullPointerException,ClassCastException{}
10     public void show02() throws IndexOutOfBoundsException{}
11     public void show03() throws IndexOutOfBoundsException{}
12     public void show04() throws Exception {}
13 }
14 
15 class Zi extends Fu{
16     //子类重写父类方法时,抛出和父类相同的异常
17     public void show01() throws NullPointerException,ClassCastException{}
18     //子类重写父类方法时,抛出父类异常的子类
19     public void show02() throws ArrayIndexOutOfBoundsException{}
20     //子类重写父类方法时,不抛出异常
21     public void show03() {}
22 
23     /*
24         父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。
25 
26      */
27     //public void show04() throws Exception{}
28 
29     //此时子类产生该异常，只能捕获处理，不能声明抛出
30     public void show04()  {
31         try {
32             throw  new Exception("编译期异常");
33         } catch (Exception e) {
34             e.printStackTrace();
35         }
36     }
37 }

第三章自定义异常

3.1 概述

　　为什么需要自定义异常类:
　　　　我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。
　　在上述代码中，发现这些异常都是JDK内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题.那么能不能自己定义异常呢？
　　什么是自定义异常类:
　　　　在开发中根据自己业务的异常情况来定义异常类.
　　　　自定义一个业务逻辑异常: RegisterException。一个注册异常类。
　　异常类如何定义:
　　　　1. 自定义一个编译期异常: 自定义类并继承于java.lang.Exception 。
　　　　2. 自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException 。

　　自定义异常类:
　　　　java提供的异常类,不够我们使用,需要自己定义一些异常类
　　格式:
　　　　public class XXXExcepiton extends Exception | RuntimeException{
　　　　　　添加一个空参数的构造方法
　　　　　　添加一个带异常信息的构造方法
　　　　}
　　注意:
　　　　1.自定义异常类一般都是以Exception结尾,说明该类是一个异常类
　　　　2.自定义异常类,必须的继承Exception或者RuntimeException
　　　　　　继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try...catch
　　　　　　继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)

代码示例：

 1 /*
 2     自定义异常类:
 3         java提供的异常类,不够我们使用,需要自己定义一些异常类
 4     格式:
 5         public class XXXExcepiton extends Exception | RuntimeException{
 6             添加一个空参数的构造方法
 7             添加一个带异常信息的构造方法
 8         }
 9      注意:
10         1.自定义异常类一般都是以Exception结尾,说明该类是一个异常类
11         2.自定义异常类,必须的继承Exception或者RuntimeException
12             继承Exception:那么自定义的异常类就是一个编译期异常,如果方法内部抛出了编译期异常,就必须处理这个异常,要么throws,要么try...catch
13             继承RuntimeException:那么自定义的异常类就是一个运行期异常,无需处理,交给虚拟机处理(中断处理)
14  */
15 public class RegisterException extends /*Exception*/ RuntimeException{
16     //添加一个空参数的构造方法
17     public RegisterException(){
18         super();
19     }
20 
21     /*
22         添加一个带异常信息的构造方法
23         查看源码发现,所有的异常类都会有一个带异常信息的构造方法,方法内部会调用父类带异常信息的构造方法,让父类来处理这个异常信息
24      */
25     public RegisterException(String message){
26         super(message);
27     }
28 }

3.2 自定义异常的练习

要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

Demo01RegisterException.java：

 1 import java.util.Scanner;
 2 
 3 /*
 4     要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
 5 
 6     分析:
 7         1.使用数组保存已经注册过的用户名(数据库)
 8         2.使用Scanner获取用户输入的注册的用户名(前端,页面)
 9         3.定义一个方法,对用户输入的中注册的用户名进行判断
10             遍历存储已经注册过用户名的数组,获取每一个用户名
11             使用获取到的用户名和用户输入的用户名比较
12                 true:
13                     用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";
14                 false:
15                     继续遍历比较
16             如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
17  */
18 public class Demo01RegisterException {
19     // 1.使用数组保存已经注册过的用户名(数据库)
20     static String[] usernames = {"张三","李四","王五"};
21 
22     public static void main(String[] args) /*throws RegisterException*/ {
23         //2.使用Scanner获取用户输入的注册的用户名(前端,页面)
24         Scanner sc = new Scanner(System.in);
25         System.out.println("请输入您要注册的用户名:");
26         String username = sc.next();
27         checkUsername(username);
28 
29     }
30 
31     //3.定义一个方法,对用户输入的中注册的用户名进行判断
32     public static void checkUsername(String username) /*throws RegisterException*/ {
33         //遍历存储已经注册过用户名的数组,获取每一个用户名
34         for (String name : usernames) {
35             //使用获取到的用户名和用户输入的用户名比较
36             if(name.equals(username)){
37                 //true:用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";
38                 try {
39                     throw new RegisterException("亲，该用户名已经被注册");
40                 } catch (RegisterException e) {
41                     e.printStackTrace();
42                     return; //结束方法（否则会执行下面的System.out.println("恭喜您,注册成功!");语句）
43                 }
44             }
45         }
46         //如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
47         System.out.println("恭喜您,注册成功!");
48     }
49 }

Demo02RegisterException.java：

 1 import java.util.Scanner;
 2 
 3 /*
 4     要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。
 5 
 6     分析:
 7         1.使用数组保存已经注册过的用户名(数据库)
 8         2.使用Scanner获取用户输入的注册的用户名(前端,页面)
 9         3.定义一个方法,对用户输入的中注册的用户名进行判断
10             遍历存储已经注册过用户名的数组,获取每一个用户名
11             使用获取到的用户名和用户输入的用户名比较
12                 true:
13                     用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";
14                 false:
15                     继续遍历比较
16             如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
17  */
18 public class Demo02RegisterException {
19     // 1.使用数组保存已经注册过的用户名(数据库)
20     static String[] usernames = {"张三","李四","王五"};
21 
22     public static void main(String[] args) {
23         //2.使用Scanner获取用户输入的注册的用户名(前端,页面)
24         Scanner sc = new Scanner(System.in);
25         System.out.println("请输入您要注册的用户名:");
26         String username = sc.next();
27         checkUsername(username);
28 
29     }
30 
31     //3.定义一个方法,对用户输入的中注册的用户名进行判断
32     public static void checkUsername(String username)  {
33         //遍历存储已经注册过用户名的数组,获取每一个用户名
34         for (String name : usernames) {
35             //使用获取到的用户名和用户输入的用户名比较
36             if(name.equals(username)){
37                 //true:用户名已经存在,抛出RegisterException异常,告知用户"亲，该用户名已经被注册";
38                 throw new RegisterException("亲，该用户名已经被注册");//抛出运行期异常,无需处理,交给JVM处理,中断处理
39             }
40         }
41 
42         //如果循环结束了,还没有找到重复的用户名,提示用户"恭喜您,注册成功!";
43         System.out.println("恭喜您,注册成功!");
44     }
45 }