八、可变参数、stream流、异常_java 预期的responsetype-CSDN博客

本文链接：https://blog.csdn.net/qq_61935150/article/details/128487237

可变参数

介绍

定义方法参数的一种方式，方法的参数类型已经确定,个数不确定,我们可以使用可变参数

格式

修饰符 返回值类型 方法名(数据类型… 变量名) {  }

注意事项

可变参数的变量其实是一个数组
如果一个方法有多个参数，包含可变参数，可变参数要放在最后

基本使用

    public static void main(String[] args) {
        //int[] arr = new int[]{4, 56, 6, 2, 2, 4, 5, 6, 7, 3};
        //sum(arr);

        sum(4, 56, 6, 2, 2, 4, 5, 6, 7, 3);
        sum();
        sum(10, 20);
        sum(10, 20, 30);

    }

    //计算数组中所有的数据的和 打印
    //int...是可变参数  表示可以接受任意数量的int类型数据 ，可变参数的本质是一个数组
    public static void sum(int... arr) {
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println(sum);
    }

    //public static void sum(int[] arr) {
    //    int sum = 0;
    //    for (int i = 0; i < arr.length; i++) {
    //        sum += arr[i];
    //    }
    //    System.out.println(sum);
    //}

可变参数放到参数的最后面

在这里插入图片描述

创建不可变集合(理解)

static <E> List<E> of(E…elements) 创建一个具有指定元素的List集合对象
static <E> Set<E> of(E…elements) 创建一个具有指定元素的Set集合对象
static <K , V> Map<K，V> of(E…elements) 创建一个具有指定元素的Map集合对象
常用来作为创建集合的构造参数

代码

method1是List.of练习
method2是 Set.of练习，注意不要传入重复数据，会报错
method3是 Map.of练习，传入多个键和值
method4是 Map.ofEntries练习，传入多个Entry对象

    private static void method1() {
        List<String> list = List.of("a", "b", "c", "d");
        System.out.println(list);
        //list.add("Q");报错
        //list.remove("a");报错
        //list.set(0,"A");报错

        //集合的批量添加。
        //首先是通过调用List.of方法来创建一个不可变的集合，of方法的形参就是一个可变参数。
        //再创建一个ArrayList集合，并把这个不可变的集合中所有的数据，都添加到ArrayList中。
        ArrayList<String> list3 = new ArrayList<>(List.of("a", "b", "c", "d"));
        System.out.println(list3);
    }

    private static void method2() {
        //传递的参数当中，不能存在重复的元素。下面的a重复 会报异常 IllegalArgumentException: duplicate element: a
        Set<String> set = Set.of("a", "b", "c", "d", "a");
        System.out.println(set);
    }

    private static void method3() {
        //传入多个键值
        Map<String, String> map = Map.of("zhangsan", "江苏", "lisi", "北京", "wangwu", "天津");
        System.out.println(map);
    }

    private static void method4() {
        //传入一个个Entry对象
        Map<String, String> map = Map.ofEntries(
                Map.entry("zhangsan", "江苏"),
                Map.entry("lisi", "北京")
        );
        System.out.println(map);
    }

Collections.addAll 添加数据

ArrayList<String> list = new ArrayList<>();

//利用Collections的addAll方法添加数据
Collections.addAll(list, "aaa", "bbb", "ccc", "ddd");

System.out.println(list);

Stream流（理解，掌握常用的中间操作）

案例需求

按照下面的要求完成集合的创建和遍历

创建一个集合，存储多个字符串元素
把集合中所有以"张"开头的元素存储到一个新的集合
把"张"开头的集合中的长度为3的元素存储到一个新的集合
遍历上一步得到的集合

原始方式示例代码

ArrayList<String> list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));

//遍历list1把以张开头的元素添加到list2中。
ArrayList<String> list2 = new ArrayList<>();
for (String s : list1) {
    if(s.startsWith("张")){
        list2.add(s);
    }
}
//遍历list2集合，把其中长度为3的元素，再添加到list3中。
ArrayList<String> list3 = new ArrayList<>();
for (String s : list2) {
    if(s.length() == 3){
        list3.add(s);
    }
}
for (String s : list3) {
    System.out.println(s);
}

