java基础--笔记11



异常：程序在运行时出现不正常情况。

异常中提示的内容：

1，异常的名称

2，名称后：异常的描述信息

3，异常在程序中出现的位置

异常的信息这么多，最方便的方式，将这些信息进行封装到对象中，这个对象封装的都是异常信息。
 

Error  严重问题

     对于Error一般不编写针对性的代码对其进行处理，只能对程序进行修改。

Exception  非严重问题

     对于Exception可以使用针对性的处理方式进行处理

无论Error或者Exception都具有一些共性内容

比如：不正常情况的信息，引发原因...

异常分两种：

1，编译器检查的异常checkException：这个问题通常都是外部因素造成的。 Exception下的所有子类都是checkException，除RuntimeException子体系外。

2，编译器不检查的异常uncheckedException（运行时异常）：通常这种问题发生，都是程序员造成的。不需要由编译器检查，该异常一旦发生，必须让程序停止，让程序员看到该问题，并对代码进行修改。

异常的处理：

java中提供了特有的语句进行处理

try

{

     需要被检测的代码；

}

catch（异常类  变量）

{

     处理异常的代码；（处理方式）

}

finally

{

     一定会执行的语句；

}

函数的结束方式有两种：

1，return  这是正常结束。如果有返回值将返回值返回给调用者

2，throw 一旦发生，函数一样结束。会将异常对象抛给调用者

对捕获到的异常对象进行常见的操作

String getMessage（） ：获取异常信息。

 

在函数上声明异常。

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

对多异常的处理。

1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。

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

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

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

不要简单的

Java中的异常用对象来表示。Java对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型(class)，每个异常都对应一个异常(类的)对象。 异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。

catch的类型是Java语言中定义的或者程序员自己定义的，表示代码抛出异常的类型，异常的变量名表示抛出异常的对象的引用，如果catch捕获并匹配上了该异常，那么就可以直接用这个异常变量名，此时该异常变量名指向所匹配的异常，并且在catch代码块中可以直接引用。

自定义异常

当在函数内部出现了shrow抛出异常对象，那么就必须要给对应的处理歌声。

要么在内部try catch处理

要么在函数上声明让调用者处理。

throw和throws的特点

Throwable体系中的所有成员都具备可抛性（该体系中德尔类以及对象可以被关键字throw和throw操作）

throw和throws的区别

1，throws使用在函数上。throw使用在函数内

2，throws后面跟的是异常类，可以跟多个，用逗号隔开。

     throw后跟的是异常对象。

3，throw用来抛异常对象，throws用来声明异常类。

Exception中有一个特殊的子类异常 RuntimeException运行时异常。

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

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

注意：之所以不用再函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时出现了无法继续运算的情况，希望停止程序后，对代码进行修改。

自定义异常时：如果该异常的发生，无法再继续进行运算，就让自定义异常继承RuntimeException

是按照java的面向对象的思想，将程序中出现的特有问题进行封装。

声明：
     函数中如果有编译时检查异常被抛出，那么需要在函数上进行声明，告知调用者，该功能有可能出现问题。

声明的目的到底是什么？
     就是为了让调用者进行处理。或者继续声明，或者捕获。
     特殊情况：为什么 运行时异常可以不用声明呢？因为运行时异常是由程序员自己造成，所以不声明，调用者就不会建立对应的处理的方式，该异常一旦发生，就会让程序在异常处停止。这时需要调用者对代码进行修改。一旦声明了，调用者很有可能会进行处理。这样有可能造成问题被隐藏而错误的代码没有被修正。

finally代码块：定义一定执行的代码

通常用于关闭资源，释放资源。

注意，finally只有一种情况不会执行。当执行到System.exit（0）；

try

{

}

finally

{

}

记住，catch是用于处理异常的。如果没有catch就代表异常没有被处理过，如果该异常是检测时异常，那么必须声明。编译时异常，要么声明，要么捕获。

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

1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。

2，如果父类方法抛出多个异常，子类在覆盖该方法时，只能抛出父类异常的子集

3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。 如果子类方法发生了异常。就必须要进行try处理，绝对不能抛。 如果还想将问题告知给调用者，可以利用异常转换，将异常转换成运行时异常throw抛出即可。因为运行时异常不需要throws声明，

总结：

异常：是对问题的描述，将问题进行对象的封装。

异常体系：

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作。只有异常体系具备这个特点。

当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。

注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeException异常，函数上可以不用声明。如果函数声明了异常，调用者需要进行处理，处理方法可以throws可以try。

 

异常的好处：

1，将问题进行封装

2，将正常流程代码和问题处理代码相分离，方便于阅读。

异常的处理原则：

1，处理方式有两种：try 或者 throws

2，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch

3， 多个catch，父类的catch放到最下面，否则编译失败。因为父类的catch在上面的话，下面的catch异常子类都是多余的。父类的catch能捕获所有的异常子类。

4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句，也不要写。

当捕获到的异常，本功能处理不了时，可以继续在catch中抛出

try

{

     throw new AException（）；

}

catch （AException e）

{

     throw e；

}

如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，再抛出和该功能相关的异常。

或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道，并处理。也可以将捕获异常处理后，转换新的异常。

try

{

     throw new AException（）；

}

catch（AException e）

{

      //对AException处理

     throw new BException（）；

}