java面向对象笔记

**

类和对象

**
oop的三大特性；
封装，继承，多态
Java要素；类、对象、封装、继承、多态、抽象类、接口、java异常
面向对象程序设计object oriented programming (简称oop)
封装；（把代码通过类或方法包装起来，不需要知道其具体的细节，通过对象重复调用使用）

1. 开发方法
   a) 结构化开发（如c语言）
   i. 以功能来进行划分区域
   ii. 从上向下开发
   iii. 最小的子系统是方法
   iv. 缺点是可维护性差，不便于系统升级
   b) 面向对象开发
   i. 以对象来进行划分，把系统当做对象的集合
   ii. 系统结构稳定
   iii. 子系统相对独立
   iv. 可重用性，可维护性，可扩展性较高

2. 开发周期
   a) 需求确认
   b) 设计框架
   c) 软件开发
   d) 周期维护

3. 软件要求
   a) 可扩展性
   b) 可重用性（无需重写）
   c) 可维护性（便于维护）

4. 什么是对象（客观描述事物的一个实体，由一组属性和方法构成）
   a) 万物皆对象
   b) 一个类别里的具体的对象叫做对象（具体到某一个）
   c) 对象的属性取决于类的类型
   类是对象的抽象，对象是类的具体

5. 什么是类（具有相同属性和方法的一组对象的集合）
   a) 一些相同的对象组成的集合称为类（不能具体到某一个）

6. 描述一个对象的特征的时候我们称之为属性（每一个属性都有一个对应的属性值）
   要求实现的效果不同对象执行的操作也会不同，对象的特征也可能发生改变（理解对象的属性与方法之间的关系）

7. 描述一个对象的行为的时候我们称之为方法（对象执行的操作）

8. 书写结构顺序（先写类在写对象，由大到小）

9. 每一个类也可称之为数据类型（自定义的数据类型）

10. 语法要求

11. 定义一个自定义的类

a) 定义类的属性，不需要赋值
b) 定义一个方法（即对象的操作，执行的任务）
c) ShowInfo为方法名，可以改变
d) return返回数据，赋予给showinfo方法，方便以后使用
e) info为定义的字符串名，可以改变
12. 使用类图（用于分析和设计类，特点容易理解）
a) 画图工具Visio、rose

b) 类图分析
i. Dog为类名
ii. Name、health、love、strain、为dog的属性
iii. Print为方法名；void返回的值；

iv. +号代表public，（作用域）
13. 创建对象
a) 类名（创建的类名也是写类的文件名）对象名（自己写的名，跟变量名一样）=new 类名（创建的类名也是写类的文件名）（）；
14. 使用对象的属性和方法

a) 对象名（自己写的名，跟变量名一样）.（属性）
b) 对象名（自己写的名，跟变量名一样）.（方法）

---

**

构造与方法的重载

**

1. 参数的类型（能通过 . 出来的都为引用数据类型，不能的为基本数据类型）
   a) 基本数据类型（int Boolean char等）
   b) 引用数据类型（自定义数据类型，数组，接口等）、
2. 方法传参（参数的传递）
   a) 数据为基本数据类型时，参数的变化不保留（传输基本数据时传输的为复制的数据，不是原数据，对象不同，数据的值不会改变）
   b) 数据为引用数据类型时，参数的变化会保留（传输引用数据类型时传输的为数据的地址，为同一对象，数据的值会改变）
3. Main方法调用方法必须要new（main方法为静态方法）
4. 对象数组（存放对象的数组）
5. 用构造方法对对象进行赋值
   public GoCoHanSuOopDemo1(){
   System.out.println();
   }（建立空的构造，在不需要用的情况下可以不建立）
   public GoCoHanSuOopDemo1(String name,int age){
   names=name;
   ages=age;
   }（建立需要赋值的构造且设置参数）
   a) 使用构造方法
   public static void main(String[] args) {
   GoCoHanSuOopDemo1 name=new GoCoHanSuOopDemo1(“账上”,28);
   }新建对象且对对象设置参数
   b) 建立一个空的构造
   c) 利用架构对其赋值（public后面不需要加返回类型）
   d) 在建立对象的时候后面加上需要赋值的值（赋值的值必须与架构的参数的类型一样，顺序也要一样）
