黑马程序员--------------面向对象

------- android培训、java培训、期待与您交流！ ----------

面向对象

1.面向对象的概念。

a) 面向对象相对于面向过程而言的。

b) 面向对象和面向过程都是一种思想

c) 面向过程强调是功能行为。

d) 面向对象将功能封装对象，强调具备了功能的对象。

e) 面向对象时基于面向过程的。

2.面向对象的特征

a) 封装（Encapsulation）

i. 定义：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

ii. 好处：

1. 将变化隔离。

2. 便于使用。

3. 提高重用性。

4. 提高安全性。

iii. 封装的原则：

1. 将不需要对外提供的内容都隐藏起来。

2. 把属性都隐藏，提供公共方法对其访问。

iv. 封装的变现形式：

1. 私有。

2. 对于我们而言只要我们访问不到的地方就是封装。

b) 继承(Extends)

i. 继承的概述

1. 就是把类中的共性，单独提取出来。

2. 关键字extend。

3. 提高了代码的复用性。

4. 让类与类之间产生了关系，有了这个关系，才有了多态的特性。

5. 这个关系必须是类与类之间的所属关系才可以继承。

6. Java只支持单继承，不支持多继承（不严谨）。因为多继承容易带来安全隐患。（当多个父类中定义了相同功能但内容功能不同时，子类对象不确定要运行哪一个）但是java用另外一种机制体现形式来完成表示，多实现。

7. Java支持多层继承。（即a继承b，b继承c，c继承d.，d继承e......）

8. 如何使用一个继承体系中的功能呢个？

a) 想要使用体系 ，先查阅体系父类的描述，因为父类中定义的是该体系的共性功能。

b) 通过了解共性功能，就可以知道该体系的基本功能。

c) 那么在具体调用时，要创建最子类的对象，为什么呢？

i. 一是：因为有可能父类不能创建对象；

ii. 二是，创建子类对象可以使用更多的功能，包括基本的也包括特有的。

iii. 简单一句话：查阅父类功能，创建子类对象使用功能。

ii. 继承的特点

1. Super关键字

i. 注意：super语句一定呀定义在子类构造函数的第一行。

2. 变量：

a) 如果子类出现非私有的同名成员变量时，子类要访问本类中的变量，用this。子类要访问父类中同名的变量，用super。

b) Super使用和this几乎一致。

c) This代表的是本类对象的引用。Super代表的是父类对象的引用。

d) 父类引用指向子类对象（多态的特征）

i. 当只有子类和父类只有一个变量（变量在父类中）时候，这是 this与super都指向同一个变量的引用。

e) 在堆中父类加载才有子类加载。

3. 函数的覆盖：

a) 当子类出现和父类一模一样的函数时。

b) 当子类对象调用该函数，会运行子类函数的内容。

c) 如同父类的函数被覆盖一样。

d) 使用覆盖条件：

i. 子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

ii. 权限由大到小排序：public  >  默认  >  private（这里注意一点父类私有，子类不叫覆盖）

e) 静态只能覆盖静态。

4. 子类中的构造函数：

a) 在对子类对象进行初始化时，父类的构造函数也会运行。

那是因为子类的构造函数默认第一行有一条隐式的语句super();

Super():会访问父类中空参数的构造函数。而且子类中所有的构造函 数默认第一行都是super();

b) 为什么子类一定要访问父类中的构造函数。

i. 因为父类中的数据子类可以直接获取 。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问以下父类中的构造函数。

c) 结论（子类的实例化过程）：

i. 子类的所有的构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super();

ii. 当父类没有空参数的构造函数时，子类必须手动通过super或者this语句形式来指定访问的构造函数。

iii. 当然：子类的构造函数第一行业可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

iii. Final关键字（最终的意思）

1. Final可以修饰类，方法，变量。

2. Final 弊端是打破了封装性。

3. Final修饰的类不可以被继承，因为加了final后成了最终子类。

4. Final修饰的方法不可以被覆盖。

