优雅的异常处理 -- Java中的异常

什么是Java中的异常

1. 代码正常运行不会出问题，但是遇到意外，参数变量，不符合要求，发生意外，代码终止运行
2. 代码中的异常处理好了，代码就可以顺利的继续运行！

Java 内置异常类

Java 语言定义了一些异常类在 java.lang 标准包中。

标准运行时异常类的子类是最常见的异常类。由于 java.lang 包是默认加载到所有的 Java 程序的，所以大部分从运行时异常类继承而来的异常都可以直接使用。

Throwable 类是JAVA语言中所有错误或异常的超类.

Exception

所有的异常类是从 java.lang.Exception 类继承的子类。

Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。

Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。

Error 用来指示运行时环境发生的错误。

例如，JVM 内存溢出。一般地，程序不会从错误中恢复。

异常类有两个主要的子类：IOException 类和 RuntimeException 类。

异常方法

1 public String getMessage()
返回关于发生的异常的详细信息。这个消息在Throwable 类的构造函数中初始化了。
2 public Throwable getCause()
返回一个Throwable 对象代表异常原因。
3 public String toString()
使用getMessage()的结果返回类的串级名字。
4 public void printStackTrace()
打印toString()结果和栈层次到System.err，即错误输出流。
5 public StackTraceElement [] getStackTrace()
返回一个包含堆栈层次的数组。下标为0的元素代表栈顶，最后一个元素代表方法调用堆栈的栈底。
6 public Throwable fillInStackTrace()
用当前的调用栈层次填充Throwable 对象栈层次，添加到栈层次任何先前信息中。

异常的处理方式

自己捕获处理

1.try-catch的语法结构及链式结构多异常处理方式

 语法：
try{
//可能产生异常的代码
}catch(捕获的异常类型 e){//e是形式参数
//该异常捕获之后要做的操作
}catch(捕获的异常类型 e){//e是形式参数
//该异常捕获之后要做的操作
}finally{
//异常发生之后一定会执行到的语句块：
//①流资源关闭②释放锁
}

抛出异常

 语法结构：方法后面使用throws 需要抛出的异常类型

void eat() throws ArithmeticException, CloneNotSupportedException{
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月");
			//sdf.parse("fsdfsd");
}

 抛出异常的注意事项：
①方法抛出运行时异常，在方法头可以不用抛出异常
②方法抛出编译时异常：方法必须处理异常，或者抛出同类异常，或者抛出异常该异常的父类类型异常

获得异常信息的方式

1. 捕获异常可以写异常的父类，也可以捕获到对应子类的异常
2. catch(捕获的异常类型 e)捕获的异常实际捕获一个异常对象，该对象e可以在catch语句块直接使用

方式1：System.out.println(e.getMessage());//e.getMessage()
方式2：System.out.println(e);//e.toString()
方式3：e.printStackTrace();//打印异常信息

finally结构

1. finally语句块

1. try-catch语句块可以用写finally
2. 处理异常之后finally语句块一定会执行到
3. finally语句块中，一般用来处理什么内容
   a. 关闭流资源[ IO流知识部分再了解 ]
   b. 释放锁[ 线程知识部分再了解 ]

2. 注意 ： 一般不要在finally里面写返回语句，程序难理解
3. finally语句之前，如果有执行退出虚拟机，也是不会执行finally语句块

	public static void main(String[] args) {
		System.out.println(eat());;
	}
	static int eat(){
		int i = 10;
		try{
			i = 20;
			System.exit(0);
			System.out.println(1/0);
			return i;
		}catch(Exception e){
			e.printStackTrace();
			i = 30;
			return i;
		}finally{
			i = 40;
			return i;
		}
	}

主动向外抛出

 方法内部主动创建异常抛出：throw new SelfException(“账户已经存在，请重新输入”);
账号登录示例:

static String[] arr = {"周周","黄黄"};
	public static void main(String[] args) throws SelfException {
		login("周周");	
	}
	//主动产生异常向外抛出
	static void login(String name) throws SelfException{
		for(int i = 0;i<=arr.length-1;i++){
			if(name.equals(arr[i])){
				throw new SelfException("账户已经存在，请重新输入");//自己在方法内部写一个异常，抛出
			}
		}
		System.out.println("恭喜你注册成功");	
}

throws 和 throw的区别

throws 处理异常
在方法头抛出异常
throw 开发代码存在以外的情况,自己主动抛出异常[产生异常]
在方法内部 throw new NullPointException();

如果一个方法没有捕获到一个检查性异常，那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法签名的尾部。

也可以使用 throw 关键字抛出一个异常，无论它是新实例化的还是刚捕获到的。
下面方法的声明抛出一个 RemoteException 异常：

public class className
{
  public void deposit(double amount) throws RemoteException
  {
    // Method implementation
    throw new RemoteException();
  }
  //Remainder of class definition
}

自定义异常

java已经写好很多异常，但不能满足开发中所有异常描述的需求，所以需要自定义异常

自定义异常的方式

1. 自定义类继承异常类
2. 参照其他异常通过Exception设置异常提示信息

注意:

所有异常都必须是 Throwable 的子类。
如果希望写一个检查性异常类，则需要继承 Exception 类。
如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

public class SelfException extends Exception {
		SelfException(String msg){
			super(msg);
		}
}