6. 方法名可以重复但在相同的方法名中方法的作用不能一样不让回导致方法重载
7. 方法
   a) 有返回值无参数 有返回值有参数
   b) 有参数无返回值 无返回值无参数
8. This应用
   a) 用于在当前方法的属性（变量名重复时）
   b) 用于在当前包里的方法（调用同一个包的方法）
   c) 语法
   i. （属性）
   ii. （方法）
9. 每个类都有一个默认的无参构造方法（如果加了有参的构造方法进类中，无参的构造方法将不在有需要使用时，必须自己写）
10. 方法重载
    a) 在同一类下可有多个同名不同参的方法
    b) 方法重载注意其方法名是否一样和参数值是否不一样
    c) 方法重载时，系统将会使用最适合的方法

---

**

封装

**
封装一

1. 局部变量
   a) 局部变量是在一个方法内（或更小的语句）声明的变量（作用域为整个方法）
2. 全局变量（成员变量，全局变量大于局部变量）
   a) 一个方法由成员变量和成员方法组成
   b) 全局变量是声明在一个类的范围内的变量（作用域为整个类）

c) 全局变量在其他的类里能通过创建对象进行调用
3. Java会给成员变量一个初始值而局部变量不会有，在使用局部变量时必须给它赋值且局部变量可以与全局变量同名（如果同名，在使用时会就近原则使用最近的变量即局部变量将全局变量值覆盖），在不同的方法里可以有同名的变量，但在一个方法里不能有同名的两个变量
4. 封装的用处（解决一些属性值范围不明确，用户可以对其随意赋值却又不可理的bug）
5. 封装的定义；将类的一些信息隐藏在类的内部，不允许直接访问而是通过类的方法来对其进行访问和操作从而达到数据的合理性，安全性
6. 封装的两大基本原则
a) 尽可能的把所有属性隐藏
b) 尽可能多的隐藏，对外提供便捷的接口
7. 基本的思路

a) 将属性修改为私有的
b) 对隐藏的属性建立一对（setter（赋值，一般写法为set（属性名）set不需要返回值，用于对属性赋值）/getter（读取一般写法为get（属性名）get需要返回值，返回类型与属性类型一样，用于用户访问隐藏的属性）可以修改属性的方法，通过方法里的判断来对属性进行修改（方法必须是公开的）
8. 语法

9. 在类里面不能直接书写功能块（逻辑块），类里只能有属性和方法
10. 权限修饰符（通过修饰符来对属性进行隐藏，从而对其进行封装）
    a) 属性和方法默认情况下在别的包中不能调用
    b) Public；公有的，用public修饰的属性和方法在整个项目中度都可以使用
    c) Protected；受保护的。只能在本包中使用，继承关系下子类能使用
    d) 默认；只能在本包中使用
    e) Private；私有的，private修饰的属性和方法只能这本类中使用。
11. 封装的优点
    a) 有助于用户正确的使用，防止错误的修改属性
    b) 有助于系统之间的松耦合（耦合，指的是系统间的小模块粘连在一起，不好分割），提高系统的独立性
    c) 提高软件的可重用性
    d) 降低了构建大型系统的风险
    **

封装二

**

1. 包机制
   a) 包相当于目录，可以放多个类
   b) 不同包的可以存放相同的类名
2. 命名规范
   a) 包名命名必须是小写

b) 包前加前缀，通常用网络域名
c) 包后续部分自定义
3. 引用不同包下的类；import .（包名）.（类名）
4. Package在一个人类里只能出现一次，import可以出现多次，除注释外，package必须声明在第一句，import在class前面声明
5. 自己建立的为用户包，java自带称为系统包
6. 使用多个不同包里的相同类名的类需要指定那个包即在建立对象时写上包名（不同于导包，只是声明加载的对象累的完整限定名）

