后端学习第二周

总结：
感悟：
经过这几天后端的学习（主要是java基础和算法），感悟很深，一是java要学的东西很多，很难记忆，二是蓝桥杯算法题有的题很难，比如粘木棍，跳马涉及到了动态规划，如果没有经过系统性的算法学习很难求解，以后还是有很长的路要走。

本周学习的主要内容:
1,异常处理和抛出。
2，File类和字节流。
3，Java全排列。
下周计划：
1，学习完I/O;
2，复习面向对象和集合相关知识。
3,学习动态规划。
本周知识点总结
一，异常处理
异常是程序在编译或执行的过程中可能出现的问题，语法错误不算在异常体系。

1，异常类的继承体系：

Error：

系统级别问题、JVM退出等，代码无法控制

Exception：

Java.lang包下，称为异常类，它表示程序本身可以处理的问题

Runtime Exception及其子类：

运行时异常，编译阶段不会报错（如空指针，数组索引越界异常）

除Runtime Exception之外所有异常：

编译时异常，编译期必须处理的，否则程序不能通过编译（如日期格式化）

2，异常类别：
运行时异常：

public class testThrows{
    public static void main(String[] args) {
        int n=10/0;
        System.out.println(n);
    }
}
这个代码编译时没有报错，运行时会报错。

编译时异常：编译时报错，必须处理

3，异常处理
1. throws
添加throws ***到方法签名

规范写法throws Exception

将方法内部出现的异常抛给本方法调用者

throws仅仅是将函数中可能出现的异常向调用者声明，而自己则不具体处理。

throws声明：如果一个方法内部的代码会抛出检查异常（checked exception），而方法自己又没有完全处理掉或并不能确定如何处理这种异常，则javac保证你必须在方法的签名上使用throws关键字声明这些可能抛出的异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理，否则编译不通过。

public static void main(String[] args) throws ParseException {
    parseTime("2022-02-25 20:20:20");
    }
 
    public static void parseTime(String data) throws ParseException {
 
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        Date d = sdf.parse(data);
}
2,try . . . catch . . .
try...catch 可以测试代码中的错误。try 部分包含需要运行的代码，而catch 部分包含错误发生时运行的代码。

　　　　java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。基本过程是用try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理；　

public static void main(String[] args)  {
parseTime("2022-02-25 20:20:20");
}
 
public static void parseTime(String data)  {
 
    try {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
        Date d = sdf.parse(data);
    } catch (ParseException e) {
        throw new RuntimeException(e);
    }
}
3,两者结合
public static void main(String[] args)  {
    try {
        parseTime("2022-02-25 20:20:20");
        System.out.println("成功");
    } catch (ParseException e) {
        e.printStackTrace();
        System.out.println("失败");
    }
}
 
public static void parseTime(String data) throws ParseException {
 
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-mm-dd HH:mm:ss");
    Date d = sdf.parse(data);
 
}
4，自定义异常类
在程序中使用自定义异常类，大体可以分为以下步骤：

1，创建自定义异常类

2，在方法中通过throw关键字抛出异常对象

3，如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一次操作

4，在出现异常方法的调用者中捕获并处理异常

class DivException extends Exception{
    public DivException(){
        
        super();
    }
    public DivException(String message){
        
        super(message);
    }
}
public class testThrow {
    public static int div(int a,int b)throws DivException{
        if (b==0){
            throw new DivException("除数不能为0");
        }
        return a/b;
    }
 
    public static void main(String[] args) {
        try{
            int n=div(10,0);
            System.out.println(n);
        }catch (DivException e){
            System.out.println(e.getMessage());
        }
    }
二，全排列
一般地说，从n个不同元素中，任取m(m≤n)个元素，按照一定的顺序排成一列，这就叫做从n个元素中取出m个元素的一个排列。

当m=n时，便称为全排列。

基本思想：
把待全排列记录分为两个部分：

（1） 第一个记录

（2） 剩下的所有元素

所有记录的全排列就是所有可能出现在第一个位置的记录与剩下所有元素的全排列。

以[1,2,3]为例，

1,2,3的全排列可以看作是

1,[2,3的全排列]

[2,3]的全排列又可以看作是

2,[3的全排列]—————对应123

3,[2的全排列]—————对应132

可见全排列的主要思想是递归。

public class Main {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4 };
        fullSort(arr, 0, arr.length - 1);
    }
 
    public static void fullSort(int[] arr, int start, int end) {
        // 递归终止条件
        if (start == end) {
            for (int i : arr) {
                System.out.print(i);
            }
            System.out.println();
            return;
        }
        for (int i = start; i <= end; i++) {
            swap(arr, i, start);
            fullSort(arr, start + 1, end);
            swap(arr, i, start);
        }
    }
 
    private static void swap(int[] arr, int i, int j) {
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }