黑马程序员之---———Java异常机制



------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培

训、.Net培训</a>、期待与您交流！ -------

 异常:就是程序运行发生的问题。

 

异常体系的特点：具备可抛性(throw ， throws)

 

1.异常的分类:

以问题严重程度的划分为两种：

         Error(错误):由Java虚拟机生成并抛出，一般不针对性处理。

         Exception(异常):所有异常类的父类，需要向外抛出或捕获。

 

         以发生时机划分为两种：

    (1)编译时检测到的异常(表示可以被处理)该异常在编译时，如果没有处理(没有抛出，也没有try处理)，则编译失败

           Exception及其子类都是编译异常。

   (2)运行时异常(编译时不检测)

　　　　  在编译时,编译器不检查,该异常发生,建议不处理,让程序停止。由调用者对代码进行修正

  RuntimeException，以及RuntimeException的子类是运行异常

 

2. Throwable类中的常用方法

注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:

     getCause()：返回抛出异常的原因。如果 cause 不存在或未知，则返回 null。

　 getMeage()：返回异常的消息信息。

　 printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段 System.err 的值。

 

3.处理异常机制

       异常处理机制为：抛出异常，捕捉异常。

        抛出异常：当一个方法出现错误引发异常时，方法创建异常对象并交付运行时系统，异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

        捕获异常：在方法抛出异常之后，运行时系统将转为寻找合适的异常处理器（exception handler）。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时，即为合适 的异常处理器。运行时系统从发生异常的方法开始，依次回查调用栈中的方法，直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器，则运行时系统终止。同时，意味着Java程序的终止。

 

 

4. 异常处理原则：

1,抛几个就处理几个。try应多个catch时，如果有父类的catch语句块，一定要放在下面。

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

3,catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。当捕获到的异常 本功能处理不了时，可以抛出异常让调用者处理

4.RuntimeException异常类包括运行时各种常见的异常，ArithmeticException类和                                                                                                                                      ArrayIndexOutOfBoundsException类都是它的子类。因此，RuntimeException异常类的catch子句应该放在 最后面，否则可能会屏蔽其后的特定异常处理或引起编译错误。

5. throw和throws的用法

throw定义在函数内，用于抛出异常对象，后面跟的是异常对象。当函数内有throw抛出的异常对象时，要在函数上进行声明

       如果抛出的是RuntimeException异常时,可以不声明

throws定义在函数上，用于抛出异常类，可以抛出多个异常用逗号隔开。

 

6.finally特点：

 　　(1).finally中定义通常定义的是关闭资源的代码，因为资源必须释放。

 　　(2).只有当执行到System.exit(0);时才不会被执行。

 

7.处理异常的常见结构:

try catch finally 代码块组合特点：  

1， try catch finally 

2, try catch(多个)当没有必要资源需要释放时，可以不用定义finally。  

3, try finally 异常无法直接catch处理，但是资源需要关闭。    

try 块：用于捕获异常。其后可接零个或多个catch块，如果没有catch块，则必须跟一个finally块。
catch 块：用于处理try捕获到的异常。
finally 块：无论是否捕获或处理异常，finally块里的语句都会被执行。

当在try块或catch块中遇到return语句时，finally语句块将在方法返回之前被执行。在以下4种特殊情况下，finally块不会被执行：
1）在finally语句块中发生了异常。
2）在前面的代码中用了System.exit()退出程序。
3）程序所在的线程死亡。
4）关闭CPU。

