java进阶教程：2023.3.14第十六天，java进阶不可变集合、Stream、异常

前言

记录时间：2023.3.14

已坚持的第十六天

java从入门到精通

学习java时间历程记录打卡

早上6：00到 12：00

下午1：00到 7：00

完成代码练习

d1_unchange_collection

1.不可变的集合

package cn.vqqc.d1_unchange_collection;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 目标：不可变集合
 */
public class CollectionDemo {
    public static void main(String[] args) {
        // 1、不可变的List集合
        List<Double> lists = List.of(569.5, 700.5, 523.0,  570.5);
        // lists.add(689.0);
        // lists.set(2, 698.5);
        // System.out.println(lists);
        double score = lists.get(1);
        System.out.println(score);

        // 2、不可变的Set集合
        Set<String> names = Set.of("小明", "小黄", "小红", "小王" );
        // names.add("三少爷");
        System.out.println(names);

        // 3、不可变的Map集合
        Map<String, Integer> maps = Map.of("huawei",2, "Java开发", 1 , "手表", 1);
        // maps.put("衣服", 3);
        System.out.println(maps);
    }
}

d2_stream

1.定义类

package cn.vqqc.d2_stream;

public class Employee {
    private String name;
    private char sex;
    private double salary;
    private double bonus;
    private String punish; // 处罚信息

    public Employee(){
    }

    public Employee(String name, char sex, double salary, double bonus, String punish) {
        this.name = name;
        this.sex = sex;
        this.salary = salary;
        this.bonus = bonus;
        this.punish = punish;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    public String getPunish() {
        return punish;
    }

    public void setPunish(String punish) {
        this.punish = punish;
    }

    public double getTotalSalay(){
        return salary * 12 + bonus;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", punish='" + punish + '\'' +
                '}'+"\n";
    }
}

2.Stream流的获取

package cn.vqqc.d2_stream;

import java.util.*;
import java.util.stream.Stream;

/**
 目标：Stream流的获取

 Stream流式思想的核心：
 是先得到集合或者数组的Stream流（就是一根传送带）
 然后就用这个Stream流操作集合或者数组的元素。
 然后用Stream流简化替代集合操作的API.

 集合获取流的API:
 (1) default Stream<E> stream();

 小结：
 集合获取Stream流用: stream();
 数组：Arrays.stream(数组)   /  Stream.of(数组);
 */
public class StreamDemo02 {
    public static void main(String[] args) {
        /** --------------------Collection集合获取流-------------------------------   */
        Collection<String> list = new ArrayList<>();
        Stream<String> s =  list.stream();

        /** --------------------Map集合获取流-------------------------------   */
        Map<String, Integer> maps = new HashMap<>();
        // 键流
        Stream<String> keyStream = maps.keySet().stream();
        // 值流
        Stream<Integer> valueStream = maps.values().stream();
        // 键值对流（拿整体）
        Stream<Map.Entry<String,Integer>> keyAndValueStream =  maps.entrySet().stream();

        /** ---------------------数组获取流------------------------------   */
        String[] names = {"赵敏","小昭","灭绝","周芷若"};
        Stream<String> nameStream = Arrays.stream(names);
        Stream<String> nameStream2 = Stream.of(names);
    }
}

3.Stream流的常用API

package cn.vqqc.d2_stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

/**
 目标：Stream流的常用API
 forEach : 逐一处理(遍历)
 count：统计个数
 -- long count();
 filter : 过滤元素
 -- Stream<T> filter(Predicate<? super T> predicate)
 limit : 取前几个元素
 skip : 跳过前几个
 map : 加工方法
 concat : 合并流。
 */
public class StreamDemo03 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        // Stream<T> filter(Predicate<? super T> predicate)
        list.stream().filter(s -> s.startsWith("张")).forEach(s -> System.out.println(s));

        long size = list.stream().filter(s -> s.length() == 3).count();
        System.out.println(size);

        // list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(s -> System.out.println(s));
        list.stream().filter(s -> s.startsWith("张")).limit(2).forEach(System.out::println);

        list.stream().filter(s -> s.startsWith("张")).skip(2).forEach(System.out::println);

        // map加工方法: 第一个参数原材料  -> 第二个参数是加工后的结果。
        // 给集合元素的前面都加上一个
        list.stream().map(s -> "学生：" + s).forEach(a -> System.out.println(a));

