JAVA中的异常

异常类

Exception：一般表示的是程序中出现的问题，可以直接使用try…catch处理
Error：一般指的是JVM错误，程序中无法处理

Exception在程序中是必须使用try…catch进行处理
RuntimeException可以不使用try…catch进行处理，但是如果有异常产生，则异常将由JVM进行处理
区别如下：

public class RuntimeExceptionDemo01 {
	public static void main(String args[]) {
		String str = "123" ;		// 定义一个由数字组成的字符串
		int temp = Integer.parseInt(str) ;	// 将字符串变为int类型
		System.out.println(temp * temp);	// 计算乘方
	}
}
其中parseInt()方法的声明如下：
public static int parseInt(String) throws NumberFomatException;
抛出了异常，但在主程序中可以不处理这个异常

异常的捕获

try{
	// 有可能出现异常的语句
}catch(异常类 异常对象){
	// 编写异常的处理语句
}[ catch(异常类 异常对象){
	// 编写异常的处理语句
} catch(异常类 异常对象){
	// 编写异常的处理语句
} …. ]
[finally{ 
    一定会运行到的程序代码 ； 
}]

捕捉之后，可以调用一些异常类的方法

e.toString();
e.getMessage();
e.printStackTrace();//跟踪出现错误的具体代码行数

throws throw

这两个关键字常常配合使用，当一个方法用throw扔出一个异常的时候，必须用throws告诉大家，我这个方法扔出了一个异常

throws ：在定义一个方法的时候可以使用throws关键字声明，使用throws声明的方法表示此方法不处理异常，而交给方法的调用处进行处理

public 返回值类型 方法名称(参数列表…) throws 异常类{}

throw：可以直接使用throw抛出一个异常。抛出的时候直接抛出异常类的实例化对象即可

public class One {
	public static void main(String args[]){
		try{
			throw new Exception("自己抛出的异常！") ;// 抛出异常的实例化对象
		}catch(Exception e){// 捕获异常
			System.out.println(e);
		}
	}
}

自定义异常类

直接上例子理解：

class MyException extends Exception{	// 自定义异常类，继承Exception类
	public MyException(String msg){	// 构造方法接收异常信息
		super(msg) ;			// 调用父类中的构造方法
	}
}
public class DefaultException {
	public static void main(String args[]) {
		try{
			throw new MyException("自定义异常。") ;	// 抛出异常
		}catch(Exception e){// 上面抛出的异常直接在这里处理了，不需要用到throws
			System.out.println(e) ;
		}
	}
}

继承中的异常

子类中非构造成员方法抛出的异常不能比父类多
因为当发生向上转型的时候，在处理成员方法抛出的异常时，还是处理父类的异常，而不是子类的！

class OpenException extends Exception {}
class NewException extends Exception {}

class CloseException extends OpenException {}

public class ArrayIndex {//父类
	public void f() throws OpenException {}
	public static void main(String[] args) {
}
class NewClass extends ArrayIndex {//子类
	public void f() throws OpenException {}//这里是错误的！不能抛出比父类更多的异常
	public static void main(String] args) {
		ArrayIndex p = new NewClass() ;//向上转型
		try {
			p.f();
		} catch (OpenException e) {//虽然向上转型，但这里捕获的还是父类抛出的异常，所以子类不能比父类更多，不然无法捕获
			e. printStackTrace();
	}
}

当父类的构造方法抛出异常的时候，子类的构造方法也必须抛出父类的全部异常：子类会默认调用父类的构造函数。
且子类的构造方法可以抛出比父类更多的异常，因为这里不涉及到向上转型。

class OpenException extends Exception {}
class NewException extends Exception {}

class CloseException extends OpenException {}

public class ArrayIndex {//父类
	public ArrayIndex() throws OpenException{}//构造函数抛出异常
	public void f() throws OpenException {}
	public static void main(String[] args) {
}
class NewClass extends ArrayIndex {//子类
	public NewClass() throws OpenException,NewException{}//可以抛出更多的异常
	public void f() throws OpenException {}//这里是错误的！不能抛出比父类更多的异常
	public static void main(String] args) {
		ArrayIndex p = new NewClass() ;//向上转型
		try {
			p.f();
		} catch (OpenException e) {//虽然向上转型，但这里捕获的还是父类抛出的异常，所以子类不能比父类更多，不然无法捕获
			e. printStackTrace();
	}
}

断言

assert boolean表达式 ;
assert boolean表达式 : 详细的信息

表达式的值为true,不会提示任何信息，
表达式的值为false,会提示信息，若不声明详细信息，会提示默认信息