void show()throws Exception { 

 try  {   //开启资源。 

  throw new Exception();  } 

 finally  { 

  //关闭资源。     } 

  /* 

 catch(Exception e)  {     }

 

事例：

   public class Test {

public static void func() throws Exception {

try {

throw new Exception();

} finally {

System.out.println("B");

}

}

 

public static void main(String[] args) {

try {

func();

System.out.println("A");

} catch (Exception e) {

System.out.println("C");

}

 

System.out.println("D");

}

}

 　　运行结果：B C D

 

 

8,异常的注意事项：

 　　在子父类覆盖时：

 　　　　1.子类抛出的异常必须是父类的异常的子类或子集

 　　　　2.如果父类或接口没有异常抛出时，子类覆盖出现异常，只能try，不能抛

   3,如果这个异常子类无法处理，可以在子类方法中，通过throw抛出RuntimeException异 常或者其子类通过throws或throw进行自定义异常抛出操作

 

注意：当出现的异常是调用者处理不了的，就需要将此异常转换为一个调用者可以处理的异常抛出。 

如果出现异常，并不处理，但是资源一定关闭，所以try finally集合只为关闭资源。

finally很有用，主要用户关闭资源。无论是否发生异常，资源都必须进行关闭。

System.exit(0); //退出jvm，只有这种情况finally不执行。

1. try-catch-finally 规则(异常处理语句的语法规则）：

1)  必须在 try 之后添加 catch 或 finally 块。try 块后可同时接 catch 和 finally 块，但至少有一个块。
2) 必须遵循块顺序：若代码同时使用 catch 和 finally 块，则必须将 catch 块放在 try 块之后。
3) catch 块与相应的异常类的类型相关。
4) 一个 try 块可能有多个 catch 块。若如此，则执行第一个匹配块。即Java虚拟机会把实际抛出的异常对象依次和各个catch代码块声明的异常类型匹配，如果异常对象为某个异常类型或其子类的实例，就执行这个catch代码块，不会再执行其他的 catch代码块
5) 可嵌套 try-catch-finally 结构。
6) 在 try-catch-finally 结构中，可重新抛出异常。
7) 除了下列情况，总将执行 finally 做为结束：JVM 过早终止（调用 System.exit(int)）；在 finally 块中抛出一个未处理的异常；计算机断电、失火、或遭遇病毒攻击。

2. try、catch、finally语句块的执行顺序:

1)当try没有捕获到异常时：try语句块中的语句逐一被执行，程序将跳过catch语句块，执行finally语句块和其后的语句；

2)当try捕获到异常，catch语句块里没有处理此异常的情况：当try语句块里的某条语句出现异常时，而没有处理此异常的catch语句块时，此异常将会抛给JVM处理，finally语句块里的语句还是会被执行，但finally语句块后的语句不会被执行；

3)当try捕获到异常，catch语句块里有处理此异常的情况：在try语句块中是按照顺序来执行的，当执行到某一条语句出现异常时，程序将跳到catch语句块，并与catch语句块逐一匹配，找到与之对应的处理程序，其他的catch语句块将不会被执行，而try语句块中，出现异常之后的语句也不会被执行，catch语句块执行完后，执行finally语句块里的语句，最后执行finally语句块后的语句；

 

9. Throws抛出异常的规则：

    1) 如果是不可查异常（unchecked exception），即Error、RuntimeException或它们的子类，那么可以不使用throws关键字来声明要抛出的异常，编译仍能顺利通过，但在运行时会被系统抛出。

    2）必须声明方法可抛出的任何可查异常（checked exception）。即如果一个方法可能出现受可查异常，要么用try-catch语句捕获，要么用throws子句声明将它抛出，否则会导致编译错误

    3)仅当抛出了异常，该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候，应该继续抛出。

    4）调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法，则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

 

 

10.Java常见异常

  

在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:

1. runtimeException子类:

    1、 java.lang.ArrayIndexOutOfBoundsException
    数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
    2、java.lang.ArithmeticException
    算术条件异常。譬如：整数除零等。
    3、java.lang.NullPointerException
    空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
    4、java.lang.ClassNotFoundException
    找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。 

   5、java.lang.NegativeArraySizeException  数组长度为负异常

   6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

   7、java.lang.SecurityException 安全性异常

   8、java.lang.IllegalArgumentException 非法参数异常

2.IOException

IOException：操作输入流和输出流时可能出现的异常。

EOFException   文件已结束异常

FileNotFoundException   文件未找到异常

3. 其他

ClassCastException    类型转换异常类

ArrayStoreException  数组中包含不兼容的值抛出的异常

SQLException   操作数据库异常类

NoSuchFieldException   字段未找到异常

NoSuchMethodException   方法未找到抛出的异常

NumberFormatException    字符串转换为数字抛出的异常

StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常

IllegalAccessException  不允许访问某类异常

InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常

 

/*描述 毕老师用电脑上课

开始思考:

上课中出现的问题

比如电脑蓝屏，电脑冒烟了

接下来要对问题进行描述，封装成对象

 

 

当冒烟发生后，会出现讲课进度无法继续

出现了老师的问题:课时计划无法完成

 

package 多发点;

 

class NoPlanException extends Exception {

NoPlanException(String msg) {

super(msg);

}

}

 

class LanPingException extends Exception {

LanPingException(String message) { // 作函数 子类没有必要再重新定义

super(message);// 将消息传给父类去操作，因为父类已经以有了操

}

}

 

class MaoYanException extends Exception {

MaoYanException(String message) {

super(message);

}

 

}

 

class Computer {

private int state = 3;// 定义一个标示 标志着正常状态 如果是1就是正常如果是2就蓝屏如果是3就冒烟

 

public void run() throws MaoYanException, LanPingException// 电脑的运行方法

{

if (state == 2)

throw new LanPingException("电脑运行中蓝屏了");

if (state == 3) {

throw new MaoYanException("电脑冒烟了");

}

System.out.println("电脑运行");

 

}

 

public void reset()// 电脑的重启方法

{

System.out.println("电脑重启");

 

}

}

 

class Teacher {

private String name;// 名字

private Computer cmpt;

 

Teacher(String name) {

this.name = name;

cmpt = new Computer();// 获取一个电脑类

 

}

 

public void JK() throws NoPlanException// 讲课

{

try {

cmpt.run();

 

} catch (LanPingException e) {

cmpt.reset();

} catch (MaoYanException e) {

Test();

throw new NoPlanException("课时无法继续" + e.getMessage());// throw后面千万不能写语句因为如果他发生那就代表着程序结束

 

}

System.out.println("讲课");

}

 

public void Test() {

System.out.println("做练习");

}

 

}

 

public class ExceptionTest {

public static void main(String[] args) {

Teacher t = new Teacher("毕老师");// 给构造函数初始化

try {

t.JK();

} catch (NoPlanException e) {

System.out.println(e.toString());

System.out.println("换老师或者放假");

 

}

 

System.out.println("Hello World!");

}

}

 

 

11.自定义异常(定义类继承Exception或RuntimeException)

定义：当开发时，项目中出现了java中没有定义过的问题时，这时就需要我们按照java异常建立思想，将项目的中的特有问题也进行对象的封装

 

继承Exception原因：

     1,使他们都具备可抛性。是Throwable中独有特点。　

 　　2.让该类具备操作异常的共性方法

 　　3.当要定义自定义异常信息时，可以使用父类已经定义好的功能

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

   　　class MyException extends Exception

   　　{

　　　　  MyException(String message)

  　　　　{

　　　　　　   super(message);

  　　　　}

   　　} 

在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常。

 

class MyException extends Exception {

// 在自定义异常中自定义处理信息

// 可以通过复写Exception父类中getMessage的方法

private int value;// 获取异常出现时的具体值

private String msg;

 

MyException(String msg, int value)// 构造函数初始化

{

super(msg);

this.value = value;

}

 

public int getValue() {

return value;

}

 

}

 

class demo {

int div(int a, int b) throws MyException// 自定义 异常声明

{

if (b < 0)

throw new MyException("负数出现了", b);// 手动通过throw关键字抛出一个自定义异常对象

return a / b;

}

}

 

class ExceptionDemo {

public static void main(String args[]) {

demo d = new demo();

try {

int x = d.div(4, -15);

System.out.println("x=" + x);

} catch (MyException e) {

System.out.println(e.toString());

System.out.println("出现负数的值是" + e.getValue());

}

System.out.println("程序运行完成!");

}

}

 

 

12、包

 

包：对类文件进行分类管理，给类提供多层命名空间，写在程序文件的第一行，类名的全称的是包名.类名，包也是一种封装形式。

 

包之间的访问

 被访问的包中的类权限必须是public的。

 类中的成员权限：public或protected。

protected是为其他包中的子类提供的一种权限。只能是不同包中的子类可以使用的权限。

 

import 导入的是包中的类。建议，不要写通配符 *，需要用到包中的哪个类，就导入哪个类。

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培

训、.Net培训</a>、期待与您交流！ -------