        // 需求：把所有的名称 都加工成一个学生对象。
        list.stream().map(s -> new Student(s)).forEach(s -> System.out.println(s));
//        list.stream().map(Student::new).forEach(System.out::println); // 构造器引用  方法引用

        // 合并流。
        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        Stream<String> s2 = Stream.of("java1", "java2");
        // public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
        Stream<String> s3 = Stream.concat(s1 , s2);
        s3.distinct().forEach(s -> System.out.println(s));
    }
}

4.求平均工资案例

package cn.vqqc.d2_stream;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
public class StreamDemo04 {
    public static double allMoney ;
    public static double allMoney2 ; // 2个部门去掉最高工资，最低工资的总和
    public static void main(String[] args) {
        List<Employee> one = new ArrayList<>();
        one.add(new Employee("猪八戒",'男',30000 , 25000, null));
        one.add(new Employee("孙悟空",'男',25000 , 1000, "顶撞上司"));
        one.add(new Employee("沙僧",'男',20000 , 20000, null));
        one.add(new Employee("小白龙",'男',20000 , 25000, null));

        List<Employee> two = new ArrayList<>();
        two.add(new Employee("武松",'男',15000 , 9000, null));
        two.add(new Employee("李逵",'男',20000 , 10000, null));
        two.add(new Employee("西门庆",'男',50000 , 100000, "被打"));
        two.add(new Employee("潘金莲",'女',3500 , 1000, "被打"));
        two.add(new Employee("武大郎",'女',20000 , 0, "下毒"));

        // 1、开发一部的最高工资的员工。（API）
        // 指定大小规则了
//        Employee e = one.stream().max((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(),  e2.getSalary() + e2.getBonus()))
//                .get();
//       System.out.println(e);
        Topperformer t = one.stream().max((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(),  e2.getSalary() + e2.getBonus()))
                .map(e -> new Topperformer(e.getName(),  e.getSalary() + e.getBonus())).get();
        System.out.println(t);

        // 2、统计平均工资，去掉最高工资和最低工资
        one.stream().sorted((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(),  e2.getSalary() + e2.getBonus()))
                .skip(1).limit(one.size() - 2).forEach(e -> {
                    // 求出总和：剩余员工的工资总和
                    allMoney += (e.getSalary() + e.getBonus());
                });
        System.out.println("开发一部的平均工资是：" + allMoney / (one.size() - 2));

        // 3、合并2个集合流，再统计
        Stream<Employee> s1 = one.stream();
        Stream<Employee> s2 = two.stream();
        Stream<Employee> s3 = Stream.concat(s1 , s2);
        s3.sorted((e1, e2) -> Double.compare(e1.getSalary() + e1.getBonus(),  e2.getSalary() + e2.getBonus()))
                .skip(1).limit(one.size() + two.size() - 2).forEach(e -> {
                    // 求出总和：剩余员工的工资总和
                    allMoney2 += (e.getSalary() + e.getBonus());
                });

        // BigDecimal
        BigDecimal a = BigDecimal.valueOf(allMoney2);
        BigDecimal b = BigDecimal.valueOf(one.size()  + two.size() - 2);
        System.out.println("开发部的平均工资是：" + a.divide(b,2, RoundingMode.HALF_UP));
    }
}

5.收集Stream流的数据到集合或者数组中去

package cn.vqqc.d2_stream;

import java.util.*;
import java.util.function.IntFunction;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 目标：收集Stream流的数据到 集合或者数组中去
 */
public class StreamDemo05 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        list.add("张无忌");
        list.add("周芷若");
        list.add("赵敏");
        list.add("张强");
        list.add("张三丰");
        list.add("张三丰");

        Stream<String> s1 = list.stream().filter(s -> s.startsWith("张"));
        List<String> zhangList = s1.collect(Collectors.toList()); // 可变集合
        zhangList.add("java1");
        System.out.println(zhangList);

//       List<String> list1 = s1.toList(); // 得到不可变集合
//       list1.add("java");
//       System.out.println(list1);

        // 注意注意注意：“流只能使用一次”
        Stream<String> s2 = list.stream().filter(s -> s.startsWith("张"));
        Set<String> zhangSet = s2.collect(Collectors.toSet());
        System.out.println(zhangSet);

        Stream<String> s3 = list.stream().filter(s -> s.startsWith("张"));