5. Final修饰的变量时一个常量，只能被赋值一次。即可以修饰成员变量，也可以修饰局部变量。当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性都给这些值起个名字方便与阅读。而这个值不需要改变，所以加上final修饰。全局常量例：public static final double PI = 3.14；

6. 内部类定义在类中的局部位置上，只能访问该局部被final修饰的局部变量。

iv. 抽象类

1. 抽象类特点：

a) 抽象方法一定要在抽象类中。

b) 抽象方法和抽象类都必须被abstract关键字

c) 抽象类不可以用new创建对象，因为调用抽象方法没意义。

d) 抽象类中的方法要被使用必须由子类复写其所有的抽象方法后，建立子类对象调用。

e) 如果子类只覆盖部分抽象类，那么该类还是一个抽象类。

2. 抽象类与一般类没有太大的的不同。

a) 该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体。通过抽象方法来表示。

b) 抽象类比一般类多个了抽象函数。

c) 抽象类不可以实例化。

3. 特殊：

a) 抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

v. 接口：

1. 抽象类里面的方法全都是抽象的，则可以通过接口的形式来表示。

2. Interface用于定义接口。

3. 接口定义时，格式特点：

a) 接口中常见定义：常量，抽象方法。

b) 接口中的成员都是固定修饰符。

i. 常量：public static final。

ii. 方法：public abstract

iii. 记住：接口的成员都是public。

4. 类与类之间是继承关系，接口与类是实现关系

a) 关键字：implements

b) 接口：是不可以创建对象的，因为有抽象方法。

c) 接口需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。

5. 接口可以被类多实现。

i. 对多继承不支持转换形式，java支持多实现。（因为接口没有实体，所以让子类任意定义）

ii. 一个类在继承一个类的同时来能实现多实现。

iii. 注意：

1. 不能出现一个类实现的两个接口中出现相同的方法名，但可以出现不同类型的方法。这样会出现错误。

2. 例：

a) 

iv. 接口的特点：

1. 接口是对外暴露的规则。

2. 接口是程序的功能扩展。

3. 接口可以用来多实现。

4. 类与接口之间是多实现，而且类可以继承一个类的同时实现多个接口。

5. 接口与接口之间可以有继承关系。

vi. 模板方法模式

1. 什么是模板方法？

a) 在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分。那么这时就将不确定的部分暴露出来。由该类的子类去完成。

2. 例：

a) 需求：获取一段程序运行时间。

b) 原理：获取程序开始和结束的时间并相减即可。

c) 获取时间的方法：

i. 在java.lang.包中的System.currentTimeMillis();

vii. 扩展：

1. 聚集：事物之间不单只有继承关系（谁是谁里面的一种），还有另外谁里面有谁的聚集关系。聚集中通过紧密联系程度不同再分出：

a) 聚合：例如球员是球队中的一个，球队中有球员。

b) 组合：比聚合中事物联系程度更加紧密，例如：手是人身体的一部分，心脏是身体的一部分。

c) 多态(polymorphism)

i. 定义：某一事物的多种存在体现形态。

ii. 多态的体现形式。

1. 代码体现形式：父类的引用指向了自己的子类对象。

2. 父类的引用也可以接受自己的子类对象。

iii. 多态的前提。

1. 必须是类与类之间有关系，要么继承，要么实现。

2. 通常还有一个前提，存在覆盖。

iv. 多态的优点。

1. 多态的出现，大大的提高程序的扩展性。

v. 多态的弊端。

1. 提高了扩展性，但是只能使用父类的引用访问父类中的成员。

vi. 函数的多态性体现：

1. 重载和覆盖。

vii. 对象的多态性。

1.  例：猫 x = new 猫()； 可以写成   动物 x = new 猫()；

a) 动物 a = new 猫()；也叫类型提升 或 向上转型。

b) 如果想要调用猫的特有方法时，如何操作？

i. 强制将父类的引用，转成子类类型。

ii. Car c = (cat)a;   c.catchMouse();

iii. 向下转型。

c) 注意：

i. 千万不要出现这样的操作，就是将父类对象转成子类类型。

ii. Animal a = new Animal();

