Java Day16

第一章 异常

1.1 异常的概念

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

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

1.2 异常体系

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

• Throwable体系：
  • Error：严重错误Error，无法通过处理的错误，只能事先避免。
  • Exception：表示异常，异常产生后程序员可以通过代码的方法纠正，是程序继续运行，是必须要处理的。
• Throwable中的常用方法：
  • public void printStackTrace()：打印异常的详细信息。包含了异常的类型，异常的原因，还包括异常出现的位置，在开发和调试阶段，都得使用printStackTrace。
  • public String getMessage()：获取发生异常的原因，提示给用户的时候就提示错误原因。
  • public String toString()：获取异常的类型和异常描述信息。

1.3 异常分类

异常的分类：根据在编译时期还是在运行时期去检查异常。

• 编译时期异常：checked异常，在编译时期，就会去检查。如果没有处理异常，则编译失败。
• 运行时期异常：runtime异常，在运行时期，检查异常，在编译时期，运行异常不会编译器检测。

1.4 异常产生的过程解析

以下程序会发生数组索引越界异常ArrayIndexOfBoundsException，我们通过该类来看看异常产生的过程：

package com.it.day05code.Exception;

/*
* 异常的产生过程解析（分析异常是怎么产生的，如何处理异常）
*
* */

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

第二章 异常的处理

2.1 抛出异常throw

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

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象，具体操作如下：

• 创建一个异常对象，封装一些提示信息（信息可以自己编写）
• 需要将这个异常对象告知给调用者。通过throw关键字可以完成异常的抛出
  • throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
  • 使用格式：

throw new 异常类名(参数);

代码演示：

package com.it.day05code.Exception;

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

public class Demo03Throw {
    public static void main(String[] args) {
        int[] arr = {0, 1};
        getElement(arr, 2);

    }

    /*
    * 定义一个方法，获取数组指定索引的元素
    * 参数：
    *   int[] arr
    *   int index
    * 以后我们首先必须对方法传递过来的参数进行合法性校验
    * 如果参数不合法，那么我们就必须使用抛出异常的方式，告知方法的调用者，传递的参数有问题
    * 注意：
    *   NullPointerException是一个运行期异常，我们不用处理，默认交给JVM处理。
    *   IndexOutOfBoundsException是一个运行期异常，我们不用处理，默认交给JVM处理。
    * */
    public static int getElement(int[] arr, int index) {
        /*
        * 我们可以对传递过来的参数数组，进行合法性校验
        * 如果数组arr的值是null
        * 那么我们就可以抛出空指针异常，告知方法的调用者"传递的数组值是null"
        *
        * */
        if (arr == null) {
            throw new NullPointerException("传递的数组值是null");
        }
        /*
        * 我们可以对传递过来的参数index进行合法性校验
        * 如果index的范围不再数组的索引范围内，
        * 那么我们就可以抛出一个数组索引越界异常，告知方法的调用者"传递的索引超出了数组的使用范围"
        *
        * */
        if (index < 0 || index >= arr.length) {
            throw new IndexOutOfBoundsException("传递的索引超出了数组的使用范围");
        }
        int ele = arr[index];
        return ele;
    }
}

注意：产生问题后我们使用throw将异常抛出，也就是将问题返回给方法的调用者，调用者的处理方式有两种：捕获处理或者抛出。

2.2 Objects非空判断

在我们之前学的Objects类时，我们在使用它的一些静态方法时，这些方法是null-save（空指针-安全的）或者null-tolerant（容忍空指针的）,查看源码发现，在源码中对对象为null的值进行了抛出异常操作。

• public static <T> T reqireNunNull(T obj)：查看指定引用对象不是null。

源码如下：

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

2.3 声明异常throws

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

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

• 代码如下：

/*
* throws关键字：异常处理的第一种方式，交给别人处理
* 作用：
*   当方法内部抛出异常对象的时候，那么我们就必须处理这个异常对象
*   可以使用throws关键自处理异常对象，会吧异常对象声明抛出给方法调用者处理（自己不处理，交给别人处理），最终交给JVM处理-->中断处理
* 使用格式：在方法声明时使用：
*   修饰符 返回值类型 方法名(参数列表) throws AAAException, BBBException... {
*       throw new AAAException("产生原因");
*       throw new AAAException("产生原因");
*       ...
*   }
* 注意：
*   1、throws关键字必须在方法声明处
*   2、throws关键字后边声明的异常对象必须是Exception或者是Exception子类
*   3、方法内部如果抛出了多个异常对象有子父类关系，那么直接声明父类异常即可
*   4、调用了一个声明抛出异常的方法，我们就必须树立声明的异常
*       要么继续使用throws声明抛出，交给方法的调用者处理，最终交给JVM
*       要么try...catch自己处理异常
* */