---

**

继承（继承最顶层一般为抽象类）

**

1. 继承；将一些具有相同特性的属性写在同一个父类中，让其余的子类继承父类特性的属性，在java中只支持单根继承即就只有一个直接父类（直接父类即它的上一级），在具有is—a的关系的时候就可以用继承来编写代码，
2. 父类（也称为基类）将所有相同的属性放在一起，给其他类继承用
3. 父类与子类是is—a的关系（is—a意思是必须是同一种类别）
4. 继承关键字extends（extends前面写子类名，后面写父类名）
   a) 书写继承语法顺序

b) 语法
i. 创建新的类，将其成为父类，将公共的属性特性写在这个公共的父类中（class pet{ （公共的属性和方法） }）
ii. 编写子类，将独有的特性属性和方法写在子类中（class dog extends pet{ 子类的特有属性和方法}）
5. Protected修饰符的方法和属性在同类、同一包、子类中都能访问，在不同的包中只要是父子关系也能进行访问
6. 子类继承的了父类被public、protected修饰的所有方法和属性（不管在不在同一个包下）、还继承了在同一包下的默认修饰的属性和方法，不能继承被private修饰的属性和方法、不在同一个包下被protected修饰的属性和方法和所有的构造方法
7. Super只能写在第一句并出现在子类的方法和构造中，代表的是父类对象
8. 继承的缺点；系统的独立性降低，不利于以后的修改，修改后的影响较大

---

**

类的方法

**

1. 类的方法分类
   a) 带参方法（方法名后的括号不为空，main（String[]args））
   b) 无参方法（方法名后的括号为空, study ( )）
2. 类的方法结构
   a) Public 返回值的类型 方法名（）{
   //书写方法的主体即方法体（实现的效果，要做的操作）
   }
3. 类的方法的返回值类型
   a) Return；返回一个方法相同的数据类型，在后面的代码不会再运行，不能写，
   i. 作用
4. 返回结果
5. 跳出方法
   ii. return返回的变量类型必须与方法的数据类型相同(声明有返回值是必须写，返回的类型要一样)
   iii. return只能返回一个值或者是一个表达式，不能返回多个

b) Void;
i. 在没有返回值得情况下使用（没有返回值时方法结构的返回值的数据类型不能不写）
ii. 没有返回值时，在调用方法时不需要定义数据类型去接收
c) 方法有没有返回值和方法有没参数没有关系
4. 调用类的方法
a) 在方法里调用方法（两个类方法相互调用）

必须创建另一个新类的对象，通过对象再来调用另一个方法
b) 在自定义的方法里调用自定义的另一个方法
i. 在同一包下，直接调用，直接书写方法。
5. 在方法里定义的变量称为局部变量（this代表当前对象的引用，即全局变量（同一方法里的最大的作用域））局部变量与全局变量重名时必须要用this。
6. 带参方法（设置参数是用来与方法里的元素进行传输或者在方法里进行输出，设置参数时必须定义类型）

a) 方法定义
i. Public String zhazhi(String fruit){ （定义参）

}
String furit带参方法必有的，称为形式参数，也称为形参，只约束参数的类型（furit可以改变，为定义的形参名字，一般用于方法体中）
ii. String zhi = ji1.zhaZhi ( shuiGuo )（传参）
iii. shuiGuo称为实际参数，也称为实参，可以给变，类型必须与形参一样。
iv. 形参和实参的数据类型必须一样，名字可以一样，也可以不一样
v. 参数可以有多个，用逗号隔开，形参和实参的数量必须要一样（定义了多个参数就需要写多个参数）
b) 语法

c) 调用参数时不要声明数据类型

---

**

方法重写（又称方法的覆盖）

**

1. Super