iii. Car c = (cat) a;

d) 我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。

e) 多态自始至终都是子类在做着变化。

f) 接口型引用指向自己的子类对象。

i. 例：主板和显卡，声卡通过接口来连接。

ii. 

Interface PCI{Public void open();Public void close();}Class  MainBoard{Public void run(){System.out.println(“mainboard  run”);}Public void usePCI(PCI P){If(p!=null)P.opern();P.close();}}

 

viii. （重点）多态中成员的特点。

1. （非静态）成员函数的特点：

a) 在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

b) 在运行时期：参阅对象所属的类中是否有调用的方法。

c) 简单总结：成员函数在多态调用时，编译看左边，运行看右边。

2. （静态）成员函数的特点：

a) 无论编译和运行，都参考左边。（因为静态优先于对象存在，并且不属于对象）

3. 成员变量的特点：

a) 无论编译和运行，都参考左边（引用型变量所属的类）。

 

 

3.Object的类。

a) 类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

b) 只要new一个对象出来就能用Object里面的所有方法。

c) Equanls方法

d) Object 中的equals比较的是对象（也就是地址值）。

e) 如果自定义类中也有比较相同的功能，没有不要重新定义。

f) 只要沿袭父类中的功能，建立自己特有比较内容即可。这就是覆盖。

g) toString方法

h) 打印的是（对象所属的类，@符号分割。对象的哈希值）

4.类与面向对象的关系。

a) 类就是：对现实生活中事物的描述。

b) 对象： 就是这类事物实实在在存在的个体。

5.成员变量与局部变量

a) 类中成员有三个：

i. 变量。

ii. 函数。

iii. 构造函数。

b) 成员变量与局部变量的区别

i. 作用的范围不同。

1. 成员变量：作用于函数中，或者语句中

2. 局部变量：作用于整个类中

ii. 内存中的位置

1. 成员变量：在堆内存中。因为对象的存在才在内存中存在。 

2. 局部变量：存在于栈内存中

iii. 不赋值能否直接参与运算

1. 成员变量：能参与直接运算因为在堆内存中，有默认初始化值。

2. 局部变量：不初始化不能参与直接运算，因为在栈内存中。

iv. 当局部变量与成员变量同名时，在函数中先在局部中找局部变量，没找到才到成员变量中找成员变量。

6.匿名对象

a) 匿名对象是对象的简化形式。

b) 匿名对象两种使用情况。

i. 当对对象方法仅进行一次调用时，可以用匿名对象来完成，这样写比较简化。如果对一个对象进行多次成员调用。必须给这个对象起个名字。

ii. 匿名对象可以作为实际参数进行传递。

c) 举例：

Car c1 = new Car();

C.num = 5;

这两句话简写成一句话：

New.Car.num =5;

 

d) 匿名对象于有名对象有什么不同。

i. 匿名对象调用属性没有意义，调用方法比较有意义。原因：

7.构造函数

a) 特点

i. 函数名与类名相同。

ii. 对象一建立就调用与之对应的构造函数。

iii. 不用定义返回值。

iv. 不可以写return语句。

b) 作用：

i. 给对象初始化。

c) 注意：

i. 默认构造函数的特点。

ii. 多个构造函数是以重载的形式存在的。

iii. 当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数。否则对象时建立不出来的，因为对象没有办法初始化。

d) 构造函数与一般函数区别：

i. 构造函数和一般函数在写法上有不同。

ii. 在运行上也有不同

1. 构造函数是在对象一建立就运行，给对象初始化。

2. 而一般方法是对象调用才执行。给对象添加对象具备的功能。

3. 一个对象建立，构造函数只运行一次。

4. 而一般方法可以被该对象调用多次。

e) 构造代码块：

i. 作用：

1. 给对象进行初始化。

ii. 运行：

1. 对象一建立就运行，而且优先于构造函数执行。

iii. 和构造函数的区别：

1. 构造代码块是给所有对象进行统一初始化。

iv. 构造代码块中定义的是不同对象共性的初始化内容。

f) 构造函数私有化。

