黑马程序员，Java基础知识五：异常

最新推荐文章于 2024-09-21 10:38:43 发布

风祭将o

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量481

点赞数

文章标签： java 笔记异常

本文链接：https://blog.csdn.net/u012605440/article/details/42261873

版权

异常

异常定义

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

异常体系

Throwable

|--------------Error：通常出现重大问题如：运行的类不存在或者内存溢出等。不编写特定代码针对处理。系统会直接结束程序运行。

|--------------Exception：在运行时出现的一起情况，可以通过try catch finally 处理，让程序继续运行下去。

Throwable中的方法

getMessage（）：获取异常信息，返回字符串

toString（）：获取异常类名和异常信息，返回字符串。

printStackTrace（）获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void

printStackTrace（PrintStream S）：通常用该方法将异常内容保存在日志文件中，以便查阅。

异常体系的特点

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

Throws和Thorw

thorws用于标识函数暴露出来的异常，而thorw用于抛出异常对象。

他们的区别是：thorws定义在函数上，后面跟异常类名；而thorw定义在函数内，后面跟异常对象。

当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明：thorws XXXException，否则编译失败。不过如果是抛出RuntimeException，则函数上不用声明。

如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。

两种异常：

编译时被检测异常

该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
该异常被标识，代表这可以被处理。

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

在编译时，不需要处理，编译器不检查。
该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

异常处理的格式：

try
｛
   需要检测的代码；
 ｝
catch（异常类  变量）
｛
   异常处理代码；
 ｝
finally
｛
   一定会执行的代码；
 ｝

注意：

1.finally代码块只有一种情况不会被执行，就是在之前执行了System.exit（0）。

2.finally定义的通常是关闭资源代码。因为资源必须释放。

import java.util.Scanner;
public class tryCatch {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int num =0;
		while((num = sc.nextInt())!=999){
			System.out.println(calculation(num,sc.nextInt()));
		}
		sc.close();
	}
	public static int calculation(int chushu,int beichushu){
		try {
			
			if(beichushu==0)
				throw new Exception("0不能作为除数，请重新输入：");
			if(beichushu<0)
				throw new Exception("请不要输入一个负数，重新输入：");
                                int num = chushu/beichushu;
                                return num; } 
                catch (Exception e) {
                   // TODO Auto-generated catch block 
                        System.out.println(e.getMessage()); }
                return 0; 
        }
}

在这个程序中，我们通过键盘输入两个整数，若被除数是零，则报出异常，并打印出"0不能作为除数，请重新输入："，若被除数小于零，则报出异常，并打印出"请不要输入一个负数，重新输入："，这样子系统就会让我们重新输入两个数，系统就会不断返回输入的数计算的商，达到计算器的效果。

自定义异常：

有时候我们需要自定义异常，让程序按照我们的定义条件运行，如果超出条件则抛出异常。按照java的面向对象思想，将程序中出现的特有问题进行封装。我们定义一个类继承Exception或者RuntimeException来创建一个自定义异常。这样做的目的是：1,为了让该自定义类具备可抛性。2.让该类具备操作异常的共性方法。当我们要定义自定义异常的信息时，可以使用父类已经定义好的功能。

    class MyException extends Exception    
    {
        MyException(String message)    //  异常信息传递给父类的构造函数。
        {
            super(message);
        }
    }

<pre name="code" class="java">import java.util.Scanner;

class myException extends Exception {
	private int b;
	private String name;
	myException(String name,int b) throws myException {
		this.name =name;
		this.b = b;
		System.out.println(name+"  这个除数不是正数！" + b);
	}

	public Throwable fillInStackTrace(){
		return this;
	}
}

public class calculate {
	public static void main(String[] args) throws myException {
		Scanner sc = new Scanner(System.in);
		int num =0;
		while((num = sc.nextInt())!=999){
			System.out.println(calculation(num,sc.nextInt()));
		}
		sc.close();
	}

	static int calculation(int chushu, int beichushu) throws myException {
		if (beichushu <= 0)
			throw new myException("喂，搞错了把",beichushu);
		else {
			 return chushu / beichushu;
		}

	}
}

异常的好处：

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

异常的处理原则：

1，处理方式有两种：try 或者 throws。2，调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。3，多个catch，父类的catch放到最下面。4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。5，当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

        try
        {
            throw new AException();
        }
        catch (AException e)
        {
            throw e;
        }

6，如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，再抛出和该功能相关的异常，或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道，并处理。也可以捕获异常处理后，转换新的异常。

        try
        {
            throw new AException();
        }
        catch (AException e)
        {
            // 对AException处理。
            throw new BException();
        }