异常是导致程序中断执行的一种指令流。程序之中如果出现异常并且没有合理处理的话就会导致程序终止执行。

为了保证程序在出现之后可以正常执行完毕，就需要进行异常处理。

先来看一下异常的继承类结构：



所有的异常都是由Throwable继承而来。其中Error类描述了Java运行时内部错误和资源耗尽错误。应用程序不抛出此类异常，这种内部错误一旦出现，除了告知用户并使程序安全终止之外，再无能为力。这种情况很少出现。

我们需要关心的是Exception以及其子类。在Exception之下又分为两个分支，RuntimeException和IOException。

RuntimeException：由于程序错误导致的异常

IOException：程序本身没有问题，由于向像I/O错误这类问题导致的异常

非受查异常（无须强制处理）：所有继承于Error或RuntimeException的异常类称为非受查异常。

受查异常（必须强制处理）：所有继承于Exception与IOException的类称为受查异常。

范例：异常产生（被除数为0）





现在程序之中产生了异常，可以看出在异常语句之前的语句可以正常执行完毕，而异常产生之后程序直接结束。为了保证程序出现异常后还可以继续向下执行，就需要异常处理。

try{
    有可能出现异常的语句 ;
}[catch (异常类 对象) {
    异常处理
} ... ]
[finally {
    异常的出口（无论会不会出现异常都会执行finally块）
}]

[ ]内的为可选项。catch块捕获异常并进行处理。

对于以上三个关键字，可以出现的组合：try...catch... , try...finally... , try...catch...finally...

对异常进行处理





关键字throws，关键字throw
throws：作用于方法上。在进行方法定义时，如果要明确告诉调用者本方法可能产生哪些异常，可以使用throws关键字进行声明，表示将异常拋回给调用方。并且当方法出现问题后可以不进行处理。

注意：如果调用了throws声明的方法，那么在调用时必须明确的使用try...catch...进行捕获，因为该方法有可能产生异常，所以必须按照异常的方式来进行处理。***主方法本身也是一个方法，所以主方法上也可以使用throws进行异常抛出，这个时候如果产生了异常就会交给JVM处理。

throw：用在方法中，一般与自定义的异常类搭配使用。throw语句直接写在方法之中，表示人为进行异常的抛出。如果异常类对象不希望由JVM产生而通过用户产生，就可以使用throw语句来完成。

一般而言，throw和break，continue都要和if结合使用。

RuntimeException类（*****）
先看一个例子





这是parseInt的源码定义：

public static int parseInt(String s) throws NumberFormatException;

这个方法上已经明确抛出异常，但是在进行调用的时候发现，即使没有进行异常处理也可以正常执行。这个就属于

RuntimeException的范畴。

面试题：请解释Exception与RuntimeException的区别，请列举几个常见的RuntimeException。

区别：首先Exception类是RuntimeException类的父类。使用Exception定义的异常都要求必须使用异常处理（受查异常），而使用RuntimeException定义的异常可以由用户选择性的来进行异常处理（非受查异常）。

常见RuntimeException：ClassCastException、NullPointerException等。

 

自定义异常
自定义异常类可以继承两种父类：Exception、RuntimeException。

范例：实现自定义异常（当两数相加等于5时，抛出异常）

异常
异常概述
处理异常
异常的传播
自定义异常

异常概述
程序在运行过程中不可避免会出现一些错误，比如:使用了没有赋值过的变量 除0 使用了不存在的索引等这些错误在程序中我们就称之为异常，程序在运行过程中，一旦出现异常会导致程序立即终止 ，异常后面的代码都不会执行。


处理异常
语法：

try：

代码块（可能出现错误的语句）

except  异常类型1  as 异常名1：

代码块（出现错误以后的处理方式）

except 异常类型2  as 异常名2：

代码块（出现错误以后的处理方式）

…

else：

代码块（没有错误的时候要执行的语句）

finally：

代码块（不管是否出现都会执行的语句）

语法规则：

执行try下的语句，如果引发异常，则执行过程会跳到第一个except语句；如果第一个except中定义的异常与引发的异常匹配，则执行该except中的语句；如果引发的异常不匹配第一个except，则会搜索第二个except（允许编写的except数量没有限制）。


异常的传播
当在函数中出现异常时，如果在函数中对异常进行了处理，则异常不会再传播， 如果函数中没有对异常进行处理，则异常会继续像函数调用处传播，如果函数调用处处理了异常，则不再传播，如果没有处理则继续像调用处传播，直到传递到全局作用域，如果依然没有处理，则程序终止，并且显示异常信息。

如：

自定义异常
抛出异常，可以是用raise语句来抛出异常，raise语句后面需要跟一个异常类或者是异常的实例，抛出异常的目的，告诉调用者这里调用时可能出现问题，希望你自己处理下。