i. 如果该构造函数私有化就代表着该对象不能被创建。

ii. 如果该类所有的构造函数私有化代表着这个是不可能创建对象的，因为对象时不可能初始化动作。

8.This关键字

a) This的特点：

i. 

b) This看上去，用于区分局部变量与成员变量同名情况。

c) This为什么可以解决这个问题？

i. 成员间互相调用的时候，其实都是对象完成的。

d) This到底代表的是什么？

i. 代表的它所在函数所属对象的引用。

ii. 简单说：那个对象在调用this所在的函数，this就代表那个对象。

e) This关键字在构造函数间的调用。

i. This语句：用于构造函数间互相调用。This（name）；

f) 注意：

i. This语句只能放在构造函数的第一行。

ii. 因为要先执行初始化，初始化动作里面还有初始化动作，则执行更细节的初始化动作。

iii. 小心出现调用死循环。

9.Static(静态)关键字

a) Static 关键字：

i. 是一个修饰符，用于修饰成员（成员变量和成员函数）

b) 被修饰后的成员具备以下特点：

i. 随着类加载而加载，随着类的消失而消失。说明生命周期长。（也就是说这个类进内存的时候，这儿静态就已经存在了）

ii. 静态优先于对象存在。

iii. 被所有对象所共享。

iv. 可以直接被类名调用。用法：类名。静态成员

c) 实例变量和类变量的区别：

i. 存放位置。

1. 类变量：随着类的加载而存在与方法区中。

2. 实例变量：随着对象的建立而存在也堆内存中。

ii. 生命周期。

1. 类变量：生命周期最长，随着类的消失而消失。

2. 实例变量：生命周期随着对象的消失而消失。

d) 使用注意事项：

i. 静态方法只能访问静态成员（原因存在的前后顺序。）

ii. 静态方法中不可以写this, super关键字。（因为静态优先于对象存在）

iii. 主函数是静态的。

1. 是一个特殊的函数，作为程序的入口，可以被jvm调用。

2. 主函数的定义。

a) Public：代表着该函数访问权限是最大的。

b) Static： 代表主函数随着类的加载就已经存在了。

c) Void： 主函数没有具体的返回值。

d) Main：不是 关键字，但是个特殊的单词。可以被jvm识别。

e) （String[] arr）：函数的参数，参数类型是一个数组。该数组中元素师字符串，字符串类型的数组。

f) Args： 是arguments（参数的意思）的简写。

g) 主函数死固定格式：jvm识别。

h) jvm调用main函数时，传递的只有两种：一是数组（实体），二是null。而jvm传的是new String[0]；

i) 如果想改变主函数传的值，可以在命令行运行时后面加入字符串,以空格隔开，并且jvm会自动封装和存储：

例：Java  mainDemo  haha  hehe  heihei

e) 静态的有缺点

i. 利处：

1. 对对象的共享数据进行单独空间的存储，节省空间。

2. 可以直接被类名调用。

ii. 弊端：

1. 生命周期过长。

2. 访问出现局限性。

f) 什么时候使用静态？

i. 要从两方面下手：因为静态修饰的内容有成员变量和函数。

1. 什么时候定义静态变量（类变量）呢？

a) 当对象中出现共享数据时，该数据被静态所修饰。

b) 对象中的特有数据要定义成非静态存在于堆内存中。

2. 什么时候定义静态函数呢？

a) 当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

g) 静态的应用工具类

i. 每个应用程序中都有特性的功能，可以将这些功能进行抽取，独立封装以便复用。

h) 静态代码块

i. 格式：

Static

{

静态代码块的执行语句。

}

ii. 特点：

1. 随着类的加载而执行，只执行一次。（即只要用到类的内容就加载）

2. 用于给类进行初始化。

10.对象的初始化过程

Person p = new person(“zhangsan”,20);

a) 以为new用到了person.class所以会先找到person.class文件并加载到内存中。

b) 执行该类中的static代码块，如果有的话，给person.class类进行初始化。

c) 在堆内存中开辟空间，分配内存地址。

