Java第十三作业

1、认识异常：

        异常是导致程序中断运行的一种指令流。如果不对异常进行正常处理，则可能导致程序的中断执行，造成不必要的损失。

1.1异常的抛

1、定义 ： 一个方法不处理这个异常，而是调用层次向上传递，谁调用这个方法，这个异常就由谁来处理。

2、throw : 将产生的异常抛出(强调的是动作)，抛出的既可以是异常的引用，也可以是异常对象。（位置: 方法体内）

3、throws : 如果一个方法可能会出现异常，但没有能力处理这种异常，可以在方法声明处用throws子句来声明抛出异常。用它修饰的方法向调用者表明该方法可能会抛出异常（可以是一种类型，也可以是多种类型，用逗号隔开）（位置: 写在方法名 或方法名列表之后 ，在方法体之前。）

注意 ： 调用可能会抛出异常的方法，必须添加try-catch代码块尝试去捕获异常 或者 添加throws 声明 来将异常 抛出给更上一层的调用者进行处理,这里需要注意一个细节:新的异常包含原始异常的所有信息，根据这个我们可以去追溯最初异常发生的位置。

异常范例

代码

class Exc{//创建一个类
	int i=10;//定义一个整型变量并初始化
}
public class ExceptionDemo01 {//创建一个类
 
	public static void main(String[] args) {//主方法
		int a=10;//定义一个整型变量并初始化
		int b=0;//定义一个整型变量并初始化
		int temp=a/b;//计算两个变量的商
		System.out.println(temp);//输出结果
 
	}
 
}

结果

2、处理异常：

异常格式：