一、异常的分类

二、异常的处理
针对异常，JVM的处理方式：

一旦遇到了程序出现了问题，就会把问题的类名，错误原因，错误的位置等信息打印在控制台，以便我们纠错。同时JVM会自动从出现问题处将程序终止掉，导致程序无法继续向下执行。

eg:
public class TestTryCatch {
	public static void main(String[] args) {
		System.out.println("程序开始了");
		String str = null;
		System.out.println(str.length());
		System.out.println("程序结束了");
}
}


为了让其他没问题的程序继续执行可以采用以下做法：

使用try——catch语句对异常进行捕获
public class TestTryCatch {
   public static void main(String[] args) {
   	System.out.println("程序开始了");
   	try{
   	String str = null;
   	System.out.println(str.length());
   	}catch(NullPointerException e){
   		System.out.println("出现了空指针");
   	}
   	System.out.println("程序结束了");
}
}
   


<2.1.1> java异常处理机制中的try——catch语法：

try{
代码片段
}catch(xxxException e){
捕获try代码片段中出现的xxxException
后的处理手段
}


注意事项了解一下：

1.在try代码块中，发生异常语句后面的代码是不会被执行的。
2.catch可以定义多个，针对不同的异常有不同的处理手段时，可以分别捕获这些异常。
3.应当有一个好习惯，在最后一个catch中捕获Exception，尽量避免因为一个 未捕获的异常导致程序中断。捕获顺序应是子类型异常在上面先捕获，父类型异常在下后捕获。
<2.1.2> finally
在程序中，有时候我们希望有些语句无论程序是否发生异常都要执行，这时就可以在

try-catch语句后加一个finally代码块。
@Test
	public void testFinallyDemo1(){
		System.out.println("程序開始了");
		try{
			String str = null;
			System.out.println(str.length());
		}catch(Exception e){
			System.out.println("程序出错了");
		}finally{
			System.out.println("finally中的代码运行了");
		}
		System.out.println("程序结束了");
	}



finally中需要注意的：

finally块是异常捕获机制中的最后一块。
finally可以直接跟在try后面或者最后一个catch之后。
finally可以保证只要程序执行到try语句块中，无论try语句块中的代码是否抛出异常，finally块中的代码都必定执行。
通常会将无论是否出现异常都要运行的代码放在finally中确保运行，比如IO操作中的关闭流。
有一点需要注意一下，finally中的代码有一种情况下是不会执行的，那就是在

try-catch中执行了System.exit(0)语句。System.exit(0)表示退出当前的Java虚拟机，Java虚拟机停止了，任何代码都不能再执行了。

<2.1.3> throws
如果调用自己的方法，我们很清楚该方法可能会发生的异常。试想一下，如果去调用一个别人写的方法时，是否能知道别人写的方法是否会有异常呢？这是很难做出判断的。针对这种情况，Java中允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常，这样调用者在调用时，就明确的知道方法有异常，并且需要调用者对异常进行处理，否则编译无法通过。

eg:



从该例可以看出，当在方法声明抛出一个异常时，在主函数中调用时，必须对该异常进行处理，否则编译不会通过。一般在主函数调用声明异常的方法时，选择对其进行

try-catch处理。



注意事项：

派生类在继承超类时会重写其方法，那么在重写超类中含有throws声明异常抛出的方法时，对throws的重写规则：

可以不再抛出任何异常
可以仅抛出父类方法抛出的部分异常
可以抛出父类方法抛出异常的子类型异常
不允许抛出父类方法抛出异常的父类型异常
不允许抛出额外异常

public class ThrowsDemo {
    public void dosome() throws IOException,AWTException{
    	
    }
class Son extends ThrowsDemo{
//	public void dosome() throws IOException,AWTException{
//		
//	}
	/*
	 * 可以不再抛出任何异常
	 */
//	public void dosome(){
//		
//	}
	/*
	 * 可以仅抛出父类方法抛出的部分异常
	 */
//	public void dosome() throws IOException{
//		
//	}
	/*
	 * 可以抛出父类方法抛出异常的子类型异常
	 */
//	public void dosome() throws FileNotFoundException{
//		
//	}
	/*
	 * 不允许抛出额外异常
	 */
	//public void dosome() throws SQLException{}  SQLException并非继承自Throwable,而是继承自 java.lang.Exception。
	/*
	 * 不允许抛出父类方法抛出异常的父类型异常
	 */
//	public void dosome() throws Exception{}
}

<2.1.4> throw
当不满足业务逻辑要求时，可以主动抛异常。当一个方法中使用throw抛出一个异常时，就应该在当前方法上使用throws声明该异常的抛出，通知调用者在调用当前方法时要处理异常（RuntimeException除外）否则编译不通过。

eg:
/*
 * 使用当前类测试异常的抛出 
 */
public class Person {
     private  int age;