a) 使用super关键字，super代表父类对象
b) 在子类构造方法中调用必须在第一句
c) 不可以访问父类中被private修饰的方法和属性
d) 通过super . （方法名或属性名）调用方法或属性（必须不是private修饰的才可以进行调用）
e) 调用父类构造方法；通过super （构造的参数）进行调用调用时就只能调用一种，不能有参无参构造一起调用且必须是写在第一句调用
f)
g)
2. 方法重写时用super对需要的方法进行调用，（构造方法不能被重写）
3. 只有普通方法可以重写
4. 方法重写的要求
a) 方法名必须一样
b) 参数列表必须一样
c) 返回的类型相同或是其子类（即返回值是父类中的一个子类）
d) 访问权限不能小于父类的访问权限
e) 静态方法不能重写为非静态的，非静态的也不能重写为静态的方法
f)
5. 方法重载与方法重写的区别

---

**

Object类

**

1. Object类
   a) Object是所有类的父类
   b) To String返回的对象信息

2. Super与this的区别

4. Object的方法重写；

5. 重写equalss
   a) 默认情况下equalss与==一样都是比较两个对象是否一样
   b) 语法
   i.

6. 先建立父类，书写父类的属性并写出相应的set get有参和无参方法

7. 重写object类（object默认为所有类的父类）中的equals方法

8. 比较object的对象与当前对象是否是同一个地址，然后在比较两个对象是否是同一种类型，在比较两个对象的属性是否一样（或者将object的对象向下转型为当前对象的类型在比较两个对象的属性是否一样）一样返回为true不一样返回为flash

9. toString()方法重写
   a) 语法

b) Alt+shift+s键选择to string 系统自动生成重写tostring的方法
c) Tostring方法的使用
i.
ii. 利用syso进行输出，输出的为对象中的值
iii. 数组不能用tostring进行输出数组中的值（用arrays进行输出）
7. instanceof 操作符判断某一个对象是否是某一个类型

---

**

静态

**

1. 访问权限控制（只作用当前的范围内，在范围之外无法进行访问）

2. 访问控制修饰符
   Public 默认 protected private
   默认情况下什么都不写

3. 类的访问控制（只有两种访问控制来修饰）
   a) Public（公有访问级别，谁都可以进行访问）
   i. 在不同的包下面访问需要导进去相应的包
   b) 默认 （包级私有访问级别，在本包下可以进行访问，在其他包中不能进行访问）

4. 类成员的访问控制（四种都可以）

5. Static修饰符（不属于访问修饰符）

6. 没有被static修饰的变量为实例变量，存储空间为多个，每一次调用都是在不同的空间上进行，会对其值进场初始化，
   被static修饰的变量称为静态变量（类变量），可以通过类名直接调用，它只有一个存储的空间，在每一次调用的时候不会对其初始化依旧保留上次赋予的值，
   被static修饰的方法称为静态方法，可以通过类名直接调用方法
   被static修饰的代码块称为静态代码块

7. 静态方法
   a) static静态方法（静态方法必须要有大括号，不能在实例方法里定义静态变量，只可以在类里面定义静态变量）
   b) 静态方法；不能用this和super，在静态方法里不能访问实例变量和实例方法，只能访问静态的方法和变量
   c) 实例方法；通过实例进行访问，可以访问静态变量、静态方法、实例变量和实例方法，

8. 静态块
   a) 语法书写

b) 多个静态块在一起的时候按顺序加载
c) 每一个静态代码块就只会加载一次
Static{ （代码） }
Static{ （代码） }

---

**

多态

**

1. 多态；同一个引用类型，使用不同的实例而执行不同的操作（多个对象进行操作后呈现多个不同的结果）
2. 多态的应用
   a) 使用父类作为方法的形参（主要形式）
   b) 使用父类作为方法的返回值（另一种主要形式）
3. 父类引用指向子类对象（向上转型）
   a) （父类类名）（父类对象）=new（子类类名）
   b)
4. 方法重写是实现多态的基础
5. 抽象方法（没有方法体的方法）
   a) Public abstract void pet（）;
   i. Abstract为抽象关键字，必须写
   b) 抽象方法在必须要有共同的行为，却又没有去实现的时候才能使用（有共同的行为方式又不能用父类去统一实现）