d) 在堆内存中建立对象的特有属性，并进行默认初始化。

e) 对属性进行显示初始化。

f) 对对象进行构造代码块初始化。

g) 对对象进行对应的构造函数初始化。

h) 将内存地址赋给栈内存中的p变量。

11.对象调用过程

a) 

12.单例设计模式

a) 解决一个类在内存只存在一个对象问题。

b) 要保证对象的唯一。

i. 为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。

ii. 还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。

iii. 为了方便掐程序对自定义对象的访问，可以对外提供一些访问方式。

 

 

c) 单例设计模式一：饿汉式

i. 这个是先初始化对象。

ii. Single类一进内存，就已经创建好了对象。

iii. 这三步用代码体现：

1. 将构造函数私有化。

2. 在类中创建一个本类对象。

3. 提供一个方法可以获取到该对象。（方法被调用只有两种方式：一：对象调用二：类名调用）

4. 

iv. 如何使用。

1. 对于事物该怎么描述，还怎么描述。

2. 当需要将该事物的对象保证在内存中唯一时，就将以上三步加上即可。

d) 单例设计模式二：懒汉式

i. 对象是方法调用时，才初始化。也叫做对象的延迟加载。

ii. Single类进内存，对象还没有存在，只有调用了getInstance方法时 ，才建立对象。 

iii. 

iv. 懒汉式的缺点与优化：

1. 因为线程问题，可能导致创建两个对象。

2. 所以加入同步。

3. 

 

e) 饿汉式与懒汉式的区别：

i. 类一加载，饿汉式的s就有值，指向对象，而懒汉式则为null，等调用getInstance()方法时才指向对象。

13.内部类

a) 将一个类定义在另一个类的里面，对里面那个类就称为内部类。（内置类，嵌套类）

b) 内部类能被私有，当内部类在外部成员位置时，这个内部类的特点

c) 内部类的访问规则：

i. 内部类可以写在类的任意位置上。

1. 内部类定义在局部内时

a) 是不能被成员修饰符修饰。例如：定义静态成员的。

b) 可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的变量。

ii. 内部类可以直接访问外部类的成员，包括私有成员。

1. 之所以可以直接访问外部类的成员，是因为内部类中持有一个外部类中的引用。格式：外部类名.this

iii. 而外部类访问内部类的成员必须要建立内部类的对象。

d) 访问格式：

i. 当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

ii. 可以直接建立内部类对象。

iii. 格式

1. 外部类名。内部类名  变量名 = 外部类对象。内部类对象。

2. 当内部类在成员位置上，就可以被成员修饰符所修饰。

a) 比如，private：将内部类在外部类中进行封装。

b) Static：内部类就具备了静态的特性。

i. 当内部类静态修饰后，只能直接访问外部类中的静态成员。出现了访问局限。

ii. 在外部其他类中，如何直接访问static 内部类的非静态成员呢？

1. New Outer.Inner().function();因为是静态类名加载就能直接调用。

iii. 在外部其他类中，如何直接访问static 内部类的静态成员呢？

1. Outer.Inner().function()；

iv. 注意：

1. 当内部类定义了静态成员，该内部类必须是static的。

2. 当外部类中的静态方法访问内部类时，内部类也必须是static

3. 但局部内部类，是不能定义静态成员的。

 

e) 内部类的格式：

i. 一种是：由从外部类一直开始访问到内部类访问。

1. Outer out = new Outer();

2. Out.method();

ii. 另一种是：直接访问内部类。

1. Outer . Inner in = new Outer() . new Inner();

2. In.function();

iii. 内部类中的变量：

1.

 Class Outer{a) Private int x = 3;}Class Inner{Int x = 4;Void function(){Int x = 6;System.out.println(“inner:”+x);//这个x=6；System.out.println(“inner:”+this.x);//这个x=4;System.out.println(“inner:”+Outer.this.x);//这个x=3;}}

2. Outer.this.x这就是之所以内部类能访问外部类的原因。

f) 什么时候使用内部类？

i. 当描述事物时，事物的内部还有事物，该事物用内部类来描述。

ii. 因为内部事物在使用外部事物内容。

iii. 例子：人体与心脏

g) 匿名内部类：