	/**
	 * @return the age
	 */
	public int getAge() {
		return age;
	}

	/**
	 * @param age the age to set
	 */
	public void setAge(int age) throws Exception{
		if(age<0||age>100){
			throw new Exception("年龄不合法");
		}
		this.age = age; 
	}
}


@Test
public void testThrowDemo(){
	System.out.println("程序开始了");
	Person p = new Person();

		try {
			p.setAge(100000);
		} catch (Exception e) {
			e.printStackTrace();
		}
	System.out.println("此人年龄："+p.getAge());
	System.out.println("程序结束了");
}


三、自定义异常
JDK中定义了大量的异常类，虽然这些异常类可以描述编程时出现的大部分异常情况，但是在程序开发中有时可能需要描述程序中特有的异常情况。为了解决这个问题，在java中允许用户自定义异常，但自定义异常必须继承自Exception类或其他子类。
/**
 * 年龄不合法异常
 * 
 * 自定义异常通常用来说明某些业务逻辑错误
 */
public class IllegalAgeException extends Exception{

	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	public IllegalAgeException() {
		super();
		// TODO Auto-generated constructor stub
	}

	public IllegalAgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
		super(message, cause, enableSuppression, writableStackTrace);
		// TODO Auto-generated constructor stub
	}

	public IllegalAgeException(String message, Throwable cause) {
		super(message, cause);
		// TODO Auto-generated constructor stub
	}

	public IllegalAgeException(String message) {
		super(message);
		// TODO Auto-generated constructor stub
	}

	public IllegalAgeException(Throwable cause) {
		super(cause);
		// TODO Auto-generated constructor stub
	}
    
}
注意：在实际开发中，如果没有特殊的要求，自定义的异常类只需继承Exception类
，在构造方法中使用supper（）语句调用Exception的构造方法即可。


既然自定义了异常，那么该如何使用呢？这时就需要用到throw关键字，throw关键字用于在方法中声明抛出异常的实例对象。

语法格式：
throw Exception  异常对象

eg:


/*
 * 使用当前类测试异常的抛出 
 */
public class Person {
     private  int age;

	/**
	 * @return the age
	 */
	public int getAge() {
		return age;
	}

	/**
	 * @param age the age to set
	 */
	public void setAge(int age) throws IllegalAgeException{
		if(age<0||age>100){
			throw new IllegalAgeException("年龄不合法");
		}
		this.age = age; 
	}
}

测试异常的抛出：

因为首先我们自定义了异常类，且在Person类中使用了throw关键字在方法中向调用者抛出了IllegalAgeException异常，所以在调用该方法p.setAge()时，调用者必须处理异常，否则编译不通过。

/*
 * 测试异常的抛出
 */