6. 抽象类（有抽象方法的类就是抽象类，抽象类不一定有抽象方法）
   a) 普通方法里不能写抽象方法必须改为抽象类
   b) 普通类改为抽象类
   i. Public abstract class Pet{ }
   ii. Abstract为普通类的转换为抽象类的关键字，必须要有
   c) 抽象类不能被实例化（即不能Pet pet=new Pet（））
   i. 在抽象类中不能建立本身的对象，但可以作为引用类型建立具体子类（子类是普通类的情况下）的对象
   d) 抽象类的子类可以是普通类也可以是抽象类
   i. 在普通子类里必须要实现（重写）抽象类中的抽象方法
   ii. 在抽象子类里可以不实现（重写）抽象类中的抽象方法
7. 向上转型（父类引用指向子类对象）

a) 通过转型后对象引用的是继承或覆盖后的父类方法（也是具体的子类的方法）而不是引用原来父类的方法
b) 转型后的对象无法再调用子类特有的方法，只能调用父类和子类所公有的方法
8. 向下转型

a) 通过转型后父级引用指向子类对象能调用子类中特有的方法（即将父级引用指向子类的对象强制转换成子类的对象）
b) 利用instanceof进行向下转换可以降低转换错误，提高运行时的正确率
9. 父类里面是抽象类的时候，子类不能显示写出super方法只能给非抽象的方法
10. 工厂模式
a) 简单工厂模式（在工厂类中根据用户传进来的数据进行生产对应的产品，返回一个抽象产品类型给客户）一般是写成static方法（方便在调用时不要创建实例）

i. 工厂类（就是调用者也是生产的生产者）
ii. 抽象商品类（就是对象的父类，客户返回的类型）、
iii. 具体产品类（就是子类，抽象类的子类）
iv. 客户（测试类）

---

**

抽象类

**

1. 在普通类class前加abstract进行声明为抽象类

2. 抽象方法没有方法体

3. 抽象类不能被实例化但可以作为引用类似进行引用（即父类类型引用指向子类类型）

4. 抽象类可以没有抽象方法，有抽象方法一定要是抽象类

5. 如果子类没有实现父类的抽象方法，子类必须要是抽象类

6. 没有抽象的构造方法，也没有抽象的静态方法

7. 抽象类中可有非抽象类的构造方法，方便子类使用

8. Main方法必须写在公共类中，一个类只能有一个public 修饰的类，但可以有多个非public类（写在public类的外面，有class加类名叫括号表示即（ class pet（ ）{ } ） ）公共类名必须与文件名一致

9. 抽象父类里有无参构造方法，子类继承父类，通过父类类型引用子类对象先走父类的构造方法，在走子类的构造方法
   接口（interface）
   （一个对象具有两种属性，且两种属相不是同一个类）
   系统对外提供的所有服务且用interface修饰的称为接口

10. 功能模块最小化（尽可能的把所有的相同功能的代码放在一起，减少代码的冗余，加强系统的可扩展性）

11. 接口；（解决子类要继承多个父类的方法，而又不能用继承来完成的时候使用，满足has - a 的关系）
    a) 写法；将类的class去掉给成interface，其余不变（即 public interface Pet）
    i. Interface为接口关键字、Pet为接口名
    b) 实现接口（public class 类名 interface 接口名）
    i. Interface为关键字不能缺少
    c) 在接口里面可以写变量也可以写方法
    d) 接口里的方法没有普通方法，都为抽象方法且为公共的抽象方法（可以手动声明也可以不写默认为公共的抽象方法）
    e) 接口中的变量都是静态的常量（建议手动声明为静态的常量，默认情况下也是静态的常量）
    f) 接口不能被实例化（一般作为类型引用即和抽象类一样）
    g) 实现类（是实现接口的类叫做实现类，是接口叫子接口）必须实现接口的所有方法
    h) 实现类可以实现多个接口（实现接口关键字implements 用逗号隔开每一个接口名）