i. 匿名内部类其实就是内部类的简写格式。

ii. 定义匿名内部类的前提：

1. 内部类必须继承一个类或者实现接口。

iii. 匿名内部类的格式：new父类或者接口(){定义子类的内容}

iv. 其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，可以理解为带内容的对象。

v. 匿名内部类中定义的方法最后不要超过三个。

14.异常

a) 异常就是程序运行时出现不正常情况。

b) 异常的由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

c) 对问题划分两种：一种是严重问题，一种非严重的问题。

i.  严重问题：java通过Error类进行描述。

1. 对于Error一般不编写针对性的代码对其进行处理。

ii. 对于非严重的，java通过Exception类进行描述。

1. 对于Exception可以使用针对性的处理。

d) Throwable

i. |----Error

ii. |----Exception

Try{需要被检测的代码。}Catch(异常类 变量){处理异常的代码；}Finally{一定会执行的语句；}

e) 对捕获到的异常进行常见方法操作。

i. String getMessage();获取异常信息。

f) 在函数上声明异常：

i. Throws的关键字声明了该功能有可能出现问题。

ii. 便于提高安全性，让调用出进行处理，不处理编译失败。

g) 对多异常的处理。

i. 声明异常时，建议声明更为具体的异常，这样处理就能更具体。

ii. 对方声明几个异常，就对应有几个catch块。

1. 如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

h) 建立在进行catch处理时，catch中一定要定义具体处理方式。

i. 不要简单定义一句e.printStackTrace();

ii. 也不要简单的就书写一天输出语句。

i) 自定义异常

i. Throw关键字：手动抛出一个自定义异常对象。

ii. 当在函数内部出现了throw 抛出异常对象，那么就必须要给对应的处理动作。

1. 要么在内部try catch处理。

2. 要么在函数上声明让调用着处理。

3. 一般情况下，函数内出现异常，函数上需要声明。

iii. 必须是自定义类继承Exception/Throwable/Error

1. 原因：

a) 异常体系有一个特点：因为异常类和异常对象都被抛出。

b) 他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

c) 只有这个体系中的类和对象才可以被throws和throw操作.

iv. Throws和throw的区别：

1. Throws使用在函数上。

2. Throw使用在函数内。

3. Throws后面跟的异常类，可以跟多个，用逗号隔开。

4. Throw后面跟的是异常对象。

v. 特殊异常子类runtimeException

1. 如果在函数内抛出该异常，函数上可以不用声明，编译一样通过。

2. 如果在函数上声明了该异常，调用者可以不用进行处理。编译一样通过。

3. 之所以不用再函数声明，是因为不需要让调用者处理。

4. 当该异常发生，希望程序停止。因为在运行时，出现了无法继续运行的情况。希望停止程序后，对代码进行修正。

vi. 对异常分两种：

1. 编译时被检测的异常。

2. 编译时不被检测的异常。（运行时的异常，runtimeException以及其子类）

vii. Finally代码块：

1. 定义一定执行的代码。

2. 通常用于关闭资源。

viii. 异常处理的其他方式。

1. 方式一：Try

i. {}

ii. Catch

iii. {}

2. 方式二：try

i. {}

ii. Catch

iii. {}

iv. Finally

v. {}

3. 方式三：try

i. {}

ii. finally

iii. {}

j) 注意：

i. Catch是用于处理异常，如果没有catch就代表异常没有被处理过，如果该异常的检测时异常，那么必须声明。

k) 异常在子父类覆盖中的体现：

i. 子类在覆盖父类时，如果父类的方法抛出异常，子类的覆盖方法， 只能抛出服了的异常或该异常的子类。或者不抛。

ii. 如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出异常的子集。

iii. （重点）如果父类或者接口方法中没有异常抛出，那么子类在覆盖方法时也不可以抛出异常。如果子类方法发生了异常，就必须要try处理，绝对不能抛。

iv.