try{//捕捉异常
异常语句
}catch(Exception e){//处理异常
 
}
finally{//会执行的语句
一定会执行的代码

代码

class Exc{//创建一个类
	int i=10;//定义一个整型变量并初始化
}
public class ExceptionDemo01 {//创建一个类
 
	public static void main(String[] args) {//主方法
		int a=10;//定义一个整型变量并初始化
		int b=0;//定义一个整型变量并初始化
		int temp=0;//定义一个整型变量并初始化
		try{ temp=a/b;//计算两个变量的商
		}catch(ArithmeticException e){//处理异常
			System.out.println(e);//输出异常信息
		}
		
		System.out.println(temp);//输出结果
 
	}
 
}

结果

3、异常处理 -常见异常 

运行时异常（系统异常）不需要预处理，通过规范的代码可以避免产生这种异常
受检异常（编译时异常）必须预处理，否则编译报错，有两种预处理方式 :捕获处理
抛出处理

3.1try、catch和finally

异常的捕获和处理需要采用try和catch来处理，
try中包含了可能产生异常的代码
try后面是catch，catch可以有一个或多个，catch中是需要捕获的异常
当try中的代码出现异常时，出现异常下面的代码不会执行，马上会跳转到相应的catch语句块中，如果没有异常不会跳转到catch中
finally表示，不管是出现异常，还是没有出现异常，finally里的代码都执行，finally和catch可以分开使用，但finally必须和try一块使用，如下格式使用finally也是正确的

3.2异常的捕获顺序

异常的捕获：一般按照由小到大的顺序，也就是先截获子异常，再截获父异常,将IOException放到前面，会出现编译问题，因为IOException是FileNotFoundException的父类，所以截获了IOException异常后，IOException的子异常都不会执行到，所以再次截获FileNotFoundException没有任何意义,异常的截获一般按照由小到大的顺序，也就是先截获子异常，再截获父异常。这里只是为了说明捕获顺序，实际中，关闭流资源fis.close()是在finally语句块中处理的。

4、throws抛出处理

在定义方法时，如果方法体中有受检（编译时）异常需要预处理，可以捕获处理，也可以抛出处理。处理异常时，使用throws抛出处理：谁调用这个方法，谁负责处理该异常
在定义方法时，把异常抛出就是为了提醒方法的使用者，有异常需要预处理
在处理异常时，是选择捕获处理还是抛出处理

一般情况下，在调用其他方法时，如果被调用的方法有受检（编译时）异常需要预处理，选择捕获处理，因为你调用了方法， 你负责处理该异常。
在定义方法时，如果方法体中有受检异常需要预处理，可以选择捕获 ，也可以选择抛出处理。如果方法体中通过throw语句抛出了一个异常对象，所在的方法应该使用throws声明该异常。

4.1方法覆盖中的异常处理 

方法覆盖(重写)规则：

方法签名必须相同，方法名与参数列表就是方法签名

方法的返回值类型可以相同 ，子类方法的返回值类型也可以是父类方法返回值类型的子类型

子类方法的访问权限可以更宽泛(更大)
a、如果父类方法使用public修饰，子类方法只能是public修饰
b、如果父类方法使用protected修饰，子类方法可以是protected或者public修饰

子类方法的异常要比父类方法的异常更小
a、如果父类方法没有抛出异常，子类重写后也不能抛出异常
b、如果父类方法抛出了异常，子类方法可以抛出相同的异常，也可以抛出父类异常的子异常，也可以不抛出异常 

class Exc{//创建一个类
	int a=10;//定义一个整型变量并初始化
	int b=10;//定义一个整型变量并初始化
}
public class ExceptionDemo01 {//创建一个类
 
	public static void main(String[] args) {//主方法
		
		int temp=0;//定义一个整型变量并初始化
		Exc e=null;//创建对象
		//e=new Exc();//实例化对象
		try{//捕捉异常
			temp=e.a/e.b;//计算商
			System.out.println(temp);//输出结果
		}catch(NullPointerException e2){//处理异常
			System.out.println("空指针异常："+e2);//输出异常信息
		}catch(ArithmeticException e2){//处理异常
			System.out.println("算数异常："+e2);//输出异常信息
		}
		finally{//最后一定会执行的代码
			System.out.println("程序推出");//输出信息
		}
 
		
 
	}
 
}

结果

 常见异常

1. 数组越界异常：ArrayIndexOutOfBoundsException
2. 数字格式化异常：NumberFormatException
3. 算数异常：ArithmeticException
4. 空指针异常：NullPointerException

5、throws关键字

throw
throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。

throw是具体向外抛出异常的动作，所以它抛出的是一个异常实例，执行throw一定是抛出了某种异常。

throw一般用于抛出自定义异常。

throws
throws语句是用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理。

throws主要是声明这个方法会抛出某种类型的异常，让它的使用者要知道需要捕获的异常的类型。

throws表示出现异常的一种可能性，并不一定会发生这种异常。

总结下 throw 和throws 关键字的区别

1、写法上 : throw 在方法体内使用，throws 函数名后或者参数列表后方法体前
2、意义 ： throw 强调动作，而throws 表示一种倾向、可能但不一定实际发生
3、throws 后面跟的是异常类，可以一个，可以多个，多个用逗号隔开。throw 后跟的是异常对象，或者异常对象的引用。
4、throw 用户抛出异常，当在当前方法中抛出异常后，当前方法执行结束（throw 后，如果有finally语句的话，会执行到finally语句后再结束。）。可以理解成return一样。

代码

public class ExceptionDemo02 {//创建类
	 
	public static void main(String[] args) {//主方法
		tell(10,0);//调用方法并传入值
	}
	public static void tell(int i,int j)throws ArithmeticException{//创建类并抛出算数异常
		int temp=0;//定义一个整型变量并初始化
		temp=i/j;//计算商
		System.out.println(temp);//输出信息
	}
 
}

结果 

代码

public class ExceptionDemo02 {//创建类
	 
	public static void main(String[] args) {//主方法
		try{//捕捉异常
			tell(10,0);//调用方法并传入值
		}catch(Exception e){//处理异常
			System.out.println(e);//输出异常信息
		}
	}
	public static void tell(int i,int j)throws ArithmeticException{//创建类并抛出算数异常
		int temp=0;//定义一个整型变量并初始化
		temp=i/j;//计算商
		System.out.println(temp);//输出信息
	}
 
}

结果 

代码

public class ExceptionDemo02 {//创建类
	 
	public static void main(String[] args)throws Exception {//主方法并抛出异常
		
			tell(10,0);//调用方法并传入值
	}
	public static void tell(int i,int j)throws ArithmeticException{//创建类并抛出算数异常
		int temp=0;//定义一个整型变量并初始化
		temp=i/j;//计算商
		System.out.println(temp);//输出信息
	}
 
}

结果 

throw关键字

1.throw关键字抛出一个异常，抛出的时候直接抛出异常类的实例化对象即可。

代码

public class ExceptionDemo03 {//创建类
	 
	public static void main(String[] args) {//主方法
		try{//捕捉异常
			throw new Exception("实例化异常对象");//利用throw关键字直接抛出异常实例化对象
		}catch(Exception e){//处理异常
			System.out.println(e);//输出异常信息
		}
 
	}
 
}

结果  

6、自定义异常：

1.自定义异常直接继承Exception就可以完成自定义异常类。

2、前面所讲的异常，都是系统自带的，系统自己处理，但是很多时候项目会出现特有问题，而这些问题并未被java所描述并封装成对象，所以对于这些特有的问题可以按照java的对问题封装的思想，将特有的问题进行自定义异常封装。在Java中要想创建自定义异常，需要继承Throwable或者他的子类Exception。

代码

class MyException extends Exception{//创建自定义异常类并继承父类
	public MyException(String msg){//定义方法并传入一个字符串参数
		super(msg);//调用父类构造方法
	}
}
public class ExceptionDemo04 {//创建类
 
	public static void main(String[] args) {//主方法
		try{//捕捉异常
			throw new MyException("自定义异常");//直接抛出自定义异常实例化对象
		}catch(MyException e){//处理异常
			System.out.println(e);//输出异常信息
		}
 
	}
 
}

结果