12. 使用接口
    a) 在测试类中通过父类类型引用指向子类对象（即接口类和实现接口类）的方法进行创建一个对象，通过调用实现接口类的方法来使用接口
    b) 在接口中只能与方法和变量（方法都是抽象方法）
    c) 接口中可以只有变量也可以只有抽象方法
    d) 接口不能有构造方法，不能被实例化
    e) 接口不能实现接口，只有在类中才能实现接口
    f) 接口可以继承接口，继承后的接口称为复合接口，接口可以多个继承
    g) 实现接口的类如果是普通类，接口的抽象方法必须实现，除非该类为抽象类，但在该类的子类中（子类也为普通类）也必须实现，如果是抽象类可以选择部分接口中的抽象方法实现，可以不必要实现所有接口中的抽象类
    h) 接口中可以就只有接口名

13. 接口也被称为一种约定

14. Java里能在继承父类的情况下通过接口实现更多的接口类具有的方法功能我们称为接口（即实现接口）

15. 在编写程序的时候用接口来进行编写，方便扩展，利于维护（面向接口编程）

16. 接口不是类型，在不同的类型中可以使用同一个接口，一个类里只能实现一次同一个接口
    抽象类vs接口
    相同点

    1. 都是在系统的抽象层
    2. 都不能被实例化
    3. 都包含抽象方法（用于提供系统的服务，不必提供具体实现）
       不同点
    4. 在抽象类中可以为部分方法提供默认实现（实现父类中的方法也就是普通方法），而接口中 只能包含抽象方法和静态常量
    5. 一个类只能继承一个父类，但可以有多个接口
    6. 已存在的继承树，可以方便抽取接口，但抽取抽象类不容易

---

**

异常

**

1. 异常；就是程序中存在的各种没有预料到的情况，导致程序的错误运行错误从而导致程序中断运行
2. in . hasNextInt ( ) 比较下一个输入的是不是整数，返回值是布尔类型；一般用于if比较中
3. system . exit (1 )；退出java虚拟机，exit为退出；括号中的值必须为非0的正整数
4. 错误流；System . err . printin（）输出错误流；括弧内的字体以比较醒目的形式打印出来
5. 异常处理机制（java提供的错误处理能力）
6. Java中处理异常机制的关键字
   a) 捕获异常
   i. Try执行可能产生异常的代码（通常与catch一起使用）
   ii. Catch捕获异常（通常与try一起使用）
   iii. Finally无论是否发生异常代码总能执行
   b) 声明异常
   i. Throw手动抛出异常
   c) 抛出异常
   i. Throws声明方法可能抛出的各种异常
7. 所有的异常都是Exception类型，在运行中报错的类型都是Exception的子类，
8. 异常的书写规范及语法

a) try – catch捕获异常
i. 语法public void method（）{
try{
代码块1
}catch（exception ex）{
当代码块1发生异常时对代码块1 的处理代码块2
ex . printStackTrace ( ) ;
}
不在try-catch中的代码块3
}

1. Exception为错误类型，java中所有的错误类型都是exception可以更改为对应错误的类型（更改之后能清楚的找到错误的原因）
2. 使用Exception做为异常的类型好处是没有漏洞，坏处是不能明确的知道是什么错误
3. ex为错误对象，可以更改
4. ex . printStackTrace ( ) ;打印异常堆栈信息（ex为变量名，printStackTrace为方法，不可改）告诉发生错误的详细内容
5. ex . getMessage ( );打印异常的字符串提示（即打印堆栈的一部分信息）放在输出语句中（不是所有的异常都有字符串提醒）
6. 代码详情

ii. 代码正常时

1. 程序进入try中通过运行没有发现异常，系统不进入catch中，直接进入try-catch后面的代码中进行执行
   iii. 代码出现问题

2. 程序进入try中通过运行发现异常，系统进入catch中，通过对比catch括号中的错误类型，类型一致时运行catch中的代码，然后进入try-catch后面的代码中进行执行
   iv. 代码出现异常但捕获的类型与异常类型不一致时