//         Object[] arrs = s3.toArray();
        String[] arrs = s3.toArray(String[]::new); // 可以不管，拓展一下思维！！
        System.out.println("Arrays数组内容：" + Arrays.toString(arrs));

    }
}

6.初步体验Stream流的方便与快捷

package cn.vqqc.d2_stream;

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

/**
 目标：初步体验Stream流的方便与快捷
 */
public class StreamTest {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        Collections.addAll(names, "张三丰","张无忌","周芷若","赵敏","张强");
        System.out.println(names);
//
//        // 1、从集合中找出姓张的放到新集合
//        List<String> zhangList = new ArrayList<>();
//        for (String name : names) {
//            if(name.startsWith("张")){
//                zhangList.add(name);
//            }
//        }
//        System.out.println(zhangList);
//
//        // 2、找名称长度是3的姓名
//        List<String> zhangThreeList = new ArrayList<>();
//        for (String name : zhangList) {
//            if(name.length() == 3){
//                zhangThreeList.add(name);
//            }
//        }
//        System.out.println(zhangThreeList);

        // 3、使用Stream实现的
        names.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
    }
}

7.定义类

package cn.vqqc.d2_stream;

public class Student {
    private String name;

    public Student() {
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                '}';
    }
}

8.定义类

package cn.vqqc.d2_stream;

public class Topperformer {
    private String name;
    private double money; // 月薪

    public Topperformer() {
    }

    public Topperformer(String name, double money) {
        this.name = name;
        this.money = money;
    }

    public String getName() {
        return name;
    }

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

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Topperformer{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

d3_exception

1.异常的概念和体系

package cn.vqqc.d3_exception;

/**
 目标：异常的概念和体系

 什么是异常？
 异常是程序在"编译"或者"执行"的过程中可能出现的问题。
 异常是应该尽量提前避免的。
 异常可能也是无法做到绝对避免的，异常可能有太多情况了，开发中只能提前干预！！
 异常一旦出现了，如果没有提前处理，程序就会退出JVM虚拟机而终止，开发中异常是需要提前处理的。

 研究异常并且避免异常，然后提前处理异常，体现的是程序的安全, 健壮性！！！
 Java会为常见的代码异常都设计一个类来代表。

 异常的体系:
 Java中异常继承的根类是：Throwable。

 Throwable(根类，不是异常类)
 /              \
 Error           Exception（异常，需要研究和处理）
 /            \
 编译时异常      RuntimeException(运行时异常)


 Error : 错误的意思，严重错误Error，无法通过处理的错误，一旦出现，程序员无能为力了，
 只能重启系统，优化项目。
 比如内存奔溃，JVM本身的奔溃。这个程序员无需理会。

 Exception:才是异常类，它才是开发中代码在编译或者执行的过程中可能出现的错误，
 它是需要提前处理的。以便程序更健壮！

 Exception异常的分类:
 1.编译时异常：继承自Exception的异常或者其子类，编译阶段就会报错，
 必须程序员处理的。否则代码编译就不能通过！！

 2.运行时异常: 继承自RuntimeException的异常或者其子类，编译阶段是不会出错的，它是在
 运行时阶段可能出现，运行时异常可以处理也可以不处理，编译阶段是不会出错的，
 但是运行阶段可能出现，还是建议提前处理！！
 小结：
 异常是程序在编译或者运行的过程中可能出现的错误！！
 异常分为2类：编译时异常，运行时异常。
 -- 编译时异常：继承了Exception,编译阶段就报错，必须处理，否则代码不通过。
 -- 运行时异常：继承了RuntimeException,编译阶段不会报错，运行时才可能出现。
 异常一旦真的出现，程序会终止，所以要研究异常，避免异常，处理异常，程序更健壮!!
 */
public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr = {10, 20, 40};
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println("-----------程序截止---------");
    }
}

d4_exception_runtimeException

1.常见的运行时异常

package cn.vqqc.d4_exception_runtimeException;

/**
 拓展: 常见的运行时异常。（面试题）
 运行时异常的概念:
 继承自RuntimeException的异常或者其子类，
 编译阶段是不会出错的，它是在运行时阶段可能出现的错误，
 运行时异常编译阶段可以处理也可以不处理,代码编译都能通过！！

 1.数组索引越界异常: ArrayIndexOutOfBoundsException。
 2.空指针异常 : NullPointerException。
 直接输出没有问题。但是调用空指针的变量的功能就会报错！！
 3.类型转换异常：ClassCastException。
 4.迭代器遍历没有此元素异常：NoSuchElementException。
 5.数学操作异常：ArithmeticException。
 6.数字转换异常： NumberFormatException。

 小结：
 运行时异常继承了RuntimeException ,编译阶段不报错，运行时才可能会出现错误!
 */