流的实现方式

        ArrayList<String> list1 = new ArrayList<>(List.of("张三丰", "张无忌", "张翠山", "王二麻子", "张良", "谢广坤"));

        //1 获取流  list1.stream()

        //2 过滤 姓张的数据   filter(s -> s.startsWith("张"))
        //3 过滤 长度为3的数据  filter(s -> s.length() == 3)

        //4 打印  终结操作   forEach(s -> System.out.println(s))

        list1.stream().filter(s -> s.startsWith("张")).
                filter(s -> s.length() == 3).
                forEach(s -> System.out.println(s));

Stream流的思想

类似流水线，在过程中可以多次处理流数据

Stream流的三类方法

获取Stream流
- 创建一条流水线,并把数据放到流水线上准备进行操作
中间方法
- 流水线上的操作
- 一次操作完毕之后,还可以继续进行其他操作
终结方法
- 一个Stream流只能有一个终结方法
- 是流水线上的最后一个操作

生成Stream流的方式

1 Collection体系集合
- 使用默认方法stream()生成流
2 Map体系集合
- 把Map转成Set集合（keySet,entrySet），间接的生成流
- keySet().stream() 或者 entrySet().stream()
3 数组
- 通过Arrays中的静态方法stream生成流 Arrays.stream(arr)
4 同种数据类型的多个数据
- 通过Stream接口的静态方法of(T… values)生成流 , 原理还是数组变流

代码演示

// - 1  Collection体系集合
//  - 使用默认方法stream()生成流
List<String> list = new ArrayList<>();
Stream<String> listStream = list.stream();

Set<String> set = new HashSet<>();
Stream<String> setStream = set.stream();


//- 2  Map体系集合
//  - 把Map转成Set集合（keySet,entrySet），间接的生成流
Map<String, String> map = new HashMap<>();
//先获取key的集合 再获取流
Stream<String> mapKeyStream = map.keySet().stream();
//先获取Entry对象的集合 再获取流
Stream<Map.Entry<String, String>> entryStream = map.entrySet().stream();


//- 3  数组
//  - 通过Arrays中的静态方法stream生成流
int[] arr = new int[]{4,56,7,8,4,3};
IntStream intStream = Arrays.stream(arr);

//4 通过of方法 把同一类型的多个数据 转为流对象
Stream<Integer> is = Stream.of(3, 4, 6, 7, 8);
Stream<String> ss = Stream.of("z", "l", "x");

Stream流中间操作方法【熟练应用】

概念

中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作

常见方法

方法名	说明
Stream filter(Predicate predicate)	用于对流中的数据进行过滤
Stream limit(long maxSize)	返回流中最前面指定参数个数的数据组成的流
Stream skip(long n)	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
static Stream concat(Stream a, Stream b)	合并a和b两个流为一个流
Stream distinct()	返回去掉流数据中重复的元素后剩余数据组成的流

filter代码

流的操作不影响原集合的数据

        ArrayList<String> al = new ArrayList<String>(List.of("周润发", "成龙", "小明", "刘德华", "吴京", "周星驰", "李连杰"));

         //流的操作不影响原集合的数据
        al.stream().filter(s -> s.length() >= 3).forEach(s -> System.out.println(s));

        //会把流数据里的每一条数据 传到test方法中 获取返回值，返回为true的数据留下，为false的删除
        al.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.length() == 3;
            }
        });

limit skip代码

 ArrayList<String> al = new ArrayList<String>(List.of("周润发", "成龙", "小明", "刘德华", "吴京", "周星驰", "李连杰"));
 
System.out.println("--------------------------------------------------------------");
//  Stream<T> limit(long maxSize)           	返回流中最前面指定参数个数的数据组成的流
al.stream().limit(4).forEach(s -> System.out.println(s));

System.out.println("--------------------------------------------------------------");

//  Stream<T> skip(long n)                  	跳过指定参数个数的数据，返回由该流的剩余元素组成的流
al.stream().skip(2).forEach(s -> System.out.println(s));

concat 和distinct