public class ThrowDemo {
@Test
public void testThrowDemo(){
	System.out.println("程序开始了");
	Person p = new Person();
	
		/*
		 * 当调用一个含有throws声明异常抛出的方法时，编译器要求必须处理这个异常
		 * 而处理方式有两种：
		 * 1.使用try——catch处理该异常
		 * 2.在当前方法上继续声明throws将该异常抛出
		 * 具体如何处理，结合实际业务需求而定。
		 */
		try {
			p.setAge(10);
		} catch (IllegalAgeException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	System.out.println("此人年龄："+p.getAge());
	System.out.println("程序结束了");
}
}


Tips
finally和final的区别：

final,最终的意思。可以修饰类，方法，变量。

修饰类，类不能被继承，但可以继承别人。

修饰方法，方法不能被重写。

修饰变量，变量是常量。
finally

异常处理的一部分。被finally控制的代码块一定会执行。
throw和throws的区别：

throws：

用在方法声明后面，跟的是异常类名
可以跟多个异常类名，用逗号隔开
表示抛出异常，由该方法的调用者来处理
throws表示出现异常的一种可能性，并不一定会发生这些异常。

throw：

用在方法体内，跟的是异常对象名
只能抛出一个异常对象名
表示抛出异常，由方法体内的语句处理
throw是抛出了异常，执行throw则一定抛出了某种异常
如果throw的是编译时期异常，在方法声明上必须用throws进行标记
如果throw的是运行时期异常，在方法声明上可以用throws进行标记，也可以不用。

异常

在程序运行的过程中，不可避免的会出现一些错误。比如 使用了不存的索引，引用了没有赋值的变量… 这些错误我们就称之为异常

程序一旦出现异常，会导致程序立即终止。异常后面的代码都不会执行
处理异常

程序出现异常，目的并不是让我们的程序终止，而是希望我们在出现异常的时候，能够编写响应的代码来对异常进行处理


try 语句：

语法：
try:
    代码块(可能出现错误的语句)
except 异常类型 as 异常名:
    代码块(出现错误以后的处理方式)
except 异常类型 as 异常名:
    代码块(出现错误以后的处理方式)
except 异常类型 as 异常名:
    代码块(出现错误以后的处理方式)
else:
    代码块(没有出现错误的语句)
finally:
    代码块(该代码总会执行)


在未知错误类型的时候：
try:
	print(6/0)
except:
	print("语句错误")
else:
	print("执行完成")

屏幕输出:除数不能为0

在已知错误类型的时候：

（如果出现的错误 跟 except中的错误不相同，则直接报错，不会执行except中的代码）
try:
	print(6/0)
except ZeroDivisionError as a:
	print(a)

屏幕输出：division by zero

（except如果指定异常 只会捕获指定的异常）

在未知情况下，想知晓错误类型，和错误内容，此时可以用到一个关键字

Exception
try:
	print(6/0)
except Exception as a:
	print(a,type(a))

屏幕输出：division by zero <class 'ZeroDivisionError'>


异常的传播

当函数中出现异常的时候，如果在函数中对异常进行了处理，则异常不会在继续传播,如果在函数中没有对异常进行处理，则异常会继续向函数调用处传播

def fn():
	print(6/0)
fn()

控制台显示：
Traceback (most recent call last):
  File "......", line 3, in <module>
    fn()
  File "......", line 2, in fn
    print(6/0)
ZeroDivisionError: division by zero



文件

打开文件：

语法：open(文件路径)

返回值：当前打开的文件作为对象返回

例如打开一个位于C:\Users\xiao_weiyu\Desktop\资料.txt 的文本文档
file_name = "C:\Users\xiao_weiyu\Desktop\资料.txt "
file_one = open(file_name)


关闭文件：

语法：文件对象.close( )

（关闭文件，是为了节省空间，优化程序）
file_name = "test.txt"
file_one = open(file_name)
file_one.close()

这样关闭文件容易，当代码较多时容易遗漏close()

更简洁的方式：

with as

语法：with open(文件路径) as 接收文件变量:
file_name = "test.txt"
with open(file_name) as file_one:
	content = file_one.read()

执行完代码块 程序会自动关闭文件

文件写入：

open()函数来进行文件的操作(读 写 追加)，如果不指定操作类型，则默认是读取文件

w 表示是可写的。如果文件不存在，它会帮我们来创建一个文件并写入内容。如果文件存在则会覆盖原文件的内容

a 表示追加内容
例如在当前目录创建一个名为：test.txt 的文本文档，并写入内容：abc

write( ) 方法 用来写入数据

语法：文件对象.write(内容)
file_name = "test.txt"
with open(file_name,"w") as file_one:
	file_one.write("abc")


文件读取

（open()函数 默认为读取操作 如不指定操作）

调用open()来打开一个文件的时候，可以将文件分为两种类型

第一种 是纯文本(使用utf-8等编写的文本文件)

第二种 是二进制文件(音频、视频、图片…)

open()函数它默认打开文件是以纯文本的形式
例如读取一个名为：test.txt 文本文档 内容为：你好世界

内容为中文，此时需要标明解码格式为：utf-8

read( ) 方法 用来读取数据

语法：文件对象.read(内容长度)     默认内容长度：-1     表示全部读取
file_name = "test.txt"
with open(file_name,encoding="utf-8") as file_one:
	content = file_one.read()


较大文件读取：

（如果一个文件内容过多，一次性读取完所有内容，很容易导致电脑死机）

read( ) 可以接受一个size作为参数，该参数用来指定读取字符的数量

默认值为-1 读取全部的内容

例如先读100个字符（字符和中文都算作一个）
file_name = "test.txt"
with open(file_name,encoding="uft-8") as file_one:
	file_one.read(100)


readline( )

作用：每次只读取一行

如果想每次读取一行，直到读取完，才截止,可以这样写
file_name = "test.txt"
with open(file_name,encoding="utf-8") as file_one:
	while True:
		content = file_one.readline()
		if not content:
			break
		else:
			print(content,end="")


readlines( )

作用：读取整个文件所有行，保存在一个列表(list)变量中，每行作为一个元素，但读取大文件会比较占内存。

（每行的\n也会被记录）
文件内容:
#你好世界
#你好python
#你好c语言
#你好java

file_name ="test.txt"
with open(file_name,encoding="utf-8") as file_one:
	content = file_one.readlines()

此时content:['你好世界\n', '你好python\n', '你好c语言\n', '你好java']