public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。。。");
        /** 1.数组索引越界异常: ArrayIndexOutOfBoundsException。*/
        int[] arr = {1, 2, 3};
        System.out.println(arr[2]);
        // System.out.println(arr[3]); // 运行出错，程序终止

        /** 2.空指针异常 : NullPointerException。直接输出没有问题。但是调用空指针的变量的功能就会报错！！ */
        String name = null;
        System.out.println(name); // null
        // System.out.println(name.length()); // 运行出错，程序终止

        /** 3.类型转换异常：ClassCastException。 */
        Object o = 23;
        // String s = (String) o;  // 运行出错，程序终止

        /** 5.数学操作异常：ArithmeticException。 */
        //int c = 10 / 0;

        /** 6.数字转换异常： NumberFormatException。 */
        //String number = "23";
        String number = "23aabbc";
        Integer it = Integer.valueOf(number); // 运行出错，程序终止
        System.out.println(it + 1);

        System.out.println("程序结束。。。。。");
    }
}

d5_exception_javac

1.常见的编译时异常认识

package cn.vqqc.d5_exception_javac;

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

/**
 目标：常见的编译时异常认识

 编译时异常：继承自Exception的异常或者其子类，没有继承RuntimeException
 "编译时异常是编译阶段就会报错"，
 必须程序员编译阶段就处理的。否则代码编译就报错！！

 编译时异常的作用是什么：
 是担心程序员的技术不行，在编译阶段就爆出一个错误, 目的在于提醒!
 提醒程序员这里很可能出错，请检查并注意不要出bug。
 编译时异常是可遇不可求。遇到了就遇到了呗。

 了解:
 */
public class ExceptionDemo {
    public static void main(String[] args) throws ParseException {
        String date = "2015-01-12 10:23:21";
        // 创建一个简单日期格式化类：
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
        // 解析字符串时间成为日期对象
        Date d = sdf.parse(date);
        //
        System.out.println(d);
    }
}

d6_exception_default

1.异常的产生默认的处理过程解析

package cn.vqqc.d6_exception_default;

/**
 目标：异常的产生默认的处理过程解析。(自动处理的过程！)
 （1）默认会在出现异常的代码那里自动的创建一个异常对象：ArithmeticException。
 （2）异常会从方法中出现的点这里抛出给调用者，调用者最终抛出给JVM虚拟机。
 （3）虚拟机接收到异常对象后，先在控制台直接输出异常栈信息数据。
 （4）直接从当前执行的异常点干掉当前程序。
 （5）后续代码没有机会执行了，因为程序已经死亡。

 小结：
 异常一旦出现，会自动创建异常对象，最终抛出给虚拟机，虚拟机
 只要收到异常，就直接输出异常信息，干掉程序！！

 默认的异常处理机制并不好，一旦真的出现异常，程序立即死亡！
 */
public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。。。。。。。");
        chu(10, 0);
        System.out.println("程序结束。。。。。。。。。。");
    }

    public static void chu(int a , int b){
        System.out.println(a);
        System.out.println(b);
        int c = a / b;
        System.out.println(c);
    }
}

d7_exception_handle

1.编译时异常的处理方式一

package cn.vqqc.d7_exception_handle;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 目标：编译时异常的处理方式一。

 编译时异常：编译阶段就会报错，一定需要程序员处理的，否则代码无法通过！！

 抛出异常格式：
 方法 throws 异常1 ,  异常2 , ..{

 }
 建议抛出异常的方式：代表可以抛出一切异常，
 方法 throws Exception{

 }

 方式一：
 在出现编译时异常的地方层层把异常抛出去给调用者，调用者最终抛出给JVM虚拟机。
 JVM虚拟机输出异常信息，直接干掉程序，这种方式与默认方式是一样的。
 虽然可以解决代码编译时的错误，但是一旦运行时真的出现异常，程序还是会立即死亡！
 这种方式并不好!

 小结：
 方式一出现异常层层跑出给虚拟机，最终程序如果真的出现异常，程序还是立即死亡！这种方式不好！

 */
