java的异常处理机制

1. 异常处理

异常是我们运行代码的时候最容易出现的问题。在我们看来十分完美的代码

import java.awt.Graphics;

public class Unusal {
	public static void main(String[] args){
		Graphics g = null;
		int x1 = 10,y1 = 10;
		int x2 = 50,y2 = 50;
		g.drawLine(x1, y1, x2, y2);
	}

但java运行时不一定对它说YES。

所以你就会受到这样的一份“礼物”。

这份“礼物”虽然红的有点扎眼，可它也包含了满满的爱意，蓝色的字体告诉了我们该代码在运行时出现的异常类型以及发生异常的具体行。
这么贴心的它在督促着我们改进。

冲冲冲！！！胜利的曙光就在前方！！！

再翻阅书籍之后，一般处理异常有两种方法：

1. 使用try catch语句捕获异常
   try{
   逻辑代码块；//可能会发生异常的语句，try 相当于捕获
   }catch(异常类型名 参数名){//异常类型必须为throwable的子类，catch语句可以有多个
   处理代码块；//对抛出的异常进行一个处理，无异常该逻辑代码块被跳过
   参数名.printStackTrace();//指出异常的类型，性质，栈层次及在程序中出现的位置
   参数名.getMessage();//输出错误的性质
   参数名.toString();给出异常的类型和性质
   }
2. 在方法的声明处通过throws语句抛出异常，即由上层的调用方法来处理。

那我们先尝试用***第一种方法***解决一下

此处x1报错了，原来同在一个方法，这个变量在try中定义就只能给try用，catch不能访问。问题不大，我们继续。

import java.awt.Graphics;

public class Unusal {
	public static void main(String[] args){
		try{
			Graphics g = null;
			int x1 = 10,y1 = 10;
			int x2 = 50,y2 = 50;
			g.drawLine(x1, y1, x2, y2);
			System.out.println("我在catch前面");
		}catch(NullPointerException e){
			e.printStackTrace();
			System.out.println("我在catch里面");
		}
		System.out.println("我在catch后面");

	}
}

异常成功被打印出来！

但我们的输出语句中 “System.out.println(“我在catch前面”);” 没有被执行，此时就要get到一个小知识，当我们利用try…catch语句时，在try中的代码块执行的过程中，若某一行的代码出现异常，则代码将会调到catch语句中执行处理代码块，执行完毕后，继续向下执行，直到程序结束。

第二种方法在这

import java.awt.Graphics;
public class Unusal {
	public static void main(String[] args)throws NullPointerException{
			Graphics g = null;
			int x1 = 10,y1 = 10;
			int x2 = 50,y2 = 50;
			g.drawLine(x1, y1, x2, y2);
	}
}

看控制台的情况，emmmmm好像和什么也不加一模一样！

这是因为throws是把异常扔给上级处理，谁调用它就要接受这个任务，我们把它写在了main方法，它已经是老大了，它都不想处理，所以整个程序进程不得不挥泪告别。

道高一尺，魔高一丈（斜眼笑）
你的程序不会这么简单

import java.awt.Graphics;
public class Unusal {
	public static void main(String[] args)throws NullPointerException{
			Graphics g = null;
			int x1 = 10,y1 = 10;
			int x2 = 50,y2 = 50;
			x1 = (int) (10/0);
			g.drawLine(x1, y1, x2, y2);
			System.out.println("我到这了");	
	}
}

新的异常已经诞生

空指针异常因为前面的代码小朋友犯了错，此次逃过一劫，没有被抓出来。

**但你允许吗？**不允许，此事决不能发生，我们要把所有的错误都要一目了然！！！

前进！！！

import java.awt.Graphics;
public class Unusal {
	public static void main(String[] args)throws NullPointerException{
			Graphics g = null;
			int x1 = 10,y1 = 10;
			int x2 = 50,y2 = 50;
			try{
				x1 = (int) (10/0);
				g.drawLine(x1, y1, x2, y2);
			}catch(ArithmeticException e){
				e.printStackTrace();
			}catch(NullPointerException e){
				e.printStackTrace();
			}			
	}
}

好像并没有全部打印出来。原因：虽然我们可以在try后面添加多个catch异常处理语句，但try…catch语句只能捕获一个错误，在try语句中，顺序执行代码，当某条语句出现异常，会跳到相应的catch语句，执行完后，跳过其他catch快接着向下执行。但是多catch语句也有自己的优点，当我们想更为详细的确定异常类型。

除了try…catch之外，还有try…catch…finally
finally语句用于在任何情况下（除特殊情况外）都必须执行的代码；throws语句用于声明可能会出现的异常。

try{
逻辑代码块；
}catch(异常类型名 参数名){
处理代码块；
}finally{
清理代码块；
}

import java.awt.Graphics;

public class Unusal {
	public static void main(String[] args){
		try{
			Graphics g = null;
			int x1 = 10,y1 = 10;
			int x2 = 50,y2 = 50;
			g.drawLine(x1, y1, x2, y2);
		}catch(NullPointerException e){
			e.printStackTrace();
		}finally{
			System.out.println("打个赌，赌你一定会在控制台见到我！");
		}
	}
}

fianlly诚不欺我。

异常是程序执行时遇到的任何错误情况和意外行为。异常处理的好坏关系到系统的健壮性和稳定度。
“例外”就是异常，是程序的运行过程中所发生的异常事件，他中断指令的正常执行。
异常Exception，对于异常的处理有两种方法。

2. 异常类型

异常类之间存在继承关系。我们通过查阅帮助文档，了解具体信息。
我们上面作为示例的NullPointerException和ArithmeticException都属于运行异常即RuntimeException。如果我们不进行处理，编译器也不会进行提示，在运行过程中如果出现问题，便会抛出相应信息。还有一些编译器会自动提醒我们加上try…catch语句或者将异常抛出。
在catch语句中的异常类型，可以用某异常的父类进行代替。

3. throws,throw,throwable傻傻分不清

1. throws现在 应该不陌生，它是我们示例中进行异常处理的一种方式，在代码生命过程中将异常抛出。
2. throw用来在程序中明确这里抛出一个异常。

import java.awt.Graphics;

public class Unusal {
	public static void main(String[] args) throws NullPointerException{
		try{
			Use();
		}catch(NullPointerException e){
			e.printStackTrace();
		}
	}
	public static void Use()throws NullPointerException{
		throw new NullPointerException("空指针异常===");
	}
}

3. throwable是所有异常直接或间接继承的父类。

4. 自立门户，自己建立异常

恭喜你，你可以做到！！！

原先我们可以通过继承JFrame类来建立属于自己的窗体，现在当然也可以建立属于自己的异常。

public class MyException extends Exception{
	public MyException(){
		super();
	}
}

但当使用这个类如此定义却出现了问题

改成如下格式就不会出现问题。
问题原因：因为我们的代码在编译器中是通过的，当运行的时候，如果我们不在方法中抛出，而在上面定义的话，程序是不知道有我们自定义异常的可能性，会不通过，所以如果我们先将可能的异常抛出，再try catch便可以

public class Unusal {
	public static void main(String[] args){
				try {
					Use();
				} catch (MyException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
					System.out.println("这是我的异常");
				}
	}
	public static void Use() throws MyException{
		Graphics g = null;
		int x1 = 10,y1 = 10;
		int x2 = 50,y2 = 50;
		g.drawLine(x1, y1, x2, y2);
	}
}

异常处理机制的优点：（参考于其他书籍）

1. 错误的处理变得规范化
2. 把错误代码和常规代码分开
3. 可以在catch语句中传播错误信息
4. 可以对错误类型进行分组
5. 方便定位错误和维护

好啦就到此结束了，如果还有其他不懂得，欢迎继续交流！