axios上传文件报400

IO流

概述

IO流，又叫输入输出流，当我们将内存中的数据写到硬盘上时，这个过程叫输出流（Output),当我们将硬盘上的数据读取到内存中时，叫做输入流（Input）。流本身是一个抽象概念，是 对数据传输的总称，也就是说，数据在设备键的传输，叫做流

重点：

明确操作是读还是写

使用何种类型的流

铺垫技术：

学习IO流之前，我们需要学习两个铺垫技术：一个是异常，一个是File类

**异常：**因为在介质传输数据会有很多问题，比如：找不到文件，文件格式错误，读写错误，我们需要知道当进入到这些问题时，如何去处理

**File：**流的操作会涉及很多的文件操作，所以我们也要学习与文件相关的类—File类

异常：

**概述：**程序出现 不正常的情况

分类：

程序异常：Throwable Throwable 类是 Java 语言中所有错误或异常的父类

严重问题----Error：我们不去处理，因为处理不了，比如：内存溢出问题

一般问题----Exception：

编译时异常:除了RuntimeException的异常都是编译时异常，这种异常必须在程序执行前进行处理。

运行时异常：RuntimeException，这个问题我们也不做处理。因为造成的原因多数是我们的逻辑不够严谨，需要我们去修改代码
案例：

public class ExceptionDemo {
    public static void main(String[] args) {
        //第一模块
        int a = 10;
        int b = 0;
        System.out.println(a / b);

        System.out.println("我是第二模块");
    }
}

分析：

程序出现问题后，控制台打印错误信息：包括Exception包名+类名，错误的描述，错误出现的位置。这些对于异常的操作我们并没有做，而是JVM替我们做的。

所以，当我们不做任何异常处理时，我们的JVM会对异常执行一个默认的操作

异常处理：

方式：

try…catch…finally

throws

try…catch…finally

格式：

try{
    //可能出现问题的代码
}catch(异常类名 变量名){
    
    //针对异常的处理
    
    
    
}finally{
    
    //释放资源
    //它不是必须
    
}

**注意：

1.try里面包裹的代码越少越好，因为被try包裹的代码在执行时需要走异常处理机制，需要JVM给该机制分配额外的资源去管理代码，所以包裹越少，越节省资源

2.catch中必须有对异常的处理，哪怕时一句输出语句也可以，因为不做任何处理的话，相当于把异常隐藏了，而不是处理了

3.try结构中的语句，一但捕获到异常，剩下的代码不再执行，直接执行catch的代码

示例:

/**
 * 多个异常的处理
 */
public class ExceptionDemo2 {
    public static void main(String[] args) {
        method();
        System.out.println("程序执行完毕");
    }

    private static void method() {
        int a = 10;
        int b = 0;
        try {
           //System.out.println(a / b);
            int[] c = {1, 2, 3};
            System.out.println(c[4]);
        } catch (ArithmeticException arithmeticException) {
            System.out.println("除数不能为0");
           // arithmeticException.printStackTrace();
        } catch (ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException) {
            System.out.println("数组越界了" );
        }


    }
}

/**
 * 多个异常的处理
 */
public class ExceptionA {
    public static void main(String[] args) {
        method();
        System.out.println("程序执行完毕");

    }
     //多个try...catch
    public static void method() {
        int a = 10;
        int b = 0;
        try {
            System.out.println(a / b);

        } catch (ArithmeticException arithmeticException) {
            System.out.println("除数不能为0!");

        }

        try {
            int[] c = {1, 2, 3};
            System.out.println(c[4]);

        } catch (ArrayIndexOutOfBoundsException arrayIndexOutOfBoundsException) {
            System.out.println("出错了");
        }
    }
}

处理方式：

1.一个try，多个catch

a.如果异常类在继承体系结构中处于平级关系，他们呢的前后不影响执行结果

b.如果异常在继承体系结构中处于父子关系，则父类异常必须写在后面，否则子类异常不会被正常匹配到

2.多个try…catch

3.一个try…catch，catch中的类可以写Exception类，它可以用来匹配所有子类异常

JDK7新特性–异常处理

格式：

try{
    //可能出现异常的代码
}catch(异常1 |异常2|...变量名){
    //异常处理
}

public class ExceptionDemo3 {
    public static void main(String[] args) {
         method();
        System.out.println("程序结束");
    }

    private static void method() {
        int a = 10;
        int b = 0;
        int[] c = {1, 2, 3};
        try {
            System.out.println(a / b);
            System.out.println(c[4]);

        } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
            System.out.println("出错了");
        }

    }
}