//  static <T> Stream<T> concat(Stream a, Stream b)	合并a和b两个流为一个流
ArrayList<String> al1 = new ArrayList<String>(List.of("林心如", "张曼玉", "林青霞", "柳岩", "林志玲", "小明", "王祖贤"));
Stream.concat(al.stream(), al1.stream()).forEach(s -> System.out.println(s));

System.out.println("--------------------------------------------------------------");
//  Stream<T> distinct()         返回 去掉流数据中 重复的元素后剩余数据组成的流
Stream.concat(al.stream(), al1.stream()).distinct().forEach(s -> System.out.println(s));

skip和limit一起操作

ArrayList<String> al = new ArrayList<String>(List.of("周润发", "成龙", "小明", "刘德华", "吴京", "周星驰", "李连杰"));
//跳过前2个数据 剩余的数据再获取前面2个
al.stream().skip(2).limit(2).forEach(s -> System.out.println(s));

Stream流终结操作方法

概念

终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作

常见方法

方法名	说明
void forEach(Consumer action)	对此流的每个元素执行操作
long count()	返回此流中的元素数

代码

ArrayList<String> al = new ArrayList<String>(List.of("周润发", "成龙", "小明", "刘德华", "吴京", "周星驰", "李连杰"));

al.stream().skip(2).limit(2).forEach(s -> {
    System.out.println(s);
});

long count = al.stream().skip(2).count();//获取数据的数量
System.out.println(count);

collect收集操作

collect方法 获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.
Collectors提供了具体的收集方式
- 收集到List 、收集到Set、收集到Map

方法名	说明
public static Collector toList()	把元素收集到List集合中
public static Collector toSet()	把元素收集到Set集合中
public static Collector toMap(Function keyMapper,Function valueMapper)	把元素收集到Map集合中

收集到list和set的代码

把集合转为流，然后把偶数留下，收集到新的集合中（list或者set）返回

public static void main(String[] args) {
    ArrayList<Integer> al = new ArrayList<>();
    for (int i = 1; i <= 10; i++) {
        al.add(i);
    }
    //添加一些重复数据  为了后面set集合演示去重复
    al.add(10);
    al.add(10);
    al.add(10);
    al.add(10);

    //使用流 获取所有的偶数 最后collect收集到List集合里
    List<Integer> list = al.stream().filter(number -> number % 2 == 0).collect(Collectors.toList());
    System.out.println(list);

    //使用流 获取所有的偶数 最后collect收集到set集合中返回，这里返回的是set集合，重复的数据最后会默认去除
    Set<Integer> set = al.stream().filter(number -> number % 2 == 0).collect(Collectors.toSet());
    System.out.println(set);
    
    
}

收集到map

把学生的名字作为key , 年龄作为value

    public static void main(String[] args) {
        ArrayList<Student> al = new ArrayList<Student>();
        al.add(new Student("zhangsan", 15));
        al.add(new Student("lisi", 17));
        al.add(new Student("xiaoming", 19));

        //数据收集为map集合
        Map<Object, Object> map = al.stream().limit(2).collect(
                Collectors.toMap(
                        new Function<Student, Object>() {
                            @Override
                            public Object apply(Student student) {
                                //返回值作为key
                                return student.getName();
                            }
                        },
                        new Function<Student, Object>() {
                            @Override
                            public Object apply(Student student) {
                                //返回值作为value
                                return student.getAge();
                            }
                        }
                )
        );

        Map<Object, Object> map1 = al.stream().limit(2).collect(
                Collectors.toMap(
                        student -> student.getName(),
                        student -> student.getAge()
                )
        );

        System.out.println(map);

    }

Stream流综合练习

案例需求

现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
- 男演员只要名字为3个字的前三人
- 女演员只要姓林的，并且不要第一个
- 把过滤后的男演员姓名和女演员姓名合并到一起
- 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法

演员类代码

public class Actor {
    private String name;

    public Actor(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

测试类代码

public static void main(String[] args) {
    ArrayList<String> manList = new ArrayList<String>();
    manList.add("周润发");
    manList.add("成龙");
    manList.add("刘德华");
    manList.add("吴京");
    manList.add("周星驰");
    manList.add("李连杰");
    //名字为3个字的前三人
    Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);

    ArrayList<String> womanList = new ArrayList<String>();
    womanList.add("林心如");
    womanList.add("张曼玉");
    womanList.add("林青霞");
    womanList.add("柳岩");
    womanList.add("林志玲");
    womanList.add("王祖贤");
    //只要姓林的，并且不要第一个
    Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);

    //合并过滤后的男演员和女演员
    Stream<String> newStream = Stream.concat(manStream, womanStream);
    newStream.forEach(s -> {
        //创建演员对象 把名字传入
        Actor actor = new Actor(s);
        //获取演员的对象的名字打印
        System.out.println(actor.getName());
    });
}

自学Stream里的 map reduce 方法

异常(重点)

异常介绍

指程序在运行后，JVM遇到无法执行的代码，从而会中断程序

举例

例如：
    int[] arr = new int[3];
    System.out.println(arr[3]);
执行结果：
           Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3
           at com.itheima.demo20.Demo01.main(Demo01.java:8)
               
例如：
    int[] arr = null;
   	 System.out.println("数组长度：" + arr.length);
执行结果：
           Exception in thread "main" java.lang.NullPointerException
           at com.itheima.demo20.Demo01.main(Demo01.java:8)
    
    
例如：
Scanner sc = new Scanner(System.in);
System.out.println("请输入年龄：");
int age = sc.nextInt()
System.out.println("你的年龄是：" + age);
执行结果：
	请输入年龄：
	呵呵
    	Exception in thread "main" java.util.InputMismatchException
           ......
   	    at com.itheima.demo20.Demo01.main(Demo01.java:9)

上面的三个程序都有一个特点：

编译通过，运行后程序会中断！！
出现这种现象带来的后果：
- 如果是桌面程序，会出现卡死、闪退…等现象；
- 如果是WEB程序，服务器端需要重启，用户无法访问。

异常处理效果演示

Java提供了一种“异常处理机制”，它是一种语法，可以在JVM遇到异常时，“跳过”有异常的代码，使程序继续运行下去
异常处理机制的作用：可以让JVM跳过有异常的代码，继续运行下去！！

Scanner sc = new Scanner(System.in);
System.out.println("请输入年龄：");
try {
    int age = sc.nextInt();
    System.out.println("你的年龄是：" + age);//上一行代码出现异常，这一行代码会跳过，不会被执行
} catch (InputMismatchException e) {
    System.out.println("你的输入有误！");
}

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

jvm如何处理异常呢？？？

当JVM执行，遇到有异常的代码时：

1 JVM会先识别出这个异常
2 然后JVM会到类库，找到描述这个异常的“异常类”，并创建此类对象
3 随后JVM会到代码中查看是否catch(捕获)(之前必须有try)
- 没有：在控制台打印异常信息，然后结束程序！！(没有异常处理机制)
- 有：则将“异常对象”传给catch语句，然后执行catch语句，程序不会被结束！！(有异常处理机制)

在这里插入图片描述

RuntimeException(运行时异常)：通常由程序逻辑引起的异常，程序员应通过良好的编码避免这种异常情况—可防！
除RuntimeException外的其它异常(编译期异常)：由外界原因导致的异常，例如：磁盘坏道、网络中断等—意外！

小结

1. 异常的概念：
      指代码运行时，JVM遇到了无法处理的代码，这种情况称为“异常”。
2. 异常处理的作用：
     通过一些异常处理的语法，可以使JVM在执行到有异常的代码时，跳过这段代码，使程序可以继续运行下去。
3. 常见的几种异常：
     1). NullPointerException：空指针异常
     2). ArrayIndexOutOfBoundsException：数组索引越界异常
     3). InputMismatchException：输入不匹配异常
     4). ArithmeticException ：算术运算异常(整数 / 0)
     5). StringIndexOutOfBoundsException：字符串索引越界 
4. 异常类体系结构：
    Throwable
             |--Error(错误)
             |--Exception(异常)
                       |--RuntimeException：运行时异常
                       |--其它异常：编译期异常

异常捕获

