面向对象编程
Java的核心思想就是oop
目录：
-
初始面向对象
-
方法回顾和加深
-
对象的创建分析
-
面向对象三大特性
-
抽象类和接口
-
内部类及OOP实战
初始面向对象
面向过程 & 面向对象
-
面向过程思想
- 步骤清晰简单，第一步做什么，第二步做什么…
- 面对过程适合处理一些较为简单的问题
-
面向对象思想
- 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
- 面向对象适合处理复杂的问题，适合处理需要多人协作的问题。
-
对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思维去处理。
什么是面向对象
-
面向对象编程（Object-Oriented Programming, OOP）
-
面向对象编程的本质就是：
以类的方式组织代码，以对象的组织（封装）数据
。
-
核心：抽象
-
三大特性：
-
封装
-
继承
-
多态
-
-
从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
-
从代码运行角度考虑是先有类后有对象。类是对象的模板。
回顾方法及加深
-
方法的定义
-
修饰符
-
返回类型
//main方法 public static void main(String[] args) { } /* 修饰符 返回值类型 方法名（...）｛ //方法体 return 返回值； ｝ */ public String sayHellp(){ return "hello,world"; } public int max(int a ,int b ){ return a>b ? a : b ;//三元运算符！ } -
break 和 return 的区别(break:跳出switch，结束循环。return：结束循环，返回值)
-
方法名（注意规范，见名知意）
-
参数列表（参数类型，参数名）
-
异常抛出
-
-
方法的调用：递归
-
静态方法
-
非静态方法
/*静态方法 stutic 输出：类名+方法名 */ /*非静态方法 1.实例化这个类 new+类名+.方法名 2.对象类型 对象名 = 对象值； 类名+.方法名 */ public static void main(String[] args) { Student student = new Student(); student.say(); }public static void a(){ b()//不可以调b }//因为static静态方法是和类一起加载，在创建的时候就已经有了 public void b(){ a();//可以调a }//而非静态需要类实例化以后（new）才存在 -
形参和实参
-
值传递和引用传递
//引用传递：对象，本质还是值传递 public static void main(String[] args) { Perosn perosn = new Perosn(); System.out.println(perosn.name);//null Demo03.change(perosn); System.out.println(perosn.name);//上下没中 } public static void change(Perosn erosn){ //perosn 是一个对象：指向的 ---> Perosn perosn = new Perosn(); // 这是一个具体的人，可以改变属性 erosn.name = "上下没中";//它赋值的是 } } //定义一个perosn类，有一个属性：name class Perosn{ String name; -
this关键字（代表当前这个类）
-
类与对象的关系
-
类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物。
- 动物、植物、手机、电脑…
- Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
-
对象是抽象概念的具体实例
- 张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例。
- 能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。
创建与初始化对象
-
使用new关键字创建对象
-
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
一个类里面只有属性和方法。
//类是抽象的，必须用new实例化
//类实例化后会返回一个自己的对象
//返回后的对象就是抽象类的具体实例
-
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下俩个特点：
- 1.必须和类的名字相同
- 2.必须没有返回类型，也不能写void
//一个类即使什么都不写,它也会存在一个方法（无参构造） //显示的定义构造器 String name; int age; //1.使用new关键字，本质是在调用构造器 //2.无参构造器，用来初始化值 public Demo02(){ } //一旦定义了有参构造，无参就必须显示定义 public Demo02(String name){ this.name = name; } //alt + insert 生产构造器
近期总结
-
类与对象
类是一个模板、抽象的；对象是一个具体的实例。
-
方法
定义与调用！
-
对应的引用
引用类型：
基本类型（8）
对象是通过引用来操作的：栈—>堆
-
属性：字段Field 成员变量
默认初始化：
数字： 0 0.0
char : u0000
boolean : false
引用 ： null
修饰符 属性类型 属性名 = 属性值！
-
对象的创建和使用
- 必须使用 new 关键字创造对象，构造器 Person sxmz = new person();
- 对象的属性 sxmz.name
- 对象的方法 sxmz.sleep()
-
类：
静态的属性 属性
动态的行为 方法
类里只写这两个。
面向对象三大特性
封装
-
该露的露，该藏得藏
-
我们程序设计要追求 “
高内聚，低耦合
”。高内聚就是将类的内部数据操作细节自己完成，不允许外部干涉； - 低耦合：尽量暴露少量的方法给外部使用。
-
我们程序设计要追求 “
-
封装（数据的隐藏）
- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
-
属性私有，private ; get / set ;
public class Student { //类 private:属性私有 private String name; private int age; private char sex; //提供一些可以操作这个属性的方法 //public 的 get/set 方法 //get 获得这个数据 public String getName(){ return this.name;} /* Student s1 = new Student(); String name = s1.getName(); name = "小白"; System.out.println(name); */ //set 给这个数据设置值 public void setName(String name){ this.name = name;} /* Student s1 = new Student(); s1.setName("小黑"); System.out.println(s1.getName()); */ //快捷键 alt + insert
继承
-
继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
-
extends 的意思是“扩展”。子类是父类的扩展。
-
Java 中类只有单继承，没有多继承！
-
继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
-
继承关系的俩个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends 来表示。
-
子类和父类之间，从意义上讲应该具有“is a”的关系。
子类名 + extends + 父类名Public 公共的
protected 受保护的
default 默认的
private 私有的
public //公共的 protected //受保护的 default //默认的 private //私有的，无法被继承 //ctrl+h 继承树 -
object类
在 Java 中，所有的类，都默认、直接或者间接继承object
-
super
—thisthis 调用当前类，super 调用父类。
super注意点：
- super 调用父类的构造方法，必须在构造方法的第一个
- super 必须只能出现在子类的方法或者构造方法中!
- super 和 this 不能同时调用构造方法！
Vs this:
代表的对象不同：
this：本身调用者这个对象
super：代表父类对象的应用
前提：
this：没有继承也可以使用
super：只能在继承条件才可以使用
构造方法：
this()：本类的构造
super()：父类的构造
-
方法重写
Override重写都是方法的重写，和属性无关。
重写值和非静态方法有关，静态没用，只能 Public 。
需要有继承关系，子类重写父类的方法！
- 方法名必须相同
- 参数列表必须相同
- 修饰符：范围可以扩大，但不能缩小；public > protected > Default > private
- 抛出的异常： 范围，可以被缩小但不能扩大；ClassNotFoundException <— Exception(大)
重写，子类的方法和父类必须一致，但方法体不同！
为什么需要从写：
-
父类的功能，子类不一定需要，或者不一定满足！
Alt + Insert : override;
静态的方法和非静态的方法区别很大
多态
父类的引用可以指向子类，但不能调用子类独有的方法。
方法的调用只和左边定义的数据类型有关，和右边关系不大。
动态编译：类型：可扩展性更强
-
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
-
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）
-
多态存在的条件
- 有继承关系
- 子类重写父类方法
- 父类引用指向子类对象
//子类能调用的方法都是自己的或继承父类的 Student s1 = new Student();//子类 //父类可以指向子类，但是不能调用子类独有的方法 Person s2 = new Student();//父类 Object s3 = new Student(); /*一个对象的实际类型是确定的 可指向的引用类型不确定，父类的引用指向子类 */ //但是子类重写父类方法后，指向子类的方法 s2.run();//父类有，子类没有，子类继承父类方法 s1.run();//子类重写后，执行子类方法 s1.eat();//子类独有方法 ((Student) s2).eat(); //父类不能调用子类独有方法，会被强制转换为子类 -
注意：
多态是方法的多态，属性没有多态性
父类和子类，有联系才能转换，不然会异常！类型转换异常：ClassCastException
存在条件：继承关系，方法需要重写，父类引用指向子类对象！Father f1 = new son();
不能重写的方法：
- static 方法，属于类，它不属于实例
- final 常量 ，被final修饰的无法修改，属于常量池
- private 私有方法，不能被重写
-
instanceof 判断一个对象是什么类型。（类型转换—引用类型之间的转换）
System.out.println（x instanceof y）; ：true or false （能不能编译通过，看x所指向的实际类型是不是y的子类型）
public static void main(String[] args) { //比较 X instanceof Y 之间是否存在父子关系 //Object>String //Object>Person（父类）>Teacher（另一子类） //Object>Person（父类）>Student（子类） Object object = new Student(); System.out.println(object instanceof Student);//true System.out.println(object instanceof Person);//true System.out.println(object instanceof Object);//true System.out.println(object instanceof Teacher);//false System.out.println(object instanceof String);//false //Student类在Object类之内存在的关系， // Student,Person,Object,Teacher,String都属于Object类内 //Teacher和String与Student不存在父子关系所以显示false System.out.println("==================================="); Person person = new Student(); System.out.println(person instanceof Student);//true System.out.println(person instanceof Person);//true System.out.println(person instanceof Object);//true System.out.println(person instanceof Teacher);//false // System.out.println(person instanceof String);编译错误 //Student类在Peron类范围内存在的关系； // 由于String在Peron类之外，没有直接联系，所以提示错误 System.out.println("==================================="); Student student = new Student(); System.out.println(student instanceof Student);//true System.out.println(student instanceof Person);//true System.out.println(student instanceof Object);//true //System.out.println(student instanceof Teacher);编译错误 //System.out.println(student instanceof String);编译错误 //Student类在Student类范围内存在的关系， //由于String和Teacher在Student类之外，所以提示错误 }
转换
：- 父类引用指向子类的对象，不可以子类引用指向父类。
- 把子类转换为父类，向上转型；
- 把父类转换为子类，向下转型，强制转换（可能会丢失方法）
- 方便方法的调用，减少重复的代码，简介
//类型之间的转化 ： 父---子 //高 低 Person s1 = new Student(); //高转低可以直接转；低转高，需要强制转 // Student s2 = (Student) s1; s2.go(); //或((Student) s1).go();
static关键字详解
静态方法在类的时候就已经加载了
Static加上方式上叫静态方式，加上属性上叫静态属性。
静态属性
//静态属性
public class Student {
private static int age;//静态的变量，可以被类中共享，多线程比较常用
private double score;//非静态变量
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.age);//通过方法可以正常调用
System.out.println(s1.score);
System.out.println(Student.age);//静态变量，可以直接用类名进行调用
//System.out.println(Student.score);//非静态变量不可以。
}
}
静态方法
//静态方法
public class Student {
public void run(){
Student.go();
}
public static void go(){
}
public static void main(String[] args) {
Student.go();//静态方法不需要 new 可以直接调用
//由于静态方法在类生成的时候就已经存在，所以可以调用静态的
//Student.run(); 但不能调用非静态的，非静态方法需要 new 出来
new Student().run();
}//注解和反射
}
代码块
{
//代码块（匿名代码块）
}//创建对象的时候就已经创建了，在构造器之前
static {
//静态代码块
}//在类一加载就已经执行，而且只加载一次
排序，static只执行一次
public class Demo03 {
//第二加载；适用于赋初值
{
System.out.println("匿名代码块");
}
//第一加载；只在第一次执行
static{
System.out.println("静态代码块");
}
//第三加载
public Demo03() {
System.out.println("构造方法");
}
public static void main(String[] args) {
Demo03 s1 = new Demo03();
System.out.println("==========");
Demo03 s2 = new Demo03();
//第二次执行static不在执行
}
}
静态导入包
静态导入包后可以直接调用其方法；
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Demo03 {
public static void main(String[] args) {
System.out.println((int)(Math.random()*50));
//random()随机值，整数，范围（0-50）
//使用静态导入包后可以直接System.out.println(random());
System.out.println(PI);
}
}
final修饰的类不能被继承
抽象类
-
abstract 修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。
-
抽象类中可以没有抽象方法，但是有抽象方法的类一定要声明为抽象类。
-
抽象类，不能使用 new 关键字来创建对象，它是用来让子类继承的。
-
抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的。
-
子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法；否者该子类也要声明为抽象类，然后由子子类实现抽象方法。
“Abstract method in non-abstract class”
//abstract 抽象类 类 extends,单继承； （接口可以多继承）
public abstract class Action {
//约束~有人帮我们实现
//abstract,抽象方法，只有方法名字，没有方法的实现！
public abstract void doSomething();
}
//抽象类的所有方法，必继承了它的子类，都必须要实现它的方法
public class A extends Action {
//除非子类也是抽象方法，那就由子子类实现
@Override
public void doSomething() {
}
}
- 不能 new 这个抽象类，只能靠子类去实现它；只是约束
- 抽象类中可以写普通方法
- 抽象方法必须在抽象类中
报错“Missing method body, or declare abstract”
思考题
：
- 抽象类存在构造器吗?
- 抽象类存在的意义
接口
-
普通类
：只有具体实现 -
抽象类
：具体实现和规范（抽象方法）都有！ -
接口
：只有规范！自己无法写方法，专业的约束！约束和实现分离：面向接口编程~ -
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…”的思想。
“如果你是天使，则必须能飞。如果你是汽车，则必须能跑。”
-
接口的本质是契约
，就像我们人间的法律一样。制定好后大家都遵守。 -
OO的精髓，是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class，声明接口的关键字是interface
//interface 接口定义的关键字；接口都需要实现类
public interface UserSerbice {
// public void ss(){ } 报错；接口内不能写方法
//接口中的所有定义其实都是抽象的，默认 public abstract
public abstract void run();
void add(String name);
void delete(String name);
//接口还可以定义变量，所有定义的属性都是静态的常量
public static final int AGE = 99;
int ABC = 99;
}
作用
：
- 约束，规范
- 定义一些方法，让不同的人实现。多个人完成共同的工作。
- 接口中所有默认的方法public abstract
- 所有常量默认public static final
- 接口不能被实例化，接口中没有构造方法。
- 可以实现多个接口
- 必须要重写接口中的方法。
- 声明接口interface,实现接口implements，可以实现多个方法
public class Application {
public static void main(String[] args) {
xiaduan sxmz = new xiaduan();
sxmz.mingzi("上下没中");
sxmz.nianling(31);
sxmz.shengao(175.8);
sxmz.zhuzhi("内蒙古");
}
}
/*
//抽象类：extende
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
public class xiaduan implements jiekou,jiekou2 {
//利用接口实现多继承（jiekou,jiekou2）
//继承类可以方法的实现，但接口只有方法的定义
@Override//jiekou
public void mingzi(String name) {
System.out.println("名字："+name);
}
@Override//jiekou
public void nianling(int nl) {
System.out.println("岁数："+nl);
}
@Override//jiekou
public void shengao(double sg) {
System.out.println("身高："+sg);
}
@Override//jiekou2
public void zhuzhi(String zz) {
System.out.println("住宅："+zz);
}
}
*/
内部类(扩展知识)
-
内部类就是在一个类的内部在定义一个类，比如A类中定义一个B类，那么B累相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
public class Outer {//外部类
private int id = 10;
public void out(){
System.out.println("这是外部类的方法！");
}
public class Inner{//内部类
public void in(){
System.out.println("这是内部类的方法！");
}
}
//内部类可以获得外部类的私有属性
public void getID(){
System.out.println(id);
}
}
public static void main(String[] args) {
//外部类通过 new 获取
Outer outer = new Outer();
//内部类通过 外部类 . new 内部类 获得
Outer.Inner inner = outer.new Inner();
}
-
成员内部类
；类中加类//先实例化外部类，再用外部类实例化内部类 Outer outer = new Outer();//new外部 Outer.Inner inner = outer.new Inner();//new内部 inner.in（）；内部类可以获得外部类的私有属性
-
静态内部类；不能直接访问非静态的外部类属性
（static先于非静态类生成） -
局部内部类；
public void method(){ class inner{ public void in(){ } } } -
匿名内部类；没有名字去初始化类，不用将实例保存到变量中
//不起名直接使用 new Apple().eat(); //new接口 class Test{ public static void main(String[] args) { new UserService(){ }; } } interface UserService{ }
一个java类中，可以有多个 class 类，但只能有一个 public class 类
异常机制
目录：
-
什么是异常
-
异常体系结构
-
Java异常处理机制
-
处理异常
-
自定义异常
-
总结
什么是异常
- 实际工作中，遇到的情况不可能是非常完美的。比如：你写的某个模块，用户输入不一定符合你的要求；你的程序要打开某个文件，这个文件可能不存在或者文件格式不对；你要读取数据库的数据，数据可能是空的等；我们的程序再跑着，内存或硬盘可能满了。等等。
- 软件程序在运行过程中，非常可能遇到刚刚提到的这些异常问题，我们叫异常，英文是：Exception，意思就是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理，而不至于程序崩溃。
- 异常值程序运行中出现不期而至的各种状况，如：文件找不到，网络连接失败，非法参数等。
- 异常发现在程序运行期间，它影响了正常的程序执行流程。
简单分类
-
要理解 Java 异常处理是如何工作的，你需要掌握以下三种类型的异常：
-
检查性异常
：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如：打卡一个不存在文件时，一个异常就会发生了，这些异常在编译时不能被简单地忽略。
-
运行时异常
：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。 -
错误 ERROR
：错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。编译时不容易被发现。例如：当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
-
异常体系结构
-
Java 把异常当做对象来处理，并定义一个基础类 java.lang.Throwable 作为所有异常的超类。
-
在 Java API 中已经定义了许多异常类，这些异常类分为两大类，错误Error和异常Exception 。
Error错误
- Error 类对象有 Java 虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
- Java 虚拟机运行错误（Virtual MachineError），当 JVM 不再有继续执行操作所需的内存资源时，将出现 OutOfMemoryError。这些异常发生时， Java 虚拟机（JVM）一般会选择线路终止。
- 还有发生在虚拟机试图执行应用时，如类定义错误（NoClassDefFoundError）、链接错误（LinkageError）。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的情况。
Exception异常
-
在 Exception 分支中有一个重要的子类 RuntimeException （运行时异常）
- ArrayIndexOutOfBoundsException（数组下标越界）
- NullPointerException（空指针异常）
- ArithmeticException（算术异常）
- MissingResourceException（丢失资源）
- ClassNotFoundException（找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
- 一些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发现；
-
Error 和 Exception 的区别：Error 通常是灾难性的致命错误，是程序无法控制和处理的，当出现这些异常时，Java 虚拟机（JVM）一般会选择终止线程；Exception 通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这类异常。
异常处理机制
-
抛出异常
-
捕获异常
-
异常处理五个关键字
- try、catch、finally、throw、throws
可以当出现异常时，捕获它，防止程序停止。
public static void main(String[] args) { int a = 1; int b = 0; //假设要捕获多个异常：从小到大！不然会报错，提示大异常以及覆盖小异常 try { //try 监控区域 System.out.println(a / b); } catch (Error e) { //catch（想要捕获的异常类型！）捕获异常 System.out.println("Error"); }catch (Exception e){//“e”,代表异常消息 System.out.println("Exception"); }catch (Throwable t){ //最高级，放在最后面 System.out.println("Throwable"); }finally { //处理善后工作，不管报不报异常，都会执行。 System.out.println("finally"); } //finally 可以不用，但是catch必须有。finally假设Io,资源，关闭工作 //快捷键：选中需要包裹的代码，ctrl+alt+T /* try { System.out.println(a / b); } catch (Exception e) { System.exit(0);//程序结束 e.printStackTrace();//打印错误的栈信息 } finally { } */ }throw
try { if (b==0){ throw new ArithmeticException();//主动的抛出异常 }throws
public static void main(String[] args) { try { new linshi().test(1,0); } catch (ArithmeticException e) { e.printStackTrace(); } finally { } } //假设这个方法中，处理不了这个异常。方法上抛出异常throws，由上一级捕获。 public void test(int a,int b)throws ArithmeticException{ if (b == 0) { throw new ArithmeticException();//throw 主动的抛出异常,一般在方法内 } System.out.println(a / b); }
自定义异常
-
使用 Java 内置的异常类可以描述在编程时出现的大部分异常情况。除此之外用户还可以自定义异常。用户自定义异常类，只需继承 Exception 类即可。
-
在程序中使用自定义异常类，大体可分为以下几个步骤：
- 创建自定义异常类。
- 在方法中通过 throw 关键字抛出异常对象。
- 如果在当前抛出异常的方法中处理异常，可以使用 try-catch 语句捕获并处理；否则在方法的声明处通过 throws 关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
- 在出现异常方法的调用者中捕获并处理异常。
自定义异常类
//自定义异常类 //假设传递数字>10异常 private int tishi;//创建一个提示信息 public Demo01(int a) {//创建一个构造器传递消息 this.tishi = a; } //toString打印信息：异常的打印信息 @Override public String toString() { return "异常{" + "tishi=" + tishi + '}'; }throws抛出方法捕获
//创建一个可能会存在异常的方法 static void test(int a) throws Demo01 { System.out.println("传递的参数为："+a); if (a>10){ throw new Demo01(a); } System.out.println("ok"); } public static void main(String[] args) { try { //赋值并捕获 test(11); } catch (Demo01 e) { // if( ){ } 可以增加一些处理异常的代码块 System.out.println("注意："+e); } }throw方法内捕获
//创建一个可能会存在异常的方法 static void test(int a) { System.out.println("传递的参数为："+a); if (a>10){ try { throw new Demo01(a); } catch (Demo01 e) { System.out.println("注意："+e);; } } System.out.println("ok"); } public static void main(String[] args) { test(15); //赋值 }
实际应用中的经验总结
- 处理运行时异常，采用逻辑去合理规避同时辅助 try-catch 处理
- 在多重 catch 块后面，可以加一个 catch（Exception）来处理可能被遗漏的异常
- 对于不确定的代码，也可以加上 try-catch ，处理潜在的异常
- 尽量去处理异常，切忌只是简单地调用 printStackTrace()去打印输出
- 具体如何处理异常，要根据不同的业务需求和异常类型去决定
- 尽量添加 finally 语句块去释放占用的资源