3. 程序进入try中通过运行发现异常，系统进入catch中，通过对比catch括号中的错误类型，类型不一致，系统中断（等同于没有进行异常处理）

4. 常见异常的类型

5. try-catch-finally
   a) 语法书写
   i. 语法public void method（）{
   try{
   代码块1
   }catch（exception ex）{
   当代码块1发生异常时对代码块1 的处理代码块2
   ex . printStackTrace ( ) ;
   }
   不在try-catch中的代码块3
   }finally{
   需要释放的代码块4（必须要执行的代码）
   }
   b) 不管发不发生异常，在finally中的代码都会被执行（在finally中一般放必须要释放的资源，如输入输出流，数据库等）
   c) 执行顺序
   i. 有异常情况先执行try语句块中的代码然后在走catch中的代码最后走finally中的代码
   ii. 无异常情况先执行try中的代码然后进入finally中执行finally的代码块
   iii. 存在return的情况下；程序先走try通过对比发生了异常，进入catch进行异常处理，然后进入finally中执行finally中的代码块最后返回到catch中（或者try中）执行return语句
   iv. 唯一的不进入finally的情况；在catch语句块中加入了system . exit ( 1 )时，finally不会被执行，

6. 多重catch
   a) 语法try { } catch（）{ } catch（）{ } finally { }
   b) 多重catch使用需要遵循先子类再父类，当程序执行到第一个匹配的类型与catch类型一致的时候结束异常排查，后面的catch语句块不会被执行

7. try-catch-finally组合；catch与finally可以不要书写，但try必须要有且try不能单独出现

8. 声明异常throws
   a) throws可以声明方法可能抛出的各种异常，多个异常之间用逗号隔开（throws可以声明多个异常）
   b) throws声明异常用于当方法无法解决异常时，通过throws把异常抛出，目的是通过调用进行处理或者调用时再进行声明
   c) Main方法的异常由java虚拟机进行处理
   d) throws声明的异常可以通过调用方法，然后使用try-catch-finally的组合进行处理，也可以通过在main方法的小括号后面继续声明异常交给java虚拟机处理（不推荐使用交给虚拟机处理）

9. throw抛出异常（真正意义上的抛出异常）
   a) 通过throw进行抛出异常，必须处理或者用throws去声明其异常（throw只能抛出一个异常）
   b) 书写throw new （异常类型）（ （异常声明） ）

i. 异常声明的内容为在处理异常时堆栈后面提示的内容
ii. throw抛出的异常与普通的异常处理一样
iii. 抛出异常及处理代码

15. throw与throws的区别

16. java的异常体系结构

a) 所有的异常的祖先类是Throwable
i. Throwable分为两类

1. Error（中文意思为错误）
   a) 程序无法恢复的错误，严重错误，通常建议中断程序
2. Excoption（程序可以恢复的错误，需要进行处理程序，希望程序不会受到错误的影响）
   a) Runtime Excoption运行时异常
   i. 有Runtime Excoption异常时，java不会报错，能通过编译（java希望避免这类异常）
   b) Checked异常，也称为检查时异常
   i. 有Checked异常时，java会进行报错，无法通过编译
3. 自定义异常
   a) 语法
   i. 定义异常类
   ii. 继承异常父类Excoption（或者Runtime Excoption）或者祖先类Throwable（不常继承祖先类，一般继承父类）
   iii. 编写自定义异常类的构造方法，继承父类实现
   iv. 实例化自定义异常对象
   v. 使用throw抛出异常

vi. 捕捉异常并处理
b) 使用自定义异常能更好的反映异常情况，更具体，更针对
18. 异常链（当A方法抛出了异常，B方法继承A方法时，既要A方法的异常，又要B方法的新异常时使用）
19. 异常链创建了新的异常但还保留了原有的异常信息（jdk1.4以后的版本才有 具体实现方法，需要自己去查！）
20. 异常处理规则
a) 异常只能用于非正常的情况下
b) 不要将过于庞大的代码放在try中
c) 在catch中指定异常类型（实在不知道可以写exception）
d) 需要对捕获的异常进行处理