格式

可以catch捕获多个异常
注意：
- 进行多catch异常处理时，父类异常不能放在子类异常的前面

try {
	//可能出现异常的代码;
} catch(要捕获的异常类名 变量名) {
	//出现异常后执行的代码;
} catch(要捕获的异常类名 变量名) {
	//出现异常后执行的代码;
} ....

例子多个异常的捕获

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年龄：");
        //捕获异常
        try {
            int age = sc.nextInt();
            System.out.println("你的年龄是：" + age);//上一行代码出现异常，这一行代码会跳过，不会被执行
            String a = null;
            System.out.println(a.length());

        } catch (NullPointerException e) {
            System.out.println("空指针了");
        } catch (InputMismatchException e) {
            System.out.println("你的输入有误！");
        }
        System.out.println("后续代码...");

    }

例子父类异常不能放在子类异常的前面如下图

在这里插入图片描述

执行流程

第一种情况：try中的代码没有任何异常，那么代码会跳过catch继续向下执行。
第二种情况：try中的代码有异常会从所有catch中对比，如果catch捕获到了这个异常，那么代码会从try直接跳到catch中。
第三种情况：try中的代码有异常但是catch没有捕获到这个异常，这个异常会依旧向外抛

throws声明异常

注意：

如果声明抛出的是“运行时异常”，调用的代码可以不处理，语法上不强制。
如果声明抛出的是“编译期异常”，调用的代码要么使用try_catch，要么使用throws必须处理，否则编译错误。

代码1编译期异常

在这里插入图片描述

代码2运行时异常

在这里插入图片描述

注意

编译时异常：在编译时期必须要进行处理（try…catch或throws）
运行时异常：在编译时期，可以try catch处理，也可以不处理(运用代码逻辑去避免)。

在这里插入图片描述

throw关键字使用

作用：用来手动向外抛出异常。
格式： throw new 异常类名();

代码1

divide中如果传入的b为0，就抛出异常
getStudent中如果传入的age不在范围内，就抛出异常

    public static void main(String[] args) {

        divide(10, 0);
        Student stu = getStudent("zhansgan", 20);
        System.out.println(stu);
    }


    public static int divide(int a, int b) {
        if (b == 0) {
            throw new RuntimeException("除数不能为0");
        }

        return a / b;
    }


    public static Student getStudent(String name, int age) {
        if (age < 0 || age > 150) {
            throw new RuntimeException("age不在范围内");
        }
        return new Student(name, age);
    }

代码2 抛出处理过的异常再次处理

注意在getSum方法内的catch里有一个throw e
这种表示，捕获异常后，把异常抛出，让调用方法的人继续去处理异常

public static void main(String[] args) {
        try {
            int[] arr = {13, 23, 12, 25, 76};
            int sum = getSum(null);
            //int sum = getSum(arr);
            System.out.println("sum = " + sum);
        } catch (Exception e) {
            System.out.println("把异常保存到文件里");
        }
    }
    public static int getSum(int[] arr) {
        int sum = 0;
        try {
            for (int i = 0; i < arr.length; i++) {  //arr.length可能会产生空指针异常
                sum += arr[i];
            }
            return sum;
        } catch (NullPointerException e) {
            System.out.println("空指针");//统一的异常处理方式
            throw e;//把异常对象抛出 希望调用的人也可以处理到这个异常
        } 
    }

代码3 抛出处理过的异常再次处理

在这里插入图片描述

finally代码块

finally代码块的特点：
- finally代码块的内容无论是否出现异常，都会执行。它通常用于方法中，
- 当try以及catch中需要return值或者抛出异常的时候
格式：

try {
    【A】可能会出现异常的代码
} catch(要捕获的异常类名 变量名) {
    【B】出现异常后执行的代码
} finally {
    【C】一定会执行的代码
}

代码

下面的代码虽然有return和throw e，但是finally里的代码始终都会执行
注意如果再finally里写里的return，try里的return和catch里的throw e就不执行了

执行流程（【A】【B】【C】看上面的格式）