public class ExceptionDemo01 {

//    public static void main(String[] args) throws ParseException, FileNotFoundException {
//        System.out.println("程序开始。。。。。");
//        parseTime("2011-11-11 11:11:11");
//        System.out.println("程序结束。。。。。");
//    }
//
//    public static void parseTime(String date) throws ParseException, FileNotFoundException {
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
//        Date d = sdf.parse(date);
//        System.out.println(d);
//
//        InputStream is = new FileInputStream("E:/meinv.jpg");
//    }

    public static void main(String[] args) throws Exception {
        System.out.println("程序开始。。。。。");
        parseTime("2011-11-11 11:11:11");
        System.out.println("程序结束。。。。。");
    }

    public static void parseTime(String date) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);

        InputStream is = new FileInputStream("E:/meinv.jpg");
    }

}

2.编译时异常的处理方式二

package cn.vqqc.d7_exception_handle;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 目标：编译时异常的处理方式二。

 方式二：在出现异常的地方自己处理，谁出现谁处理。

 自己捕获异常和处理异常的格式：捕获处理
 try{
 // 监视可能出现异常的代码！
 }catch(异常类型1 变量){
 // 处理异常
 }catch(异常类型2 变量){
 // 处理异常
 }...

 监视捕获处理异常企业级写法：
 try{
 // 可能出现异常的代码！
 }catch (Exception e){
 e.printStackTrace(); // 直接打印异常栈信息
 }
 Exception可以捕获处理一切异常类型！

 小结：
 第二种方式，可以处理异常，并且出现异常后代码也不会死亡。
 这种方案还是可以的。
 但是从理论上来说，这种方式不是最好的，上层调用者不能直接知道底层的执行情况！

 */
public class ExceptionDemo02 {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。");
        parseTime("2011-11-11 11:11:11");
        System.out.println("程序结束。。。。");
    }

    public static void parseTime(String date) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
            Date d = sdf.parse(date);
            System.out.println(d);

            InputStream is = new FileInputStream("E:/meinv.jpg");
        } catch (Exception e) {
            e.printStackTrace(); // 打印异常栈信息
        }
    }


//    public static void parseTime(String date) {
//        try {
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
//            Date d = sdf.parse(date);
//            System.out.println(d);
//
//            InputStream is = new FileInputStream("E:/meinv.jpg");
//        } catch (FileNotFoundException|ParseException e) {
//            e.printStackTrace(); // 打印异常栈信息
//        }
//    }

//    public static void parseTime(String date) {
//        try {
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
//            Date d = sdf.parse(date);
//            System.out.println(d);
//
//            InputStream is = new FileInputStream("E:/meinv.jpg");
//        } catch (FileNotFoundException e) {
//           e.printStackTrace(); // 打印异常栈信息
//        } catch (ParseException e) {
//           e.printStackTrace();
//        }
//    }

//    public static void parseTime(String date) {
//        try {
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
//            Date d = sdf.parse(date);
//            System.out.println(d);
//        } catch (ParseException e) {
//            // 解析出现问题
//            System.out.println("出现了解析时间异常哦，走点心！！");
//        }
//
//        try {
//            InputStream is = new FileInputStream("E:/meinv.jpg");
//        } catch (FileNotFoundException e) {
//            System.out.println("您的文件根本就没有啊，不要骗我哦！！");
//        }
//    }
}

3.编译时异常的处理方式三

package cn.vqqc.d7_exception_handle;

import java.io.FileInputStream;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 目标：编译时异常的处理方式三。

 方式三： 在出现异常的地方把异常一层一层的抛出给最外层调用者，
 最外层调用者集中捕获处理！！（规范做法）

 小结：
 编译时异常的处理方式三：底层出现的异常抛出给最外层调用者集中捕获处理。
 这种方案最外层调用者可以知道底层执行的情况，同时程序在出现异常后也不会立即死亡，这是
 理论上最好的方案。

 虽然异常有三种处理方式，但是开发中只要能解决你的问题，每种方式都又可能用到!!
 */
public class ExceptionDemo03 {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。");
        try {
            parseTime("2011-11-11 11:11:11");
            System.out.println("功能操作成功~~~");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("功能操作失败~~~");
        }
        System.out.println("程序结束。。。。");
    }

    public static void parseTime(String date) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy、MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);

        InputStream is = new FileInputStream("D:/meinv.jpg");
    }

}

d8_exception_handle_runtime

