用于说明 commit 的类别，常见类别如下：
经典MVC模式中，M是指模型，V是视图，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。其中，View的定义比较清晰，就是用户界面。
模型表示企业数据和业务规则。在MVC的三个部件中，模型拥有最多的处理任务。例如它可能用像EJBs和ColdFusion Components这样的构件对象来处理数据库，被模型返回的数据是中立的，就是说模型与数据格式无关，这样一个模型能为多个视图提供数据，由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码的重复性
背景: 在看主播冬灰条直播时发现他做了一个很有趣的东西<语音实时转文字>,看他直播时发现使用typescript写的,后来发现webApi中存在这个api,然后....
[scode type="green" size=""]前提: 有vue3和TypeScript基础[/scode]
环境: node
技术栈: TypeScript,VUE(全家桶)
使用的组件是vueuse的useSpeechRecognition模块
无环境安装过程建议百度
注意事项
建议使用Edge浏览器 因为使用谷歌浏览器需要科学手段(其他浏览器没试过),还有就是使用Edge浏览器会有标点符号美化
如果项目一直运行且长时间没有说话或语音输入,建议使用监听器监听状态,只要检测语音状态关闭立即重新启动语音输入
项目可以会存在文字卡顿现象
Input/Output)，视角为内存视角。IO流的分类按照数据的流向
按照数据类型来分
字节流(万能流)
字符流
字符流指的是传递字符的流，建议只用于读写纯文本文件；
字节流就是以字节为单位操作数据的流。
| 方法签名 | 说明 |
|---|---|
FileOutputStream FileOutputStream(File file) | 基于一个File封装一个FileOutputStream对象 |
FileOutputStream FileOutputStream(String pathName) | 基于一个字符串格式的文件路径封装一个FileOutputStream对象 |
| void write(int b) | 把指定的内容写入文件 |
| void close() | 关闭流释放资源 |
三个步骤
FileOutputStream)对象注释
// FileOutputStream FileOutputStream(String pathName) 基于一个字符串格式的文件路径封装一个FileOutputStream对象
// FileOutputStream FileOutputStream(File file) 基于一个File封装一个FileOutputStream对象
// void write(int b) 把指定的内容写入文件
// void close() 关闭流释放资源演示代码
/**
* 字节输出流入门案例：写一个字节
*/
public class ByteStreamDemo01 {
public static void main(String[] args) throws IOException {
// FileOutputStream FileOutputStream(String pathName) 基于一个字符串格式的文件路径封装一个FileOutputStream对象
// FileOutputStream FileOutputStream(File file) 基于一个File封装一个FileOutputStream对象
// void write(int b) 把指定的内容写入文件
// void close() 关闭流释放资源
// 创建自己输入流对象
// 创建输出流对象时，会判断关联的文件是否存在；
// 如果不存在，会自动创建一个空白的文件
// 如果存在，则清空文件内容
FileOutputStream fos = new FileOutputStream("d:\\file\\a.txt");
// 写出数据
// 字节输入流，操作的是字节；写97其实写的不是97这两个字符，而是一个码点/码值；
// 程序会把他当做一个字节写入到文件。我们查看，把这个字节的数字作为码点，查询字符集中对应的字符，后展示。
fos.write(98);
// 关闭流释放资源
// 创建输入流对象时，会自动关联对应的文件；这个时候，可以理解为当前这个Java程序独占了该文件
// 其他的程序想要操作相同文件时，会有问题。
// 所以使用完之后，要关闭流，释放对文件的独占
fos.close();
}
}| 方法签名 | 说明 |
|---|---|
| void write(int b) | 一次写一个字节数据(编码值)到指定位置（文件） |
| void write(byte[] b) | 一次写一个字节数组数据到指定位置（文件） |
| void write(byte[] b,int off,int len) | 一次写一个字节数组的部分到指定位置（文件） |
注释
// void write(byte[] b) 一次写一个字节数组数据到指定位置（文件）
// void write(byte[] b,int off,int len)一次写一个字节数组的部分到指定位置（文件） 演示代码
public class ByteSteamDemo01 {
public static void main(String[] args) throws IOException {
// 1. 创建字节输出流(`FileOutputStream`)对象
// FileOutputStream FileOutputStream(String pathName) 基于一个字符串格式的文件路径封装一个FileOutputStream对象
FileOutputStream fos = new FileOutputStream("d:\\file\\java74\\a.txt",true);
// 2.1 写出数据，每次写一个字节
// void write(int b) 把指定的内容写入文件
fos.write(97);
fos.write(98);
fos.write(99);
fos.write(48);
// 2.2 写出数据，每次写一个字节数组
// void write(byte[] b) 一次写一个字节数组数据到指定位置（文件）
fos.write(new byte[]{97,98,99});
// void write(byte[] b,int off,int len)一次写一个字节数组的部分到指定位置（文件）
// fos.write(new byte[]{-28, -72, -83, -27, -101, -67},0,3);
fos.write(new byte[]{-28, -72, -83, -27, -101, -67},3,3);
// 乱码的可能原因之一：使用字节流读写时，没有读写一个字符应该拥有的所有字节
// fos.write(new byte[]{-28, -72, -83, -27, -101, -67},0,2);
// 3. 关闭流释放资源
fos.close();
}
}写数据时写入如下内容即可实现换行
Linux和mac的换行符）字符串提供了把字符串对象转换成字节数组的方法
演示代码
// 加一个换行
// 新版本Windows中 也可以正确识别`Linux`和`mac`的换行符
fos.write("\r".getBytes());
fos.write("你好，中国！".getBytes());
// 加一个换行
fos.write("\n".getBytes());
fos.write("你好，中国！".getBytes());
// 加一个换行
fos.write("\r\n".getBytes());
fos.write("你好，中国！".getBytes());创建FileOutputStream对象时，除了关联一个文件之外，还可指定是否追加写入。
public FileOutputStream(String name,boolean append)
true ，则字节追加将写入文件的末尾；而不是直接写入，覆盖原有内容。演示代码
// 第二个参数指定为true，关联文件后写入内容时，会追加写入而非清空原有内容
FileOutputStream fos = new FileOutputStream("d:\\file\\a.txt",true);完整代码
public class ByteStremDemo03 {
public static void main(String[] args) throws IOException {
// 1. 创建字节输出流(FileOutputStream)对象
// 第二个参数指定为true，关联文件后写入内容时，会追加写入而非清空原有内容
FileOutputStream fos = new FileOutputStream("d:\\file\\a.txt",true);
// 2. 写入数据
// 写入换行 windows
fos.write("\r\n".getBytes());
// 使用字节流，写 “你好，中国！”到文件
// 使用API把字符串转为字节（而非自己查码表后拼接），写入文件
String str = "你好，中国2023！";
byte[] strBytes = str.getBytes();
fos.write(strBytes);
// 3. 关闭流释放资源
fos.close();
}
}创建字节输出流(FileOutputStream)对象，会去关联一个文件并进行一些基础的操作。
如果文件存在且有内容，默认清空文件内容；
true，表示追加写入。写数据
"\r\n".getBytes()释放资源
Java程序操作文件时会独占关联的文件，每次使用完流必须要释放资源。否则其他程序将不能正确访问该文件；字节输入流：读取一个字节
| 方法签名 | 说明 |
|---|---|
| FileInputStream FileInputStream(String pathName) | 基于一个字符串格式的文件路径封装一个FileInputStream对象 |
| int read() | 从文件中读取一个字节，值为字节的编码值 |
| void close() | 关闭流释放资源 |
步骤
注释
// FileInputStream FileInputStream(String pathName) 基于一个字符串格式的文件路径封装一个FileInputStream对象
// int read()从文件中读取一个字节，值为字节的码表值
// void close()关闭流释放资源 演示代码
public class ByteStreamDemo02 {
public static void main(String[] args) throws IOException {
// 1. 创建流对象，关联文件
// FileInputStream FileInputStream(String pathName) 基于一个字符串格式的文件路径封装一个FileInputStream对象
FileInputStream fis = new FileInputStream("d:\\file\\java74\\a.txt");
// 2. 读：读一个字节
// int read() 从文件中读取一个字节，返回值为字节的码表值
int charPoint = fis.read();
System.out.println("charPoint = " + ((char)charPoint));
// 3. 关闭流，释放资源
// void close() 关闭流释放资源
fis.close();
}
}文件内容
abcdefg控制台输出
a字节输入流：循环读取多个字节
| 方法签名 | 说明 |
|---|---|
| int read() | 从文件中读取一个字节，值为字节的编码值 |
演示代码
public class ByteStreamDemo03 {
public static void main(String[] args) throws IOException {
// 1. 创建流对象，关联文件
// FileInputStream FileInputStream(String pathName) 基于一个字符串格式的文件路径封装一个FileInputStream对象
FileInputStream fis = new FileInputStream("d:\\file\\java74\\a.txt");
// 2. 读：读一个字节
// int read() 从文件中读取一个字节，返回值为字节的码表值
// read(fis);
// 定义变量，接收每次读取到的码点
int charPoint;
// 循环读取码点，并和-1判断
while ((charPoint = fis.read()) != -1) {
// 如果不是-1，说明没有读取到文件末尾，就使用读取到的这个码点（eg：转换成字符使用）
System.out.println(charPoint + " : " + ((char) charPoint));
}
// 3. 关闭流，释放资源
// void close() 关闭流释放资源
fis.close();
}
private static void read(FileInputStream fis) throws IOException {
int charPoint = fis.read();
System.out.println("charPoint = " + ((char) charPoint));
charPoint = fis.read();
System.out.println("charPoint = " + ((char) charPoint));
charPoint = fis.read();
System.out.println("charPoint = " + ((char) charPoint));
charPoint = fis.read();
System.out.println("charPoint = " + ((char) charPoint));
charPoint = fis.read();
System.out.println("charPoint = " + ((char) charPoint));
charPoint = fis.read();
System.out.println("charPoint = " + ((char) charPoint));
charPoint = fis.read();
System.out.println("charPoint = " + ((char) charPoint));
charPoint = fis.read();
System.out.println("charPoint = " + (charPoint));
}
}文件内容
abcdefg控制台输出
97 : a
98 : b
99 : c
100 : d
101 : e
102 : f
103 : g字节输入流：读一个字节数组
| 方法签名 | 说明 |
|---|---|
| int read(byte[] bytes) | 从文件中读取一个字节数组的内容，并传入形参，返回读取到的字节数，否则为-1 |
| byte[] readAllBytes() | 读取文件中所有内容并转换为字节数组返回 |
演示代码
public class ByteStreamDemo04 {
public static void main(String[] args) throws IOException {
// 1. 创建流对象，关联文件
// FileInputStream FileInputStream(String pathName) 基于一个字符串格式的文件路径封装一个FileInputStream对象
FileInputStream fis = new FileInputStream("d:\\file\\java74\\a.txt");
// 2. 读：读一个字节数组
// read2Array(fis);
// byte[] readAllBytes() 读取文件中所有内容并转换为字节数组返回
byte[] allBytes = fis.readAllBytes();
String str = new String(allBytes);
// allBytes.length = 7
System.out.println("allBytes.length = " + allBytes.length);
// str = abcdefg
System.out.println("str = " + str);
// 3. 关闭流，释放资源
// void close() 关闭流释放资源
fis.close();
}
/**
* 读：读一个字节数组
* @param fis
* @throws IOException
*/
private static void read2Array(FileInputStream fis) throws IOException {
// int read(byte[] bytes) 从文件中读取一个字节数组的内容，并传入形参，返回读取到的字节数，否则为-1
byte[] bytes = new byte[1024];
int len = fis.read(bytes);
// 打印字节数组，看到大量的默认值0 bytes = [97, 98, 99, 100, 101, 102, 103, 0, 0, ...]
// System.out.println("bytes = " + Arrays.toString(bytes));
// 转换成字符串，会出现大量乱码 abcdefg后面有一大堆方块
// String str = new String(bytes);
// 不想出现乱码，就要控制转换的长度，只转换读取到的有效内容 str = abcdefg
String str = new String(bytes,0,len);
System.out.println("str = " + str);
}
}文件内容
abcdefg控制台输出内容
注意：
字节输入流-循环读取多个字节数组
方法和之前一样，配合while循环使用
| 方法签名 | 说明 |
|---|---|
| int read(byte[] bytes) | 从文件中读取一个字节数组的内容，并传入形参，返回读取到的字节数，否则为-1 |
演示代码
/**
* 字节输入流：循环读取多个字节数组
* @Description: 字节输入流：读一个字节
*/
public class ByteStreamDemo05 {
public static void main(String[] args) throws IOException {
// 1. 创建流对象，关联文件
// FileInputStream FileInputStream(String pathName) 基于一个字符串格式的文件路径封装一个FileInputStream对象
FileInputStream fis = new FileInputStream("d:\\file\\java74\\a.txt");
// 2. 读：读一个字节数组
// read(fis);
// int read(byte[] bytes) 从文件中读取一个字节数组的内容，并传入形参，返回读取到的字节数，否则为-1
byte[] bytes = new byte[2];
int len;
while ((len = fis.read(bytes)) != -1) {
// 使用读取到的字节数组
// 最后一次数据中，多了一个f
// String str = new String(bytes);
// 读取多少个字节，就转多少个字节，不会出现错误数据
String str = new String(bytes,0,len);
System.out.println("str = " + str);
}
// 3. 关闭流，释放资源
// void close() 关闭流释放资源
fis.close();
}
private static void read(FileInputStream fis) throws IOException {
// int read(byte[] bytes) 从文件中读取一个字节数组的内容，并传入形参，返回读取到的字节数，否则为-1
byte[] bytes = new byte[1024];
int len = fis.read(bytes);
// 返回的是成功读取的字节数
System.out.println("len = " + len);
len = fis.read(bytes);
// 返回的是成功读取的字节数
System.out.println("len = " + len);
}
}核心代码
// int read(byte[] bytes) 从文件中读取一个字节数组的内容，并传入形参，返回读取到的字节数，否则为-1
byte[] bytes = new byte[2];
int len;
while ((len = fis.read(bytes)) != -1) {
// 使用读取到的字节数组
// 最后一次数据中，多了一个f
// String str = new String(bytes);
// 读取多少个字节，就转多少个字节，不会出现错误数据
String str = new String(bytes,0,len);
System.out.println("str = " + str);
}文件内容
abcdefg控制台输出内容
str = ab
str = cd
str = ef
str = g注意：
创建字节输入流(FileInputStream)对象，会去关联一个文件并进行一些基础的操作。
读数据
释放资源
Java程序操作文件时会独占关联的文件，每次使用完流必须要释放资源。否则其他程序将不能正确访问该文件。D:\\file\\猜猜我是啥.mp4复制到其他位置。演示代码
/**
* 使用字节流复制文件
*
* @Description: 使用字节流复制文件
*/
public class ByteStreamDemo06 {
public static void main(String[] args) throws IOException {
// 1. 数据源：读，关联输入流。内存视角
FileInputStream fis = new FileInputStream("D:\\file\\猜猜我是啥.mp4");
// 2. 目的地：写，关联输出流。内存视角
FileOutputStream fos = new FileOutputStream("D:\\file\\猜猜你是啥.mp4");
// 3. 边读编写
// 3.1 每次读写一个字节
// operateByByte(fis, fos);
// 3.2 每次读写一个字节数组
operateByByteArray(fis, fos);
// 4. 关闭流，释放资源(先开后关)
fos.close();
fis.close();
}
/**
* 每次读写一个字节数组
* @param fis
* @param fos
* @throws IOException
*/
private static void operateByByteArray(FileInputStream fis, FileOutputStream fos) throws IOException {
// 统计性能，开始时间
long start = System.currentTimeMillis();
// a. 定义一个字节数组，用于存储每次读取到的多个字节
byte[] bytes = new byte[1024];
// b. 定义一个int变量，用于记录每次读取到的字节数
int len;
// c. 循环读取并出入字节数组，知道返回的有效字节数为-1
while ((len = fis.read(bytes)) != -1) {
// d. 循环内部，不停的将读取到的数组写入文件，注意控制长度
fos.write(bytes,0,len);
}
// 统计性能，结束时间
long end = System.currentTimeMillis();
// 自定义字节数组复制，共耗时：45ms
System.out.println("自定义字节数组复制，共耗时：" + (end - start) + "ms");
}
/**
* 每次读写一个字节
*
* @param fis
* @param fos
* @throws IOException
*/
private static void operateByByte(FileInputStream fis, FileOutputStream fos) throws IOException {
// 统计性能，开始时间
long start = System.currentTimeMillis();
// a. 定义一个变量，接收每次读取到的字节（的码点）
int read;
// b. 循环不断的读，直到读到文件结尾，返回-1
while ((read = fis.read()) != -1) {
// c. 每次读取到之后，就写入文件
fos.write(read);
}
// 统计性能，结束时间
long end = System.currentTimeMillis();
// 逐个字节复制，共耗时：37946ms
System.out.println("逐个字节复制，共耗时：" + (end - start) + "ms");
}
}思考：如何确保资源被正确释放
输出流操作文件期间如果产生了异常，异常之后的代码就不会继续执行，也就无法释放资源。
这个程序（生产环境程序不会关闭）就会独占关联的文件，造成其他程序无法访问该文件。
我们就要想办法让任何时候，资源都可以释放掉。
所以这个时候就需要用到finally
演示代码
public class ByteStreamDemo07 {
public static void main(String[] args) {
FileInputStream fis = null;
FileOutputStream fos = null;
try {
System.out.println(1 / 0);
// 读，输入流 从硬盘到内存
fis = new FileInputStream("d:\\file\\猜猜我是啥.mp4");
// 写，输出流， 从内存到硬盘
fos = new FileOutputStream("d:\\file\\猜猜我是啥2.mp4");
// 定义变量记录每次读取到的字节个数
int len;
// 创建数组缓存读取到的数据
byte[] bytes = new byte[1024];
// 边读边写
while ((len = fis.read(bytes)) != -1) {
fos.write(bytes, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
// 处理异常。常见的操作：记录日志，调用第三方接口发邮件、发短信
} finally {
// 关闭流，释放资源
if (fos != null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
System.out.println("流真的关闭了，舒了一口气！！");
}
}
}问题：释放资源的代码比核心代码还多还复杂！！！
JDK7中提供了语法糖，简化资源的释放。可以理解为对try代码块的增强。
语法糖名称：try-with-resource
格式：
try(开启资源){
// 可能出现异常的代码
}catch(异常类型 异常变量){
// 处理异常
}作用：
演示代码
/**
* JDK7新特性演示：自动释放资源
*
*/
public class TryWithResource {
public static void main(String[] args) {
/*
JDK7提供的新特性：
Try-With-Resource：可以理解为对Try{}catch(){}finally{}的简化
格式：
try(开启资源){}catch(){处理异常}
效果：
在try小括号中开启的资源，会在try代码块结束后自动释放
资源：
只要是实现了AutoCloseable接口的类，都可以称之为资源，都可以被Try-With-Resource管理并自动关闭
*/
// beforeJdk7();
// jdk7_01();
// jdk7_02();
}
private static void jdk7_02() {
// 在try小括号中开启的资源，try代码块中可以使用，并且会在try代码块执行完成后自动关闭释放
// 多个资源
try (
FileInputStream fis = new FileInputStream("d:\\a.mp4");
FileOutputStream fos = new FileOutputStream("d:\\a.mp4");
) {
int read = fis.read();
System.out.println("(char)read = " + (char) read);
fos.write(read);
// Try代码块中，如果出现异常，会被catch字句捕获，并在字句中处理
} catch (IOException e) {
e.printStackTrace();
}
}
private static void jdk7_01() {
// 在try小括号中开启的资源，try代码块中可以使用，并且会在try代码块执行完成后自动关闭释放
// 单个资源
try (FileInputStream fis = new FileInputStream("d:\\a.mp4")) {
int read = fis.read();
System.out.println("(char)read = " + (char) read);
// Try代码块中，如果出现异常，会被catch字句捕获，并在字句中处理
} catch (IOException e) {
e.printStackTrace();
}
}
private static void beforeJdk7() {
FileInputStream fis = null;
try {
fis = new FileInputStream("d:\\a.mp4");
int read = fis.read();
System.out.println("read = " + (char) read);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (fis != null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}Java中的IO流主要分为四类：字节流、字符流、字节缓冲流和字符缓冲流
字符流是专门为读取文本数据而生的
这是字符输入流，用来将文件中的字符数据读取到程序中来
FileReader(File file) 创建字符输入流管道与源文件接通
FileReader(String pathname) 创建字符输入流管道与源文件接通FileReader读取文件的步骤如下：
//第一步：创建FileReader对象与要读取的源文件接通
//第二步：调用read()方法读取文件中的字符
//第三步：调用close()方法关闭流每次读取一个字符返回,没有发现没有数据可读会返回-1
每次会一个字符数组去读取数据,返回字符数读取了多少个字符,如果没有发现数据可读会返回-1
public class FileReaderTest1 {
public static void main(String[] args) {
try (
// 1、创建一个文件字符输入流管道与源文件接通
Reader fr = new FileReader("text.txt");
){
// 2、一个字符一个字符的读（性能较差）
// 记住每次读取的字符编号。
int c;
while ((c = fr.read()) != -1){
System.out.print((char) c);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}public class FileReaderTest1 {
public static void main(String[] args) {
try (
//创建一个文件字符输入流管道与源文件接通
Reader fr = new FileReader("io-app2\\src\\itheima01.txt");
){
//每次读取多个字符。（性能是比较不错的！）
char[] buffer = new char[3];
int len; // 记住每次读取了多少个字符。
while ((len = fr.read(buffer)) != -1){
// 读取多少倒出多少
System.out.print(new String(buffer, 0, len));
}
} catch (Exception e) {
e.printStackTrace();
}
}
}它可以将程序中的字符数据写入文件
FileWriter往文件中写字符数据的步骤如下：
第一步：创建FileWirter对象与要读取的目标文件接通
第二步：调用write(字符数据/字符数组/字符串)方法读取文件中的字符
第三步：调用close()方法关闭流//会覆盖原文件内容
FileWriter(File file) 创建字节输出流管道与源文件对象接通
FileWirter(String filePath) 创建字节输出流管道与源文件对象接通
//可以追加内容
FileWriter(File file,boolean append) 创建字节输出流管道与源文件对象接通 可以追加内容
FileWirter(String filePath,boolean append) 创建字节输出流管道与源文件对象接通 可以追加内容写一个字符
写一个字符串
写一个字符串的一部分
写入一个字符数组
写入字符数组的一部分
try (
// 0、创建一个文件字符输出流管道与目标文件接通。
// 覆盖管道
// Writer fw = new FileWriter("io-app2/src/itheima02out.txt");
// 追加数据的管道
Writer fw = new FileWriter("io-app2/src/itheima02out.txt", true);
){
//下面内容
} catch (Exception e) {
e.printStackTrace();
}// 1、public void write(int c):写一个字符出去
fw.write('a');
fw.write(97);
//fw.write('磊'); // 写一个字符出去
fw.write("\r\n"); // 换行// 2、public void write(String c)写一个字符串出去
fw.write("我爱你中国abc");
fw.write("\r\n");// 3、public void write(String c ,int pos ,int len):写字符串的一部分出去
fw.write("我爱你中国abc", 0, 5);
fw.write("\r\n");// 4、public void write(char[] buffer):写一个字符数组出去
char[] buffer = {'黑', '马', 'a', 'b', 'c'};
fw.write(buffer);
fw.write("\r\n");// 5、public void write(char[] buffer ,int pos ,int len):写字符数组的一部分出去
fw.write(buffer, 0, 2);
fw.write("\r\n");字节流就是以字节为单位操作数据的流。
FileOutputStream(File file) //基于一个File封装一个FileOutputStream对象
FileOutputStream(String pathName) //基于一个字符串格式的文件路径封装一个FileOutputStream对象把指定的内容写入文件
一次写一个字节数组数据到指定位置（文件）
一次写一个字节数组的部分到指定位置（文件）
常见一个字节输出流
FileOutputStream fos = new FileOutputStream("a.txt",true);//写出数据，每次写一个字节
// void write(int b) 把指定的内容写入文件
fos.write(97);
fos.write(98);
fos.write(99);
fos.write(48);//写出数据，每次写一个字节数组
// void write(byte[] b) 一次写一个字节数组数据到指定位置（文件）
fos.write(new byte[]{97,98,99});一次写一个字节数组的部分到指定位置（文件）
// fos.write(new byte[]{-28, -72, -83, -27, -101, -67},0,3);
fos.write(new byte[]{-28, -72, -83, -27, -101, -67},3,3);[scode type="red" size=""]
创建字节输出流(FileOutputStream)对象，会去关联一个文件并进行一些基础的操作。
如果文件存在且有内容，默认清空文件内容；
true，表示追加写入。写数据
"\r\n".getBytes()释放资源
Java程序操作文件时会独占关联的文件，每次使用完流必须要释放资源。否则其他程序将不能正确访问该文件；[/scode]
基于一个字符串格式的文件路径封装一个FileInputStream对象
从文件中读取一个字节，值为字节的编码值
从文件中读取一个字节数组的内容，并传入形参，返回读取到的字节数，否则为-1
读取文件中所有内容并转换为字节数组返回
FileInputStream fis = new FileInputStream("a.txt");int read() 从文件中读取一个字节，返回值为字节的码表值byte[] bytes = new byte[1024];
int len = fis.read(bytes);
// 打印字节数组，看到大量的默认值0 bytes = [97, 98, 99, 100, 101, 102, 103, 0, 0, ...]
// System.out.println("bytes = " + Arrays.toString(bytes));
// 转换成字符串，会出现大量乱码 abcdefg后面有一大堆方块
// String str = new String(bytes);
// 不想出现乱码，就要控制转换的长度，只转换读取到的有效内容 str = abcdefg
String str = new String(bytes,0,len);
System.out.println("str = " + str);// byte[] readAllBytes() 读取文件中所有内容并转换为字节数组返回
byte[] allBytes = fis.readAllBytes();
String str = new String(allBytes);[scode type="red" size=""]
创建字节输入流(FileInputStream)对象，会去关联一个文件并进行一些基础的操作。
读数据
释放资源
Java程序操作文件时会独占关联的文件，每次使用完流必须要释放资源。否则其他程序将不能正确访问该文件。[/scode]
计算机只能处理0和1组成的二进制数据，为了让计算机能够存储处理字符，计算机的设计者美国人就把他们会用到的每一个字符进行了编码（所谓编码，就是人为的为每一个字符关联一个数字（称为码点）），计算机在存储某个字符时，存储的就是字符对应码点的二进制数据。
ASCII字符集：《美国信息交换标准代码》，包含英文字母、数字、标点符号、控制字符
特点：1个字符占1个字节
GBK字符集：中国人自己的字符集，兼容ASCII字符集，还包含2万多个汉字
特点：1个字母占用1个字节；1个汉字占用2个字节
Unicode字符集：包含世界上所有国家的文字，有三种编码方案，最常用的是UTF-8
UTF-8编码方案：英文字母、数字占1个字节兼容(ASCII编码)、汉字字符占3个字节| 方法名 | 说明 | |
|---|---|---|
| 编 | byte[] getBytes() | 使用平台的默认字符集将一个字符串编码为字节数组 |
| 码 | byte[] getBytes(String charsetName) | 使用指定的字符集将一个字符串编码为字节数组 |
| 解 | String(byte[] bytes) | 使用平台的默认字符集解码指定的字节数组来创建字符串 |
| 码 | String(byte[] bytes, String charsetName) | 通过指定的字符集解码指定的字节数组来创建字符串 |
注释
// byte[] getBytes () 使用平台的默认字符集将一个字符串编码为字节数组
// byte[] getBytes (String charsetName)使用指定的字符集将一个字符串编码为字节数组
// String( byte[] bytes)使用平台的默认字符集解码指定的字节数组来创建字符串 |
// String( byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来创建字符串public static void main(String[] args) throws UnsupportedEncodingException {
// byte[] getBytes () 使用平台的默认字符集将一个字符串编码为字节数组
// byte[] getBytes (String charsetName)使用指定的字符集将一个字符串编码为字节数组
// String( byte[] bytes)使用平台的默认字符集解码指定的字节数组来创建字符串 |
// String( byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来创建字符串
// 1. 编码
// 从字符串 -> 码点数字
String str1 = "中国";
// byte[] getBytes () 使用平台的默认字符集将一个字符串编码为字节数组
byte[] str1U8Bytes = str1.getBytes();
// str1U8Bytes = [-28, -72, -83, -27, -101, -67]
System.out.println("str1U8Bytes = " + Arrays.toString(str1U8Bytes));
// byte[] getBytes (String charsetName)使用指定的字符集将一个字符串编码为字节数组
byte[] strGbkBytes = str1.getBytes("GBK");
// strGbkBytes = [-42, -48, -71, -6]
System.out.println("strGbkBytes = " + Arrays.toString(strGbkBytes));
// 2.解压
// 从 码点数字(字节数组) -> 字符串 ====> 字符串构造方法
// 使用默认字符集：U8
// String( byte[] bytes)使用平台的默认字符集解码指定的字节数组来创建字符串
String str2 = new String(new byte[]{-28, -72, -83, -27, -101, -67});
// str2 = 中国
System.out.println("str2 = " + str2);
// 使用指定字符集:GBK
// String( byte[] bytes, String charsetName)通过指定的字符集解码指定的字节数组来创建字符串
String str3 = new String(new byte[]{-42, -48, -71, -6},"gbk");
// str3 = 中国
System.out.println("str3 = " + str3);
// 演示乱码
// 编解码使用不同的字符集：UTF-8解码时，使用字节数组是通过GBK编码出来的
String str4 = new String(new byte[]{-42, -48, -71, -6});
// �й�
System.out.println("str4 = " + str4);
}前面我们已经学习过了ArrayList集合，但是除了ArrayList集合，Java还提供了很多种其他的集合，如下图所示：
这些集合一共分两大类，如下图所示：一类是单列集合元素是一个一个的，另一类是双列集合元素是一对一对的。
主要学习Collection单列集合。Collection是单列集合的根接口，Collection接口下面又有两个子接口List接口、Set接口，List和Set下面分别有不同的实现类，如下图所示：
上图中各种集合的特点如下图所示：
可以自己写代码验证一下，各种集合的特点
//简单确认一下Collection集合的特点
ArrayList<String> list = new ArrayList<>(); //存取顺序一致，可以重复，有索引
list.add("java1");
list.add("java2");
list.add("java1");
list.add("java2");
System.out.println(list); //[java1, java2, java1, java2]
HashSet<String> list = new HashSet<>(); //存取顺序不一致，不重复，无索引
list.add("java1");
list.add("java2");
list.add("java1");
list.add("java2");
list.add("java3");
System.out.println(list); //[java3, java2, java1] Collection集合的一些常用方法，这些方法所有Collection实现类都可以使用。 这里我们以创建ArrayList为例，来演示
Collection<String> c = new ArrayList<>();
//1.public boolean add(E e): 添加元素到集合
c.add("java1");
c.add("java1");
c.add("java2");
c.add("java2");
c.add("java3");
System.out.println(c); //打印: [java1, java1, java2, java2, java3]
//2.public int size(): 获取集合的大小
System.out.println(c.size()); //5
//3.public boolean contains(Object obj): 判断集合中是否包含某个元素
System.out.println(c.contains("java1")); //true
System.out.println(c.contains("Java1")); //false
//4.pubilc boolean remove(E e): 删除某个元素，如果有多个重复元素只能删除第一个
System.out.println(c.remove("java1")); //true
System.out.println(c); //打印: [java1,java2, java2, java3]
//5.public void clear(): 清空集合的元素
c.clear();
System.out.println(c); //打印：[]
//6.public boolean isEmpty(): 判断集合是否为空 是空返回true 反之返回false
System.out.println(c.isEmpty()); //true
//7.public Object[] toArray(): 把集合转换为数组
Object[] array = c.toArray();
System.out.println(Arrays.toString(array)); //[java1,java2, java2, java3]
//8.如果想把集合转换为指定类型的数组，可以使用下面的代码
String[] array1 = c.toArray(new String[c.size()]);
System.out.println(Arrays.toString(array1)); //[java1,java2, java2, java3]
//9.还可以把一个集合中的元素，添加到另一个集合中
Collection<String> c1 = new ArrayList<>();
c1.add("java1");
c1.add("java2");
Collection<String> c2 = new ArrayList<>();
c2.add("java3");
c2.add("java4");
c1.addAll(c2); //把c2集合中的全部元素，添加到c1集合中去
System.out.println(c1); //[java1, java2, java3, java4]最后，我们总结一下Collection集合的常用功能有哪些，ArrayList、LinkedList、HashSet、LinkedHashSet、TreeSet集合都可以调用下面的方法。
因为Collection集合是单列集合的祖宗类，学会了Collection集合的遍历，就可以用来遍历其他所有单列集合
接下来学习的迭代器就是一种集合的通用遍历方式。
代码写法如下：
Collection<String> c = new ArrayList<>();
c.add("赵敏");
c.add("小昭");
c.add("素素");
c.add("灭绝");
System.out.println(c); //[赵敏, 小昭, 素素, 灭绝]
//第一步：先获取迭代器对象
//解释：Iterator就是迭代器对象，用于遍历集合的工具)
Iterator<String> it = c.iterator();
//第二步：用于判断当前位置是否有元素可以获取
//解释：hasNext()方法返回true，说明有元素可以获取；反之没有
while(it.hasNext()){
//第三步：获取当前位置的元素，然后自动指向下一个元素.
String e = it.next();
System.out.println(s);
}迭代器代码的原理如下：
最后，我们再总结一下，使用迭代器遍历集合用到哪些方法
接下来介绍一种更加简化的写法，叫做增强for循环。
格式如下：
需要注意的是，增强for不光可以遍历集合，还可以遍历数组。接下来我们用代码演示一em.o下：
Collection<String> c = new ArrayList<>();
c.add("赵敏");
c.add("小昭");
c.add("素素");
c.add("灭绝");
//1.使用增强for遍历集合
for(String s: c){
System.out.println(s);
}
//2.再尝试使用增强for遍历数组
String[] arr = {"迪丽热巴", "古力娜扎", "稀奇哈哈"};
for(String name: arr){
System.out.println(name);
}在JDK8版本以后还提供了一个forEach方法也可以遍历集合，如果下图所示：
我们发现forEach方法的参数是一个Consumer接口，而Consumer是一个函数式接口，所以可以传递Lambda表达式
Collection<String> c = new ArrayList<>();
c.add("赵敏");
c.add("小昭");
c.add("素素");
c.add("灭绝");
//调用forEach方法
//由于参数是一个Consumer接口，所以可以传递匿名内部类
c.forEach(new Consumer<String>{
@Override
public void accept(String s){
System.out.println(s);
}
});
//也可以使用lambda表达式对匿名内部类进行简化
c.forEach(s->System.out.println(s)); //[赵敏, 小昭, 素素, 灭绝]接下来，我们看一个案例，在集合中存储自定义的对象，并遍历。具体要求如下
首先，我们得写一个电影类，用来描述每一步电影应该有哪些信息。
public class Movie{
private String name; //电影名称
private double score; //评分
private String actor; //演员
//无参数构造方法
public Movie(){}
//全参数构造方法
public Movie(String name, double score, String actor){
this.name=name;
this.score=score;
this.actor=actor;
}
//...get、set、toString()方法自己补上..
}接着，再创建一个测试类，完成上面的需求
public class Test{
public static void main(String[] args){
Collection<Movie> movies = new ArrayList<>();
movies.add(new MOvie("《肖申克的救赎》", 9.7, "罗宾斯"));
movies.add(new MOvie("《霸王别姬》", 9.6, "张国荣、张丰毅"));
movies.add(new MOvie("《阿甘正传》", 9.5, "汤姆汉克斯"));
for(Movie movie : movies){
System.out.println("电影名：" + movie.getName());
System.out.println("评分：" + movie.getScore());
System.out.println("主演：" + movie.getActor());
}
}
}以上代码的内存原理如下图所示：当往集合中存对象时，实际上存储的是对象的地址值
List集合是索引的，所以多了一些有索引操作的方法，如下图所示：
接下来，我们用代码演示一下这几个方法的效果
//1.创建一个ArrayList集合对象（有序、有索引、可以重复）
List<String> list = new ArrayList<>();
list.add("蜘蛛精");
list.add("至尊宝");
list.add("至尊宝");
list.add("牛夫人");
System.out.println(list); //[蜘蛛精, 至尊宝, 至尊宝, 牛夫人]
//2.public void add(int index, E element): 在某个索引位置插入元素
list.add(2, "紫霞仙子");
System.out.println(list); //[蜘蛛精, 至尊宝, 紫霞仙子, 至尊宝, 牛夫人]
//3.public E remove(int index): 根据索引删除元素, 返回被删除的元素
System.out.println(list.remove(2)); //紫霞仙子
System.out.println(list);//[蜘蛛精, 至尊宝, 至尊宝, 牛夫人]
//4.public E get(int index): 返回集合中指定位置的元素
System.out.println(list.get(3));
//5.public E set(int index, E e): 修改索引位置处的元素，修改后，会返回原数据
System.out.println(list.set(3,"牛魔王")); //牛夫人
System.out.println(list); //[蜘蛛精, 至尊宝, 至尊宝, 牛魔王]List集合相比于前面的Collection多了一种可以通过索引遍历的方式，所以List集合遍历方式一共有四种：
List<String> list = new ArrayList<>();
list.add("蜘蛛精");
list.add("至尊宝");
list.add("糖宝宝");
//1.普通for循环
for(int i = 0; i< list.size(); i++){
//i = 0, 1, 2
String e = list.get(i);
System.out.println(e);
}
//2.增强for遍历
for(String s : list){
System.out.println(s);
}
//3.迭代器遍历
Iterator<String> it = list.iterator();
while(it.hasNext()){
String s = it.next();
System.out.println(s);
}
//4.lambda表达式遍历
list.forEach(s->System.out.println(s));ArrayList集合底层是基于数组结构实现的，也就是说当你往集合容器中存储元素时，底层本质上是往数组中存储元素。 特点如下：
我们知道数组的长度是固定的，但是集合的长度是可变的，这是怎么做到的呢？原理如下：
数组扩容，并不是在原数组上扩容（原数组是不可以扩容的），底层是创建一个新数组，然后把原数组中的元素全部复制到新数组中去。
LinkedList底层是链表结构，链表结构是由一个一个的节点组成，一个节点由数据值、下一个元素的地址组成。如下图所示
如，现在要在B节点和D节点中间插入一个元素，只需要把B节点指向D节点的地址断掉，重新指向新的节点地址就可以了。如下图所示：
假如，现在想要把D节点删除，只需要让C节点指向E节点的地址，然后把D节点指向E节点的地址断掉。此时D节点就会变成垃圾，会把垃圾回收器清理掉
上面的链表是单向链表，它的方向是从头节点指向尾节点的，只能从左往右查找元素，这样查询效率比较慢；还有一种链表叫做双向链表，不光可以从做往右找，还可以从右往左找。如下图所示：
LinkedList集合是基于双向链表实现了，所以相对于ArrayList新增了一些可以针对头尾进行操作的方法，如下图示所示：
入队列可以调用LinkedList集合的addLast方法，出队列可以调用removeFirst()方法.
//1.创建一个队列：先进先出、后进后出
LinkedList<String> queue = new LinkedList<>();
//入对列
queue.addLast("第1号人");
queue.addLast("第2号人");
queue.addLast("第3号人");
queue.addLast("第4号人");
System.out.println(queue);
//出队列
System.out.println(queue.removeFirst());//第4号人
System.out.println(queue.removeFirst());//第3号人
System.out.println(queue.removeFirst());//第2号人
System.out.println(queue.removeFirst());//第1号人
有没有感觉栈结构很像，手枪的子弹夹呀！！第一个压进入的子弹在最底下，最后一个才能打出来，最后一个压进入的子弹在最顶上，第一个打出来。
接着，我们就用LinkedList来模拟下栈结构，代码如下：
//1.创建一个栈对象
LinkedList<String> stack = new ArrayList<>();
//压栈(push) 等价于 addFirst()
stack.push("第1颗子弹");
stack.push("第2颗子弹");
stack.push("第3颗子弹");
stack.push("第4颗子弹");
System.out.println(stack); //[第4颗子弹, 第3颗子弹, 第2颗子弹,第1颗子弹]
//弹栈(pop) 等价于 removeFirst()
System.out.println(statck.pop()); //第4颗子弹
System.out.println(statck.pop()); //第3颗子弹
System.out.println(statck.pop()); //第2颗子弹
System.out.println(statck.pop()); //第1颗子弹
//弹栈完了，集合中就没有元素了
System.out.println(list); //[]List集合的特点是什么？
有序、可重复、有索引
List集合底层是基于什么数据结构的？
基于数组实现的
为什么List集合查询快、增删慢？
查询快：因为数组是连续的一段内存空间，当指定下标时，计算机可以算出对于元素的地址，所以查询快
增删慢：因为数组是连续的一段内存空间，假如在数组中间增加删除元素，后面的所有元素全要后移或前移
你能说出List集合的扩容过程吗？(四步)
- 无参构造创建List集合，默认大小是0
- 添加第一个元素时，底层会创建一个长度为10的数组
- 存满时，会扩容1.5倍
- 如果一次添加多个元素，1.5倍还放不下，则新创建的数组的长度以实际为准
正则表达式其实是由一些特殊的符号组成的，它代表的是某种规则。
正则表达式的作用1：用来校验字符串数据是否合法
正则表达式的作用2：可以从一段文本中查找满足要求的内容
现在，我们就以QQ号码为例，来体验一下正则表达式的用法。注意：现在仅仅只是体验而已，我们还没有讲正则表达式的具体写法。
public static boolean checkQQ(String qq){
// 1、判断qq号码是否为null
if(qq == null || qq.startsWith("0") || qq.length() < 6 || qq.length() > 20){
return false;
}
// 2、qq至少是不是null,不是以0开头的，满足6-20之间的长度。
// 判断qq号码中是否都是数字。
// qq = 2514ghd234
for (int i = 0; i < qq.length(); i++) {
// 根据索引提取当前位置处的字符。
char ch = qq.charAt(i);
// 判断ch记住的字符，如果不是数字，qq号码不合法。
if(ch < '0' || ch > '9'){
return false;
}
}
// 3、说明qq号码肯定是合法
return true;
}public static boolean checkQQ1(String qq){
return qq != null && qq.matches("[1-9]\\d{5,19}");
}使用正则表达式，大大简化的了代码的写法。
前面我们已经体验到了正则表达式，可以简化校验数据的代码书写。这里需要用到一个方法叫matches(String regex)。这个方法时属于String类的方法。
这个方法是用来匹配一个字符串是否匹配正则表达式的规则，参数需要调用者传递一个正则表达式。但是正则表达式不能乱写，是有特定的规则的。
下面我们就学习一下，正则表达式的规则。从哪里学呢？在API中有一个类叫做Pattern，我们可以到API文档中搜索，关于正则表达式的规则，这个类都告诉我们了。我这里把常用的已经给大家整理好了。
我们将这些规则，在代码中演示一下
/**
* 目标：掌握正则表达式的书写规则
*/
public class RegexTest2 {
public static void main(String[] args) {
// 1、字符类(只能匹配单个字符)
System.out.println("a".matches("[abc]")); // [abc]只能匹配a、b、c
System.out.println("d".matches("[^abc]")); // [^abc] 不能是abc
// 2、预定义字符(只能匹配单个字符) . \d \D \s \S \w \W
// \转义
System.out.println("\"");
// \n \t
System.out.println("3".matches("\\d")); // \d: 0-9
System.out.println("a".matches("\\d")); //false
// 3、数量词： ? * + {n} {n, } {n, m}
System.out.println("1".matches("[0-9]?")); // ? 代表0次或1次
System.out.println("123".matches("[0-9]*")); // * 代表0次或多次
}
}学习完正则表达式的规则之后，我们看几个实际案例。
/**
* 目标：校验用户输入的电话、邮箱、时间是否合法。
*/
public class RegexTest3 {
public static void main(String[] args) {
checkPhone();
}
public static void checkPhone(){
while (true) {
System.out.println("请您输入您的电话号码(手机|座机): ");
Scanner sc = new Scanner(System.in);
String phone = sc.nextLine();
// 1. 手机号码，以1开头，第二位是3-9中的任意一个数字，后面跟着9个数字。
// 2. 座机号码，以0开头，后面跟着2-7位数字，然后可能会有一个横杠（“-”），后面是4-19位数字。
if(phone.matches("(1[3-9]\\d{9})|(0\\d{2,7}-?[1-9]\\d{4,19})")){
System.out.println("您输入的号码格式正确~~~");
break;
}else {
System.out.println("您输入的号码格式不正确~~~");
}
}
}
}public class RegexTest3 {
public static void main(String[] args) {
checkEmail();
}
public static void checkEmail(){
while (true) {
System.out.println("请您输入您的邮箱： ");
Scanner sc = new Scanner(System.in);
String email = sc.nextLine();
// 1. \w{2,} 匹配一个包含至少两个字母数字字符的字符串，用来匹配电子邮件地址的用户名部分。
//2. @ 匹配一个 "@" 符号，用来分隔用户名和域名。
//3. \w{2,20} 匹配一个包含至少两个字母数字字符、至多20个字母数字字符的字符串，用来匹配电子邮件地址的域名部分。
//4. (\\.\\w{2,10}){1,2} 匹配一个域名后面跟着的一个或两个点号（用 \\ 来转义点号），每个点号后面跟着一个至少两个、至多十个字母数字字符的字符串，用来匹配电子邮件地址的子域名和顶级域名。
if(email.matches("\\w{2,}@\\w{2,20}(\\.\\w{2,10}){1,2}")){
System.out.println("您输入的邮箱格式正确~~~");
break;
}else {
System.out.println("您输入的邮箱格式不正确~~~");
}
}
}
}
总结一下，正则表达式优缺点都很明显。优点是很简练，缺点是可读性和可扩展性很差，以及很难写。
我们调用一个方法时，经常一不小心就出异常了，然后在控制台打印一些异常信息。其实打印的这些异常信息，就叫做异常。
int[] arr = {11,22,33};
//5是一个不存在的索引，所以此时产生ArrayIndexOutOfBoundsExcpetion
System.out.println(arr[5]); 下图是API中对ArrayIndexOutOfBoundsExcpetion类的继承体系，以及告诉我们它在什么情况下产生。
编译时异常，它把异常的提醒提前了，你调用方法是否真的有问题，只要可能有问题就给你报出异常提示（红色波浪线）。
编译时异常的目的：意思就是告诉你，你小子注意了！！，这里小心点容易出错，仔细检查一下
有人说，我检查过了，我确认我的代码没问题，为了让它不报错，继续将代码写下去。我们这里有两种解决方案。
/**
* 目标：认识异常。
*/
public class ExceptionTest1 {
public static void main(String[] args) throws ParseException{
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse("2028-11-11 10:24");
System.out.println(d);
}
}public class ExceptionTest1 {
public static void main(String[] args) throws ParseException{
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse("2028-11-11 10:24");
System.out.println(d);
} catch (ParseException e) {
e.printStackTrace();
}
}
}Java提供了一些异常，但是Java官方无法为这个世界上的全部问题都提供异常类，如果企业自己的某种问题，想通过异常来表示，那就需要自己来定义异常类了。
我们通过一个实际场景，来给大家演示自定义异常。
需求：写一个saveAge(int age)方法，在方法中对参数age进行判断，如果age<0或者>=150就认为年龄不合法，如果年龄不合法，就给调用者抛出一个年龄非法异常。
分析：Java的API中是没有年龄非常这个异常的，所以我们可以自定义一个异常类，用来表示年龄非法异常，然后再方法中抛出自定义异常即可。
// 1、必须让这个类继承自Exception，才能成为一个编译时异常类。
public class AgeIllegalException extends Exception{
public AgeIllegalException() {
}
public AgeIllegalException(String message) {
super(message);
}
}public class ExceptionTest2 {
public static void main(String[] args) {
// 需求：保存一个合法的年
try {
saveAge2(225);
System.out.println("saveAge2底层执行是成功的！");
} catch (AgeIllegalException e) {
e.printStackTrace();
System.out.println("saveAge2底层执行是出现bug的！");
}
}
//2、在方法中对age进行判断，不合法则抛出AgeIllegalException
public static void saveAge(int age){
if(age > 0 && age < 150){
System.out.println("年龄被成功保存： " + age);
}else {
// 用一个异常对象封装这个问题
// throw 抛出去这个异常对象
throw new AgeIllegalRuntimeException("/age is illegal, your age is " + age);
}
}
}1.如果自定义异常类继承Excpetion，则是编译时异常。
特点：方法中抛出的是编译时异常，必须在方法上使用throws声明，强制调用者处理。
2.如果自定义异常类继承RuntimeException，则运行时异常。
特点：方法中抛出的是运行时异常，不需要在方法上用throws声明。比如有如下的场景：A调用用B，B调用C；C中有异常产生抛给B，B中有异常产生又抛给A；异常到了A这里就不建议再抛出了，因为最终抛出被JVM处理程序就会异常终止，并且给用户看异常信息，用户也看不懂，体验很不好。
此时比较好的做法就是：1.将异常捕获，将比较友好的信息显示给用户看；2.尝试重新执行，看是是否能修复这个问题。
我们看一个代码，main方法调用test1方法，test1方法调用test2方法，test1和test2方法中多有扔异常。
public class ExceptionTest3 {
public static void main(String[] args) {
try {
test1();
} catch (FileNotFoundException e) {
System.out.println("您要找的文件不存在！！");
e.printStackTrace(); // 打印出这个异常对象的信息。记录下来。
} catch (ParseException e) {
System.out.println("您要解析的时间有问题了！");
e.printStackTrace(); // 打印出这个异常对象的信息。记录下来。
}
}
public static void test1() throws FileNotFoundException, ParseException {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date d = sdf.parse("2028-11-11 10:24:11");
System.out.println(d);
test2();
}
public static void test2() throws FileNotFoundException {
// 读取文件的。
InputStream is = new FileInputStream("D:/meinv.png");
}
}/**
* 目标：掌握异常的处理方式：捕获异常，尝试修复。
*/
public class ExceptionTest4 {
public static void main(String[] args) {
// 需求：调用一个方法，让用户输入一个合适的价格返回为止。
// 尝试修复
while (true) {
try {
System.out.println(getMoney());
break;
} catch (Exception e) {
System.out.println("请您输入合法的数字！！");
}
}
}
public static double getMoney(){
Scanner sc = new Scanner(System.in);
while (true) {
System.out.println("请您输入合适的价格：");
double money = sc.nextDouble();
if(money >= 0){
return money;
}else {
System.out.println("您输入的价格是不合适的！");
}
}
}
}