第一种情况：如果try中的代码没有异常，执行流程为【A】【C】
第二种情况：如果try中的代码有异常，并且catch捕获到了这个异常，执行流程为【A】【B】【C】
第三种情况：如果try中的代码有异常，但是catch没有捕获到这个异常，执行流程为【A】【C】向外抛出异常

    public static void main(String[] args) {
        try {
            int[] arr = {13, 23, 12, 25, 76};
            int sum = getSum(null);
            //int sum = getSum(arr);
            System.out.println("sum = " + sum);
        } catch (Exception e) {
            System.out.println("把异常保存到文件里");
        }
    }


    public static int getSum(int[] arr) {
        int sum = 0;
        try {
            for (int i = 0; i < arr.length; i++) {  //arr.length可能会产生空指针异常
                sum += arr[i];
            }
            //return sum;
        } catch (NullPointerException e) {
            System.out.println("空指针");//统一的异常处理方式
            throw e;//把异常对象抛出 希望调用的人也可以处理到这个异常
        } finally {
            System.out.println("方法执行完毕，时间：" + System.currentTimeMillis());
        }
    }

异常的常见方法

public String getMessage() 返回此 throwable 的详细消息字符串
public String toString() 返回此可抛出的简短描述
public void printStackTrace() 把异常的错误信息输出在控制台(字体为红色的)

代码

注意printStackTrace异常的错误信息为红色

    public static void main(String[] args) {
        int index = 10;
        test(index);
    }

    public static void test(int index) {

        try {
            int[] arr = {1, 2, 3, 4, 5};
            //虚拟机帮我们创建了一个异常对象 new ArrayIndexOutOfBoundsException();
            System.out.println(arr[index]);
        } catch (ArrayIndexOutOfBoundsException e) {
            //System.out.println("有越界");
            e.printStackTrace();
            System.out.println(e.toString());
            System.out.println(e.getMessage());
        }
        System.out.println("嘿嘿嘿");
    }

自定义异常

我们之前用的异常很多都是Java中定义好的，在真正开发中，有很多在JDK中没有定义的异常，比如年龄异常，分数异常等等，如果使用这样的异常，那么就需要我们自己定义了。
一般自定义异常会继承Exception,目的是让大家必须去处理

代码

类AgeException继承Exception 是编译期异常
注意如果需要传入异常描述，需要要写构造方法

public class AgeException extends Exception {
    public AgeException(String message) {
        super(message);
    }
}

测试

public class Demo01 {
    public static void main(String[] args) {
        try {
            test(-2);
        } catch (AgeException e) {
            e.printStackTrace();
        }
    }
    public static void test(int age) throws AgeException{
        if (age < 0)
            throw new AgeException("年龄异常");
    }
}

小结

1. 异常处理的基本语句？
            try{
                 ...
            }catch(异常类型名 变量名){
                 ...
            }
2. 多catch语句？
           try{
                 ...
            }catch(异常类型名1 变量名){
                 ...
            } catch(异常类型名2 变量名){
                 ...
            }
3. finally语句？
           try{
                 ...
                 return xxx;
            }catch(异常类型名1 变量名){
                 ...
                 return xxx;
            } finally{
                 //无论是否出现异常，都会被执行的代码
            }
4. throws：方法声明处，声明抛出异常？
5. throw：方法内部，抛出一个异常对象？
6. Throwable中的常用方法？
      1.getMessage()：获取异常信息
      2. toString()：异常类名 + 异常信息(如果有)
      3. printStackTrace()：打印异常详细信息

经验总结

1 编译期异常 必须处理  如果是在方法中，那么就看这个方法是写业务逻辑的还是工具型的被别人调用的
	1.1如果是写业务逻辑的，那么直接trycatch捕获
	1.2 如果是工具型的被别人调用的，那么直接throws声明，也可以捕获后，catch中再throw抛出，交给调用的程序员去处理这个异常
	
2 运行时异常 一般像空指针 越界这种异常，很多是因为自己的代码不够严谨导致，需要自己处理代码的逻辑bug，很少去捕获

3 一般公司中都会有自己规范的自定义异常的方式，要写详细的文档和注释。

4一般自定义异常会继承Exception,目的是让大家必须去处理