import java.io.FileNotFoundException;
import java.io.IOException;
import java.nio.file.NoSuchFileException;

public class Demo05Throws {

    /*
    * FileNotFoundException extends IOException
    * 如果抛出多个异常对象有子父类关系，那么我们声明父类异常即可。
    *
    * */
    public static void main(String[] args) throws FileNotFoundException, IOException {
        readFile("cdicjdi");
    }

    /*
    * 定义一个方法，对传递的文件路径进行合法性判断
    * 如果路径不是"C：\\a.txt"，那么我们就抛出文件找不到异常对象，告知方法的调用者
    *
    * 注意：
    *   FileNotFoundException是编译异常，抛出了编译异常就必须处理这个异常
    *   可以使用throws继续声明抛出FileNotFoundException这个异常对象，让方法的调用者处理。
    *
    * */
    public static void readFile(String fileName) throws FileNotFoundException, IOException {
        if (!fileName.equals("c:\\\\a.txt")) {
            throw new FileNotFoundException("文件找不到");
        }

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

2.4 捕获异常try...catch

• 如果异常出现的话，会立刻终止程序，所以我们得处理异常：
  • 该方法不处理而是抛出，由该方法的调用者来处理异常（throws）
  • 该方法中使用try-catch的语句块来处理异常。
• try-catch的方式就是捕获异常：
  • 捕获异常：java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。
  • 格式如下：

try {
    可能出现异常的代码
} catch(异常类型 e) {
    处理异常代码
    // 记录日志/打印异常信息/继续抛出异常
}

• try：该代码块中编写可能产生异常的信息。
• catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
• try和catch不能单独出现。

代码如下：

/*
* try...catch：异常处理的第二种方式，自己处理异常
* 格式：
*   try {
*       可能产生异常的代码
*   } catch (定义一个异常的变量，用来接收try中抛出的异常对象) {
*       异常的处理逻辑，异常对象之后怎么处理异常对象
*       一般在工作中，会把异常的信息记录到一个日志中
*   }
*   ...
*   catch(异常类名 变量名) {
*
*   }
*
* 注意：
*   1、try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
*   2、如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try...catch之后的代码
*      如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try...catch之后的代码
*
* */

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

public class Demo05TryCatch {
    public static void main(String[] args) {
        try {
            readFile("d:\\a.xt");
        } catch (IOException e) {  // try中抛出什么异常对象，catch就定义什么异常变量，用来接收这个异常对象
//            System.out.println("传递的额文件的后缀不是.txt");

            /*
            * Throwable类中定义了3个异常处理方法
            *   String getMessage() 返回此，throwable 的详细消息字符串。
            *   String toString() 返回此throwable 的简短描述。
            *   void printStackTrace()：JVM打印异常对象默认调用此方法，打印的信息最全面
            *
            * */
            // System.out.println(e.getMessage());
            // System.out.println(e.toString());  // 重写Object类的toString方法
            e.printStackTrace();

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

    /*
     * 如果传递的路径，不是.txt结尾
     * 那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
     * */
    public static void readFile(String fileName) throws  IOException {
        if (!fileName.equals("c:\\\\a.txt")) {
            throw new FileNotFoundException("文件找不到");
        }


        if (!fileName.endsWith(".txt")) {
            throw new IOException("文件的后缀名不对");
        }
    }

}

2.4 finally代码块

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

try {
    ...
} catch(异常类型 e) {

} catch()
...
finally {

}

• 代码演示：

package com.it.day05code.Exception;

/*
* 格式：
*   try {
*       可能产生异常的代码
*   } catch (定义一个异常的变量，用来接收try中抛出的异常对象) {
*       异常的处理逻辑，异常对象之后怎么处理异常对象
*       一般在工作中，会把异常的信息记录到一个日志中
*   } finally {
*       无论是否出现异常都会执行
*   }
* 注意：
*   1、finally不能单独使用，必须和try一起使用
*   2、finally一般用于资源释放，无论程序是否出现异常，最后都要资源释放
*
* */

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

public class Demo06TryCatchFinally {
    public static void main(String[] args) {
        try {
            // 可能会产生异常的代码
            readFile("c:\\a.ttxt");
        } catch (IOException e) {
            // 异常的处理逻辑
            e.printStackTrace();
        } finally {
            // 无论是否出现异常，都会执行
            System.out.println("资源释放");
        }
    }

    /*
     * 如果传递的路径，不是.txt结尾
     * 那么我们就抛出IO异常对象，告知方法的调用者，文件的后缀名不对
     * */
    public static void readFile(String fileName) throws IOException {
        if (!fileName.equals("c:\\\\a.txt")) {
            throw new FileNotFoundException("文件找不到");
        }


        if (!fileName.endsWith(".txt")) {
            throw new IOException("文件的后缀名不对");
        }
    }
}

2.5 异常的注意事项

• 多个异常如何处理：
  • 多个异常分别处理
  • 多个异常一次捕获，多次处理
  • 多个异常一次捕获，一次处理
  • 代码演示：

/*
* 异常的注意事项：
*
*
* */

import java.util.List;

public class Demo07Exception {
    public static void main(String[] args) {
        /*
        * 多个异常使用捕获又该如何处理呢？
        * 1、多个异常分别处理。
        * 2、多个异常一次捕获，多次处理
        * 3、多个异常一次捕获哦一次处理
        *
        * */
        // 1、多个异常分别处理
//        try {
//            int[] arr = {1, 2, 3};
//            System.out.println(arr[3]);  // ArrayIndexOutOfBoundsException：3
//        } catch (ArrayIndexOutOfBoundsException e) {
//            System.out.println(e);
//        }
//
//        try {
//            List<Integer> list = List.of(1, 2, 3);
//            System.out.println(list.get(3));  // IndexOutOfBoundsException
//        } catch (IndexOutOfBoundsException e) {
//            System.out.println(e);
//        }
//
//        System.out.println("后续代码");

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

        // 多个异常一次捕获一次处理
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]);  // ArrayIndexOutOfBoundsException：3
            List<Integer> list = List.of(1, 2, 3);
            System.out.println(list.get(3));  // IndexOutOfBoundsException
        } catch (IndexOutOfBoundsException e) {
            System.out.println(e);
        }

        int[] arr = {1, 2, 3};
        System.out.println(arr[3]);  // ArrayIndexOutOfBoundsException：3
        List<Integer> list = List.of(1, 2, 3);
        System.out.println(list.get(3));  // IndexOutOfBoundsException


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

    }
}

• 运行时异常被抛出后可以不处理，即不捕获也不抛出。
• 如果finally有return语句，永远返回finally中的结果，避免该类情况。

/*
* 如果finally有reture语句，永远返回finally中的结果，避免该情况
*/

public class Demo08Exception {
    public static void main(String[] args) {
        int a = getA();
        System.out.println(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() {
        try {

        } catch (Exception e) {

        }
    }


}

第三章 自定义异常

3.1 概述

• 为什么需要自定义异常类：在Java中不同的异常类，分别表示着某一种异常情况，那么在开发中总是有些异常情况是没有定义好的，此时就需要我们根据业务情况来定义异常类。
• 什么是自定义异常类：在开发中根据自己业务的异常情况来定义异常类。
• 异常类如何定义：
  • ​​​​​​​自定义一个编译期异常，自定义类，并继承与java.lang.Exception
  • 自定义一个运行期异常类：自定义类并继承于：java.lang.RuntimeException

3.2 自定义异常类练习

3.2.1 编译期异常：

定义一个异常类：

package com.it.day05code.UserDefineException;

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

public class RegisterException extends Exception{
    // 添加一个空参数的构造方法
    public RegisterException() {
        super();
    }

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

}

定义一个测试类：

package com.it.day05code.UserDefineException;

/*
* 需求：我们模拟注册操作，如果用户名已存在，则抛出异常提示：亲，该用户名已经被注册！
* 分析：
*   使用数组保存已经注册过的用户名（数据库）
*   使用Scanner获取用户输入的注册的用户名
*   定义一个方法，对用户输入的注册的用户名进行判断
*       遍历已经注册过用户的数组，获取每一个用户名
*       使用获取到的用户名比较
*           true：用户名已存在，抛出RegisterException异常，告知用户：亲，该用户名已经被注册！
*           false：继续遍历比较
*           如果结束还没有发现重复的用户名，提示用户"恭喜你注册成功"
*
* */

import java.util.Scanner;

public class Demo01RegisterException {
    static String[] usernames = {"aaa", "bbb", "ccc"};
    public static void main(String[] args) throws RegisterException {
        System.out.println("请输入注册的用户名：");
        String userName = new Scanner(System.in).next();
        check(userName);


    }

    public static void check(String str) throws RegisterException {
        for (String name : usernames) {
            if (name.equals(str)) {
                try {
                    throw new RegisterException("亲，该用户名已经被注册！");
                } catch (RegisterException e) {
                    e.printStackTrace();
                    return;
                }
            }
        }
        System.out.println("恭喜你注册成功");
    }
}

3.2.2 运行期异常

定义一个异常类：

package com.it.day05code.UserDefineException;

public class RegisterException02 extends RuntimeException {
    // 添加一个空参数的构造方法
    public RegisterException02() {
        super();
    }

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

定义测试类：

package com.it.day05code.UserDefineException;

import javax.management.relation.RoleInfoNotFoundException;
import java.util.Scanner;

public class Demo02RegisterException {
    static String[] usernames = {"aaa", "bbb", "ccc"};
    public static void main(String[] args) throws RegisterException {
        System.out.println("请输入注册的用户名：");
        String userName = new Scanner(System.in).next();
        check(userName);


    }

    public static void check(String str) throws RegisterException {
        for (String name : usernames) {
            if (name.equals(str)) {
                // 运行期异常直接抛出
                throw new RegisterException02("用户名已被注册");
            }
        }
        System.out.println("恭喜你注册成功");
    }

}

第四章 多线程

4.1 并发与并行

• ​​​​​​​并发：指两个或多个事件在同一个时间段内发生。
• 并行：指两个或多个事件在同一个时刻发生。

在操作系统中，安装了多个程序，并发指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一个时刻只能有一道程序执行，即微观上这些程序是分时交替运行。

4.2 线程与进程

4.2.1 概述

• 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位，系统运行一个程序是一个进程从创建，运行到消亡的过程。
• 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程，一个进程中可以有多个线程的，这个应用程序也被称为多线程程序。
• 简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

4.2.2 线程的调度

• 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
• 抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，随机选择一个线程执行，java使用的就是抢占式调度。

4.3 创建线程类

java使用java.lang.Thread类代表线程，所有线程对象必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。

java通过继承Thread类来创建并启动多线程，步骤如下：

• 定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程需要完成的任务，因此把run方法称为线程执行体。
• 创建Tread子类的实例，即创建了线程对象。
• 调用线程对象的start方法来启动该线程。
• 代码演示：

自定义线程类：

// 创建一个Thread类
public class MyThread extends Thread {
    // 在Thread类的子类中重写Thread类中的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run：" + i);
        }
    }


}

定义测试类：

/*
* 创建多线程程序的第一种方式：创建Thread类的子类
* java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
*
* 实现步骤：
*   1、创建一个Thread类的子类
*   2、在Thread类的子类中重写Thread类中的run方法，设置线程任务
*   3、创建Thread类的子类对象
*   4、调用Thread类中的方法start方法，开启新的线程，执行run方法
*       void start()：使该线程开始执行；Java虚拟机调用该线程的润方法
*       结果是两个线程并发的运行，当前线程（mian线程）和另一个线程（创建的新线程，执行其run方法）
*       多次启动一个线程是非法的，特别是当线程已经结束执行后，不能再重新启动
*
* java程序属于抢占试调度，哪个线程的优先级搞，哪个线程优先执行，同一个优先级，随机执行
*
* */

public class Demo02Thread {

    public static void main(String[] args) {
        // 创建Thread类的子类对象
        MyThread mt = new MyThread();

        // 调用Thread类中的方法start方法，开启新的线程，执行run方法
        mt.start();

        for (int i = 0; i < 20; i++) {
            System.out.println("main:" + i);
        }



    }
}