注意：

1.多个异常必须是平级关系

2.针对不同异常，处理方式一致

编译时异常和运行时异常

**编译时异常：**我们在执行程序，必须处理掉的异常，如果不处理，程序将不能编译正常

**运行时异常：**不需要我们显示处理，但是我们也可以使用try…catch处理

案例：

/**
 * 编译时异常:必须通过异常处理，代码才能通过编译
 */
public class ExceptionDemo4 {
    public static void main(String[] args) {
        String day = "2020-11-29";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM--dd");
        try {
            Date date = sdf.parse(day);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

Throwable

常用方法：

/**
 * Throwable:
 * public String getMessage():返回此 throwable 的详细消息字符串。
 * public String toString():返回此 throwable 的简短描述。
 *     组成：
 *        此异常类的全路径类名
 *        ":"
 *         调用此对象 getLocalizedMessage() 方法的结果 
 *           如果 getLocalizedMessage 返回 null，则只返回类名称。 
 * public void printStackTrace():获取异常类名和异常信息描述以及错误出现的位置
 * public void printStackTrace(PrintStream s)：将此 throwable 及其追踪输出到指定的输出流。
 */

throws

在开发中，如果去调用别人写的代码，我们很难判断调用方法时是否会发生异常。针对这种情况，java允许在方法后面使用throws关键字对外声明该方法在使用过程中可能发生的异常，这样调用者在调用方法时，就明确知道该方法有异常，并必须处理掉异常，否则代码将无法通过编译。

格式

方法()throws 异常类名1，异常类名2，...

注意：

我们在调用方法时，如果不做异常处理，我们可以选择抛出（throws），直到main方法抛给JVM为止，这种情况，JVM就会采取默认处理方式处理异常，尽量不要在主方法抛出。

案例：

/**
 * throws 演示案例
 */
public class ThrowsDemo {
    public static void main(String[] args)  {
       // method();
        try {
            method2();
        } catch (ParseException e) {
            e.printStackTrace();
        }
        System.out.println("程序结束");
    }

//    private static void method()throws ArithmeticException {
//        int a = 10;
//        int b = 0;
//        System.out.println(a / b);
//    }

    private static void method2() throws ParseException {
        String day = "2020-11-29";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM--dd");
        Date date = sdf.parse(day);
    }
}

根据演示案例，我们知道

编译时异常抛出：调用者必须处理

运行时异常抛出：调用者可以不处理

throws 和 throw

案例

/**
 * throws 演示案例
 */
public class ThrowsDemo {
    public static void main(String[] args)  {
       // method();
        method3();
//        try {
//            method2();
//        } catch (ParseException e) {
//            e.printStackTrace();
//        }
        System.out.println("程序结束");
    }

//    private static void method()throws ArithmeticException {
//        int a = 10;
//        int b = 0;
//        System.out.println(a / b);
//    }

    private static void method2() throws ParseException {
        String day = "2020-11-29";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM--dd");
        Date date = sdf.parse(day);
    }

    private static void method3()throws ArithmeticException {
       int a = 10;
        int b = 1;
        if (b == 0) {
            throw new ArithmeticException();
        } else {
            System.out.println(a / b);
        }

   }
}

总结：

throw：

1.方法体内，后面跟异常对象

2.只能抛一个异常

3.执行throw，表示一定有异常抛出

throws：

1.方法声明上，后面跟异常类名

2.可以抛多个异常，用，隔开

3.throws，表示可能有异常抛出

finally

概述：

被finally包裹的代码一定会被执行，但是，JVM退出

面试题

1.final，finally，finalize的区别？

final：它表示最终的，可以 类，成员变量，成员方法

类：表示最终类，不能被继承

成员变量：常量，不能被赋值

成员方法：最终方法，不能被重写

finally:它是 异常处理中try…catch…finally结构的一部分，这部分代码最终都会被执行，除了JVM退出。它一般用于释放资源

自定义异常：

注意事项：

1.自定义异常类必须继承Exception或RUntimeException

2.在其有参构造中，一定要指定访问父类的有参构造，这样才能把异常信息打印到控制台上

异常注意事项：

1.子类在重写父类方法时，子类的方法必须抛出相同的异常或父类异常的子类异常

2.如果父类抛出多个异常，子类重写父类方法时，只能抛出相同的异常或父类异常的子集，并且子类不能抛出父类中没有抛出的异常

3.如果被重写的方法没有抛出编译时异常，那么子类绝对不能抛出任何编译时异常，如果重写方法中有异常需要处理，只能选择try-catch，不能throws