java的异常机制、异常处理

异常

异常

异常的概念

导堂，就是不正堂的意思，在生活中医生说你的身体某个部位有导堂该部位和正堂相比有点不同该部位的功能将受影响在程序中的意思就是:

• 异常:指的是程序在执行过程中，出现的非正常的情况，最终会导致VM的非正常停止

在java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理是堂的方式是中新外理

异常指的并不是语法错误语法错了编译不通过不会产生字节码文件,根本不能运行

异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable 其下有两个子类
java.lang.Error与java.lang.Exception 平常所说的异常指java.lang.Exception

异常的分类

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序异常(Exception)的分类根据在编译时期还是运行时期去检查异常?

• 编译时期异常：checked异常。在编译时期，就会检查如果没有处理异常则编译失败。(如日期格式化异常)
• 运行时期异常：runtime异常。在运行时期检查异常在编译时期运行异常不会编译器检测(不报错)。(如数学异常)

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
    java.lang.Throwable:类是Java语言中所有错误或异常的超类。
        Exception：编译期异常，进行编译（写代码）java程序出现的问题
            RuntimeException：运行期异常，java程序运行过程中出现的问题
            异常就相当于程序得了一个小毛病(感冒,发烧)，把异常处理掉，程序可以继续执行(吃点药、继续革命工作)
    Error：错误
        错误就相当于程序的了一个无法治愈的毛病(艾滋)，必须修改源代码，程序才能继续进行
 */
public class Demo01Exception {
    public static void main(String[] args) /*throws ParseException*/ {
        //Exception：编译期异常，进行编译（写代码）java程序出现的问题
        /*SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");//用来格式化日期
        Date date = null;
        try {
            date = sdf.parse("1999-09-09");//把字符串格式的日期，解析为Date格式的日期
        } catch (ParseException e) {
            e.printStackTrace();
        }*/

        //RuntimeException：运行期异常，java程序运行过程中出现的问题
        /*int[] arr = {1,2,3};
        try{
            //可能会出现异常的代码
            System.out.println(arr[3]);
        }catch (Exception e){
            //异常的处理逻辑
            System.out.println(e);
        }*/

        /*
            Error：错误
            OutOfMemoryError: Java heap space
            内存溢出的错误，创建的数组太大了，超出了给JVM分配的内存
         */
        int[] arr = new int[1021*1024*1024];
        System.out.println("后续代码");
    }
}

异常的产生过程解析

/*
    异常的产生过程解析(分析异常怎么产生的，如何处理异常)
 */
public class Demo02Exception {
    public static void main(String[] args) {
        //创建int类型的数组，并赋值
        int[] arr = {1,2,3};
        int e = getElement(arr,3);
        System.out.println(e);
    }
    /*
        定义一个方法，获取数组指定索引出的与水泥素
        参数：
            int[] arr
            int index
     */
    public static int getElement(int[] arr,int index){
        int ele = arr[index];
        return ele;
    }
}

异常的处理

抛出异常throw

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来，这时重要使用拗出是堂的方式来告诉调用者

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢?

1. 创建一个异常对象。封装一些提示信息(信息可以自己编写)。
2. 需要将这个异常对象告知给调用者。怎么告知呢?怎么将这个异常对象传递到调用者处呢?通过关键字throw就可以完成。throw 异常对象。
   throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

/*
    throw关键字
    作用：
        可以使用throw关键字在指定的方法中抛出指定的异常
    使用格式：
        throw new xxxException("异常产生的原因");
    注意：
        1.throw关键字必须写在方法的内部
        2.throw关键字后面new的对象必须是Exception或者Exception的子类对象
        3.throw关键字抛出指定的异常对象，我们就必须处理这个异常对象
            throw关键字后面创建的是RuntimeException或者RuntimeException的子类对象，我们可以不处理，默认交给JVM处理(打印异常对象，中断程序)
            throw关键字后面创建的是编译异常(写代码的时候报错)，我们就必须处理这个异常，要么throws，要么try...catch
 */
public class Demo03Exception_throw {
    public static void main(String[] args) {
        //int[] arr = null;
        int[] arr = new int[3];
        int e = getElement(arr,3);
        System.out.println(e);
    }
    /*
        定义一个方法，获取数组指定索引出的与水泥素
        参数：
            int[] arr
            int index
        以后(工作中)我们首先必须对方法传递过来的参数进行合法性校验
        如果参数不合法，那么我们就必须使用抛出异常的方法，告知方法的调用者，传递的参数有问题
        注意：
            NullPointerException是一个运行期异常，我们不用处理，默认交给JVM处理
            ArrayIndexOutOfBoundsException是一个运行期异常，我们不用处理，默认交给JVM处理
     */
    public static int getElement(int[] arr,int index){
        /*
            我们可以对传递过来的参数数组，进行合法性校验
            如果数组arr的值为null
            那么我们就抛出空指针异常，告知方法的调用者“传递的数组值为null”
            Objects.requireNonNull(arr,"传递的数组为null");
         */
        if (arr == null){
            throw  new NullPointerException("传递的数组为null");
        }
        /*
            我们可以对传递过来的参数index进行合法性校验
            如果index的范围不再数组的索引范围内
            那么我们就抛出数组索引越界异常，告知方法的带用着“传递的数组的索引超出数组的使用范围”
         */
        if (index < 0 || index > arr.length-1){
            throw new ArrayIndexOutOfBoundsException("传递的数组的索引超出数组的使用范围");
        }
        int ele = arr[index];
        return ele;
    }
}

Objects非空判断

import java.util.Objects;

/*
    Objects类的静态方法
    public static <T> T requireNonNull(T obj):查看指定引用对象不是null
    源码：
        public static <T> T requireNonNull(T obj){
        if(obj==nul){
            throw new NullPointerException();
            return obj;
        }
 */
public class Demo04Exception_Objects {
    public static void main(String[] args) {
        method(null);
    }
    public static void method(Object obj){
        /*//对传递过来的参数进行合法性判断，判断是否为null
        if(pbj == null){
            throw  new NullPointerException("传递的对象的值是null");
        }*/
        Objects.requireNonNull(obj);
        Objects.requireNonNull(obj,"传递的对象的值是null");
    }
}

声明异常throws

声明异常:将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理(稍后讲解该方式)，那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上，用于表示当前方法不处理异常，而是提醒该方法的调用者来处理异常(抛出异常)

import java.io.FileNotFoundException;
import java.io.IOException;

/*
    throws关键字：异常处理的第一种方式，交给别人处理
    作用：
        当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象
        可以使用throws关键字处理异常对象，会把异常对象声明抛出给方法的调用者处理(自己不处理，给别人处理)，最终交给JVM处理-->中断处理
    使用格式：在方法声明时使用
        修饰符 返回值类型 方法名(参数列表) throws{
            throws new AAAException("产生原因");
            throws new BBBException("产生原因");
            ...
        }
        注意：
            1.throws关键字必须写在方法声明处
            2.throws关键字后边声明的异常必须是Exception或者Exception的子类
            3.方法内部如果抛出了多个异常，那么throws后边必须也声明多个异常
                如果抛出的多个异常对象有子父类关系，那么直接声明父类异常集合
            4.调用了一个声明抛出异常的方法，我们就必须处理声明的异常
                要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM
                要么try...catch自己处理异常
 */