1.运行时异常的处理机制

package cn.vqqc.d8_exception_handle_runtime;

/**
 目标：运行时异常的处理机制

 可以不处理，编译阶段又不报错
 按照理论规则：建议还是处理，只需要在最外层捕获处理即可
 */
public class Test1 {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。。。。。。。");
        try {
            chu(10, 0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("程序结束。。。。。。。。。。");
    }

    public static void chu(int a , int b) { // throws RuntimeException{
        System.out.println(a);
        System.out.println(b);
        int c = a / b;
        System.out.println(c);
    }
}

2.需要输入一个合法的价格为止要求价格大于 0

package cn.vqqc.d8_exception_handle_runtime;

import java.util.Scanner;

/**
 需求：需要输入一个合法的价格为止 要求价格大于 0
 */
public class Test2 {
    public static void main(String[] args) {
        Scanner sc  = new Scanner(System.in);
        while (true) {
            try {
                System.out.println("请您输入合法的价格：");
                String priceStr = sc.nextLine();
                // 转换成double类型的价格
                double price = Double.valueOf(priceStr);

                // 判断价格是否大于 0
                if(price > 0) {
                    System.out.println("定价：" + price);
                    break;
                }else {
                    System.out.println("价格必须是正数~~~");
                }
            } catch (Exception e) {
                System.out.println("用户输入的数据有毛病，请您输入合法的数值，建议为正数~~");
            }
        }
    }
}

d9_exception_custom

1.自定义异常(了解)

package cn.vqqc.d9_exception_custom;

/**
 目标:自定义异常(了解)

 引入:Java已经为开发中可能出现的异常都设计了一个类来代表.
 但是实际开发中,异常可能有无数种情况,Java无法为
 这个世界上所有的异常都定义一个代表类。
 假如一个企业如果想为自己认为的某种业务问题定义成一个异常
 就需要自己来自定义异常类.

 需求：认为年龄小于0岁，大于200岁就是一个异常。

 自定义异常:
 自定义编译时异常.
 a.定义一个异常类继承Exception.
 b.重写构造器。
 c.在出现异常的地方用throw new 自定义对象抛出!
 编译时异常是编译阶段就报错，提醒更加强烈，一定需要处理！！

 自定义运行时异常.
 a.定义一个异常类继承RuntimeException.
 b.重写构造器。
 c.在出现异常的地方用throw new 自定义对象抛出!
 提醒不强烈，编译阶段不报错！！运行时才可能出现！！

 */
public class ExceptionDemo {
    public static void main(String[] args) {
//        try {
//            checkAge(-34);
//        } catch (VqqcAgeIlleagalException e) {
//            e.printStackTrace();
//        }

        try {
            checkAge2(23);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void checkAge2(int age)  {
        if(age < 0 || age > 200){
            // 抛出去一个异常对象给调用者
            // throw ：在方法内部直接创建一个异常对象，并从此点抛出
            // throws : 用在方法申明上的，抛出方法内部的异常
            throw new VqqcAgeIlleagalRuntimeException(age + " is illeagal!");
        }else {
            System.out.println("年龄合法：推荐商品给其购买");
        }
    }

    public static void checkAge(int age) throws VqqcAgeIlleagalException {
        if(age < 0 || age > 200){
            // 抛出去一个异常对象给调用者
            // throw ：在方法内部直接创建一个异常对象，并从此点抛出
            // throws : 用在方法申明上的，抛出方法内部的异常
            throw new VqqcAgeIlleagalException(age + " is illeagal!");
        }else {
            System.out.println("年龄合法：推荐商品给其购买");
        }
    }
}

2.自定义的编译时异常

package cn.vqqc.d9_exception_custom;

/**
 自定义的编译时异常
 1、继承Exception
 2、重写构造器
 */
public class VqqcAgeIlleagalException extends Exception{
    public VqqcAgeIlleagalException() {
    }

    public VqqcAgeIlleagalException(String message) {
        super(message);
    }
}

3.自定义的编译时异常

package cn.vqqc.d9_exception_custom;

/**
 自定义的编译时异常
 1、继承RuntimeException
 2、重写构造器
 */
public class VqqcAgeIlleagalRuntimeException extends RuntimeException{
    public VqqcAgeIlleagalRuntimeException() {
    }

    public VqqcAgeIlleagalRuntimeException(String message) {
        super(message);
    }
}