public class Demo05Exceprion_throws {
    /*
        FileNotFoundException extends IOException
        如果抛出的多个异常对象有子父类关系，那么直接声明父类异常集合
     */
    //public static void main(String[] args) throws FileNotFoundException,IOException {
    //public static void main(String[] args) throws IOException {
    public static void main(String[] args) throws Exception {
        readFile("d:\\a.txt");
    }
    /*
        定义一个方法，对传递的文件路径进行合法性判断
        如果路劲不是“c:\\a.txt”，那么就排除文件找不到异常对象，告知方法调用者
        注意：
            FileNotFoundException是编译异常，抛出了编译异常，就必须处理这个异常
            可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法的调用者处理
    */
    public static void readFile(String fileName) throws FileNotFoundException,IOException{
        if(!fileName.equals("c:\\a.txt")){
            throw  new FileNotFoundException("传递的文件不是c:\\a.txt");
        }

        /*
            如果传递的路径，不是.txt结尾
            那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀不对
         */
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

捕获异常try…catch

如果异常出现的话，会立刻终止程序,所以我们得处理异常:

1. 该方法不处理而是声明抛出由该方法的调用者来处理(throws)。

2. 在方法中使用try-catch的语句块来处理异常

try-catch的方式就是捕获异常

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

import java.io.IOException;

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

        }
    注意：
        1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
        2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try...catch之后的代码
          如果太容易中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try...catch之后的代码
 */
public class Demo06Exception_TyrCatch {
    public static void main(String[] args) {
        try {
            readFile("d:\\a.tx");
        } catch (IOException e) {//try抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
            //异常的处理逻辑，产生异常对象之后，怎么处理异常对象
            System.out.println("catch - 传递的文件后缀名不是.txt");
        }
        System.out.println("后续代码");
    }
    /*
        如果传递的路径，不是.txt结尾
        那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀不对
    */
    public static void readFile(String fileName) throws IOException {

        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

如何获取异常信息
Throwable类中定义了一些查看方法

• public String getMessage() :获取异常的描述信息,原因(提示给用户的时候，就提示错误原因。

• public String tostring():获取异常的类型和异常描述信息(不用)。

• public void printstackTrace():打印异常的跟踪栈信息并输出到控制台。

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

在开发中呢也可以在catch将编译期异常转换成运行期异常处理。

import java.io.IOException;
public class Demo06Exception_TyrCatch {
    public static void main(String[] args) {
        try {
            readFile("d:\\a.tx");
        } catch (IOException e) {
            /*
                Throwable类中定义了3ge异常处理的方法
                    String getMessage() 返回此 throwable 的简短描述
                    String toString() 返回此 throwable 的详细信息字符串
                    void printStackTrace() JVM打印异常对象，默认调用此方法，打印的异常信息是最全面的
             */
            System.out.println(e.getMessage());//文件的后缀名不对
            System.out.println(e.toString());//重写Object类的toString方法 java.io.IOException: 文件的后缀名不对
            System.out.println(e);//java.io.IOException: 文件的后缀名不对
            e.printStackTrace();
        }
        System.out.println("后续代码");
    }
   
    public static void readFile(String fileName) throws IOException {

        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

finally代码块

finally:有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行?

当我们在trv语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等)我们都得在使用完之后，最终关闭打开的资源。

import java.io.FileNotFoundException;
import java.io.IOException;

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

        }finally{
            无论是否出现异常都会执行
        }
    注意：
        1.finally不能单独使用，必须和try一起使用
        2.finally一般用于资源释放(资源回收),无论程序是否出现异常，最后的都要资源释放(IO)
 */
public class Demo07Exception_TryCatchFinally {
    public static void main(String[] args) {
        try {
            //可能会产生异常的代码
            readFile("c:\\a.txt");
        } catch (IOException e) {
            //异常的处理逻辑
            e.printStackTrace();
        }finally {
            //无论是否出现异常都会执行
            System.out.println("资源释放");
        }
    }
    public static void readFile(String fileName) throws IOException {
        if(!fileName.equals("c:\\a.txt")){
            throw  new FileNotFoundException("传递的文件不是c:\\a.txt");
        }

        /*
            如果传递的路径，不是.txt结尾
            那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀不对
         */
        if(!fileName.endsWith(".txt")){
            throw new IOException("文件的后缀名不对");
        }
        System.out.println("路径没有问题，读取文件");
    }
}

异常注意事项

多个异常使用捕获又该如何处理呢?

1. 多个异常分别处理
2. 多异常一次捕获，多次 处理。
3. 多个异常一次捕获一次处理。

• 运行时异常被抛出可以不处理。即不捕获也不声明排除。

import java.util.ArrayList;
import java.util.List;

/*
    异常的注意事项
 */
public class Demo08Exception_PayAttention {
    public static void main(String[] args) {
        /*
            多个异常使用捕获又该如何处理呢?
            1.多个异常分别处理
            2多异常一次捕获，多次处理。
            3.多个异常一次捕获一次处理。
         */

        //1.多个异常分别处理
        /*try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }

        try {
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out of bounds for length 3
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }*/

        //2多异常一次捕获，多次处理。
        /*try{
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out of bounds for length 3
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }catch(IndexOutOfBoundsException e){
            System.out.println(e);
        }*/
        /*
            一个try多个catch注意事项：
                catch里边定义的异常变量，如果有子父类关系，那么子类的异常变量必须写在上边，否则就会报错
                ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
         */
        /*try{
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out of bounds for length 3
        }catch(IndexOutOfBoundsException e){
            System.out.println(e);
        }catch(ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }*/

        //3.多个异常一次捕获一次处理。
        try{
            int[] arr = {1,2,3};
            //System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out of bounds for length 3
        }catch(Exception e){
            System.out.println(e);
        }

        //运行时异常被抛出可以不处理。即不捕获也不声明排除。
        //默认会给虚拟机处理，终止程序，什么时候不抛出运行时异常了，再来继续执行程序
        int[] arr = {1,2,3};
        System.out.println(arr[3]);//ArrayIndexOutOfBoundsException
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list.get(3));//IndexOutOfBoundsException: Index 3 out of bounds for length 3

        System.out.println("后续代码！");
    }
}

• 如果finally有return语句,永远返回finally中的结果避免该情况.

  /*
      如果finally有return语句,永远返回finally中的结果避免该情况.
   */
  public class Demo08Exception_PayAttention2 {
      public static void main(String[] args) {
          int a = getA();
          System.out.println(a);
      }
      //定义一个方法，返回变量a的值
      public static int getA(){
          int a = 10;
          try {
              return a;
          }catch (Exception e){
              System.out.println(e);
          }finally {
              //一定会执行的代码
              a = 100;
              return a;
          }
      }
  

• 如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。

• 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

  /*
      子父类的异常：
          - 如果父类抛出了多个异常，子类重写父类方法时，抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
          - 父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
      注意：
          父类异常时什么样，子类就异常就什么样
   */
  public class Fu {
      public void show01() throws NullPointerException,ClassCastException{}
      public void show02() throws IndexOutOfBoundsException{}
      public void show03() throws IndexOutOfBoundsException{}
      public void show04() {}
  }
  class Zi extends Fu{
      //子类重写父类方法时，抛出和父类相同的异常
      public void show01() throws NullPointerException,ClassCastException{}
      //子类重写父类方法时，抛出父类异常的子类
      public void show02() throws ArrayIndexOutOfBoundsException{}
      //子类重写父类方法时，不抛出异常
      public void show03(){}
  
      //父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。
      //public void show04() throws Exception{}
      // 此时子类产生该异常，只能捕获处理，不能声明抛出
      public void show04() {
          try {
              throw new Exception("编译期异常");
          } catch (Exception e) {
              e.printStackTrace();
          }
      }
  }
  

• 在try/catch后可以追加finally代码块，其中的代码一定会被执行，通常用于资源回收

自定义异常

概述

为什么需要自定义异常类：
我们说了Java中不同的异常类分别表示着某一种具体的异常情况那么在开发中总是有些异常情况是SUN没有定义好的此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题，考试成绩负数问题等等。

在上述代码中，发现这些异常都是JDK内部定义好的，但是实际开发中也会出现很多异常，这些异常很可能在JDK中没有定义过例如年龄负数问题考试成绩负数问题那么能不能自己定义异常呢?

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类

自定义一个业务逻辑异常:RegisterException。一个注册异常类

异常类如何定义:

1. 自定义一个编译期异常:自定义类并继承于java.lang.Exception。
2. 自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException.

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

    public RegisterException() {
        super();
    }

    /*
        添加一个带异常信息的构造方法
        查看源码发现，所有的异常类都会有一个带异常信息的构造方法，方法内部调用父类带异常信息的构造方法，让父类来处理这个异常信息
     */
    public RegisterException(String message) {
        super(message);
    }
}

自定义异常练习

RegisterException.java

public class RegisterException extends RuntimeException{
    //添加一个空参数的构造方法

    public RegisterException() {
        super();
    }

    /*
        添加一个带异常信息的构造方法
        查看源码发现，所有的异常类都会有一个带异常信息的构造方法，方法内部调用父类带异常信息的构造方法，让父类来处理这个异常信息
     */
    public RegisterException(String message) {
        super(message);
    }
}

Register_Exception.java

import java.util.Scanner;

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

    分析：
        1.使用数组保存已经注册过的用户名(数据库)
        2.使用Scanner获取用户输入的注册的用户名(前端，页面)
        3.定义一个方法，对用户输入的中注册的用户名进行判断
            谝历存储已经注册过用户名的数组 获取每一个用户名
            使用获取到的用户名和用户输入的用户名比较
                tnue ：
                    用户名已经存在，抛出RegisterException异常，告知用户"亲，该用户名已经被注册”
                false:
                    继续遍历比较
                如果循环结束了，还没有找到重复的用户名，提示用户“恭喜您，注册成功!";
 */
public class Register_Exception {
    //1.使用数组保存已经注册过的用户名(数据库)
    static String[] usernames = {"张三","李四","王五"};

    public static void main(String[] args) /*throws RegisterException*/ {
        //2.使用Scanner获取用户输入的注册的用户名(前端，页面)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名：");
        String username = sc.next();
        checkUsername(username);
    }
    //3.定义一个方法，对用户输入的中注册的用户名进行判断
    public static void checkUsername(String username) /*throws RegisterException*/ {
        //谝历存储已经注册过用户名的数组 获取每一个用户名
        for(String name : usernames){
            if (name.equals(usernames)){
                //tnue ：用户名已经存在，抛出RegisterException异常，告知用户"亲，该用户名已经被注册”
                try {
                    throw new RegisterException("该用户已经被注册");
                } catch (RegisterException e) {
                    e.printStackTrace();
                    return;//结束方法
                }
            }
        }
        //如果循环结束了，还没有找到重复的用户名，提示用户“恭喜您，注册成功!";
        System.out.println("恭喜您，注册成功!");
    }
}

Register_Exception2.java

import java.util.Scanner;

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

    分析：
        1.使用数组保存已经注册过的用户名(数据库)
        2.使用Scanner获取用户输入的注册的用户名(前端，页面)
        3.定义一个方法，对用户输入的中注册的用户名进行判断
            谝历存储已经注册过用户名的数组 获取每一个用户名
            使用获取到的用户名和用户输入的用户名比较
                tnue ：
                    用户名已经存在，抛出RegisterException异常，告知用户"亲，该用户名已经被注册”
                false:
                    继续遍历比较
                如果循环结束了，还没有找到重复的用户名，提示用户“恭喜您，注册成功!";
 */
public class Register_Exception2{
    //1.使用数组保存已经注册过的用户名(数据库)
    static String[] usernames = {"张三","李四","王五"};

    public static void main(String[] args) /*throws RegisterException*/ {
        //2.使用Scanner获取用户输入的注册的用户名(前端，页面)
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您要注册的用户名：");
        String username = sc.next();
        checkUsername(username);
    }
    //3.定义一个方法，对用户输入的中注册的用户名进行判断
    public static void checkUsername(String username){
        //谝历存储已经注册过用户名的数组 获取每一个用户名
        for(String name : usernames){
            if (name.equals(usernames)){
                //tnue ：用户名已经存在，抛出RegisterException异常，告知用户"亲，该用户名已经被注册”
                throw new RegisterException("该用户已经被注册");//抛出运行期异常，无需处理，交给JVM处理，中断处理

            }
        }
        //如果循环结束了，还没有找到重复的用户名，提示用户“恭喜您，注册成功!";
        System.out.println("恭喜您，注册成功!");
    }
}