本文主要是介绍day16：java异常，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

java异常

• 异常概述与异常体系结构（常见异常）
• • 异常中的错误Error
  • 异常中的Exception
• 异常处理机制
• • 异常的处理：抓抛模型
  • 一、tray-catch-finally
  • 二、throws方式
• 手动抛出异常
• 自定义异常
• 综合

异常概述与异常体系结构（常见异常）

异常中的错误Error

/*
 * Error:java虚拟机都无法解决的严重问题
 * 一般无法编写针对性的代码
 * 出现后缀为Error就是错误不是异常，无法通过代码改变，只能改代码
 */

public class ErrorTest {
	public static void main(String[] args) {
	//	main(args);//递归调用，栈溢出，main方法调用main方法：java.lang.StackOverflowError
	Integer[] arr = new Integer[1024*1024*1024];//堆溢出OOM，java.lang.OutOfMemoryError
	}

}

异常中的Exception

编译时异常比较严重，编译时就报错了
常见的运行时异常

import java.io.File;
import java.io.FileInputStream;
import java.util.Date;
import java.util.Scanner;

import org.junit.jupiter.api.Test;

/*
 * 一、异常的体系与结构
 * java.lang.Throwable
 * 		|---java.lang.Error : 一般不编写针对性的代码进行处理
 * 		|---java.lang.Exception : 可以进行异常的处理
 * 			|----编译时异常（checked）:
 * 					IOException , FileNotFondException , ClassNotFoundException
 * 			|----运行时异常（unchecked）:
 * 					NullPointerException , ArrayIndexOutOfBoundsException,
 * 					ClassCastException , NumberFormatException,
 * 					InputMismatchException , ArithmaticException
 *面试题：常见的异常有哪些？举例说明。
 */	

public class ExceptionTest {
	//***********************以下是运行时异常*********************
	//NullPointerException:空指针异常
	@Test
	public void test1() {
		int[] arr = null;
		System.out.println(arr[3]);
		
		String str = "abc";
		str = null;
		System.out.println(str.charAt(0));
	}
	
	//***********************************************************
	
	//ArrayIndexOutOfBoundsException:数组角标越界
	@Test
	public void test2() {
		int[] arr = new int[10];
		System.out.println(arr[10]);
		
		String str = "abc";
		System.out.println(str.charAt(3));
	}
	
	//************************************************************
	
	//ClassCastException
	@Test
	public void test3() {
		Object obj = new Date();
		String str = (String)obj;
	}
	
	//*************************************************************
	
	//NumberFormatException
	@Test
	public void test4() {
		String str = "123";
		str="abc";
		int num = Integer.parseInt(str);
	}
	
	//****************************************************************
	
	//InputMismatchException
	@Test
	public void test5() {
		Scanner sc = new Scanner(System.in);
		//当输入为整数时不会报错，当输入为整数以外的数字或字符时，报错InputMismatchException
		int score = sc.nextInt();
		sc.close();
	}
	
	//****************************************************************
	//ArithmaticException:算数异常
	@Test
	public void test6() {
		int a=10;
		int b=0;
		System.out.println(a/b);
	}
	//***********************以下是编译时异常*********************
//	@Test
//	public void test7() {
//		File file = new File("hello.txt");
//		FileInputStream fis = new FileInputStream(file);
//		
//		int data = fis.read();
//		while(data != -1) {
//			System.out.println((char)data);
//			data = fis.read();
//		}
//		fis.close();
//	}
}

异常处理机制

异常的处理：抓抛模型

过程一： “抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处，生成一个对应的异常类的对象。并将此对象抛出。一旦抛出对象后，其后面的代码就不在执行

关于异常的产生：

1、系统自动生成异常对象
2、手动生成异常对象，并抛出（throw）

过程二： “抓”：可以理解为异常的处理方式：1、try-catch-finally 2、throws

一、tray-catch-finally

try{
	//可能出现异常的代码
 }catch(异常类型1 变量名1){
 	//处理异常的方式1
 }catch(异常类型2 变量名2){
 	//处理异常的方式2
 }catch3(异常类型3 变量名3){
 }
 .....
 finally{
 	//一定会执行的代码
 }

说明：
1、finally是一个可选的
2、使用try将可能出现的异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个异常类的对象，根据此对象的类型，到catch中去匹配为哪种异常，若都没有则向控制台报出异常运行终止，若有则执行处理方式。
3、一旦try中的异常对象匹配到某个catch时，就进入catch中进行异常类的处理，一旦处理完成就跳出当前的try-catch（在没有写finally的情况下），继续执行其后的代码。
4、catch中的异常类型，若没有继承关系，则谁声明在上，谁声明在下没有关系，若catch中的异常类型满足子父类关系，要求子类一定声明在父类的上面，否则报错。
5、常用的异常对象处理的方式，1、String getMessage() 2、printStackTrace()
6、在try结构中，在出了try结构后就不能再调用
7、try-catch-finally结构可以嵌套

体会1：使用try-catch-finally处理编译时异常，是将程序编译时就不再报错，但是在运行时仍可能报错，相当于使用try-catch-finally将一个编译时可能出错的异常，延迟至运行时出现。

体会2：开发时，由于运行时异常比较常见，所以我们通常不针对运行时异常编写try-catch-finally了，针对编译时异常，我们说一定考虑异常的处理。

	@Test
	public void test1() {
		String str = "123";
		str = "abc";
		try {
		int num = Integer.parseInt(str);
		System.out.println("hello-----1");
		}catch(NumberFormatException e) {
			//System.out.println("出现数值转换异常。。。。");
			//String的 getMessage()
			//System.out.println(e.getMessage());
			//printStackTrace
			e.printStackTrace();
		}catch(Exception e2) {//eclipse CTRL+T 可查看继承关系
			System.out.println("出现异常！");
		}
		System.out.println("hello-----2");
	}

try-catch-finally结构中finally的使用
1、finally是可选的
2、finally声明的是一定会被执行的代码，即使catch中又出现异常了，try中有return语句，catch中有return语句等情况。
3、像数据库的链接，输入输出流、网络编程中的Socket等资源，JVM是不能自动回收的，需要手动的进行资源的进行资源的释放，此时的资源释放就需要放在finally中。

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.junit.jupiter.api.Test;
/*
try-catch-finally结构中finally的使用
*/
public class FianllyTest {
	

	
	@Test
	public void test1() {
		try {
		int a = 10;
		int b = 0;
		System.out.println(a/b);
		}catch(ArithmeticException e) {
			//e.printStackTrace();
			int[] arr = new int[10];
			System.out.println(arr[10]);//catch中又有错误，没有try去捕获它
			
		}catch(Exception e2) {
			e2.printStackTrace();
		}finally {
			System.out.println("一定会执行");
		}
	}
	
//************************************************************	
	
	public int method() {
		try {
			int[] arr = new int[10];
			System.out.println(arr[10]);
			return 1;
		}catch(ArrayIndexOutOfBoundsException e) {
			e.printStackTrace();
			return 2;
		}finally {
			System.out.println("一定会被执行");
			return 3;
		}
	}
	
	@Test
	public void test2() {
		int num = method();
		System.out.println(num);//3
	}
//***********************************************************
	@Test
	public void test3() {
	//eclipse自动包含try-catch结构：右键--->Surround With---->Try/catch Block
		FileInputStream fis=null;
		try {
			File file = new File("hello.txt");//当前目录下的hello.txt文件
			fis = new FileInputStream(file);
			
			int data = fis.read();
			while(data != -1) {//打印hello,java!
				System.out.print((char)data);
				data = fis.read();
			}
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				if(fis != null)//为了避免空指针异常
					fis.close();//关闭资源
			} catch (IOException e) {
				e.printStackTrace();//若没有hello.txt文件则打印错误信息
			}
		}
	}
}

二、throws方式

异常处理的方式二：throws + 异常类型

1、“throws + 异常类型” 写在方法的声明处，指明此方法执行时抛出异常的类型。一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象。此对象满足throws后面异常的类型时，异常就会被抛出。方法中异常代码后续的代码不再执行！

2、体会：

try-catch-finally:真正处理掉异常。
throws:将方法抛给调用者，并没有将异常真正的处理掉。

3、开发中，如何选择使用try-catch-finally 还是 throws？

3.1、如果父类中被重写的方法没有throws方法处理异常，则子类重写也不能使用throws，意味着如果子类重写的方法有异常，必须使用try-catch-finally方式处理。
3.2、执行的方法a中，先后又调用了另外几个方法，这几个方法是递进关系执行的，我们建议这几个方法使用throws的方式进行处理，而执行的方法a可以考虑使用try-catch-finally方式进行处理。

import java.io.*;
public class ExceptionTest2 {
	public static void main(String[] args) {
		try {
			method2();//main方法调用method2方法，并处理异常
		} catch (IOException e) {
			e.printStackTrace();
		}
		method3();//异常已被method3处理
	}
	
	public static void method3() {
		try {
			method2();//method3调用method2，并处理异常
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	
	
	public static void method2() throws FileNotFoundException,IOException{//IOException是FileNotFoundException的父类，写一个即可
		//再将异常向上抛
		method1();
	}

	//声明method1()方法，并抛出异常，throws + 异常类型
	public static void method1() throws FileNotFoundException,IOException{
		//向上抛出异常，在当前的方法中不处理该异常，异常交给调用者处理
		
		File file = new File("hello.txt");
		FileInputStream fis = new FileInputStream(file);
		
		int data = fis.read();
		while(data != -1) {
			System.out.println((char)data);
			data = fis.read();
		}
		fis.close();
		
		System.out.println("有机会执行吗？");//不执行
	}
}

import java.io.*;

/*
方法重写的规则之一：
子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
*/
public class OverrideTest {

}

class SuperClass{
	public void method() throws IOException{
	}
}
class SubClass extends SuperClass{
	public void method() throws FileNotFoundException{
	}
}

手动抛出异常

public class StudentTest {
	public static void main(String[] args) {
		Student s= new Student();
		
		try {
			s.regist(-1001);
		} catch (Exception e) {
//			e.printStackTrace();
			System.out.println(e.getMessage());//Message = "您输入的数据非法!" 
		}
		
		System.out.println(s);
	}
}

class Student {
	private int id;
	public void regist(int id) throws Exception {
		if(id > 0) {
			this.id=id;
		}else {
//			System.out.println("您输入的数据非法!");
			//手动抛出一个异常对象
			throw new Exception("您输入的数据非法！");//若输入的数据小于0，手动抛出异常。
		}
	}
	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}
	
}

自定义异常

//自定义一个异常类MyException
/*
如何于自定义异常类：
1、继承于现有的结构，RuntimeException、Exception
2、提供全局常量：serialVersionUID
3、提供重载的构造器
 */

public class MyException extends RuntimeException{
	static final long serialVersionUID = -703412310745766939L;//标识该异常的序列号
	
	public MyException() {
		
	}
	
	public MyException(String msg) {
		super(msg);
	}
}

public class StudentTest {
	public static void main(String[] args) {
		Student s= new Student();
		
		try {
			s.regist(-1001);
			System.out.println(s)
		} catch (Exception e) {
//			e.printStackTrace();
			System.out.println(e.getMessage());//Message = "不能输入负数!" 
		}
	}
}

class Student {
	private int id;
	public void regist(int id) throws Exception {
		if(id > 0) {
			this.id=id;
		}else {
			//System.out.println("您输入的数据非法!");
			//手动抛出一个异常对象
			//throw new Exception("您输入的数据非法！");//若输入的数据小于0，手动抛出异常。
			throw new MyException("不能输入负数");//MyException是自定义异常类
		}
	}
	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}
}

练习：

进入方法A
用A方法的finally
制造异常
进入方法B
调用方法B的finally

综合

//自定义异常类
public class EcDef extends Exception{
	static final long serialVersionUID =  -33875164229948L;

	public EcDef() {
	}
	public EcDef(String msg) {
		super(msg);
	}
}

public class EcmDef {
	public static void main(String[] args) {
		try {
		int i=Integer.parseInt(args[0]);
		int j=Integer.parseInt(args[1]);
		int resual = ecm(i,j);
		}catch(NumberFormatException e) {
			System.out.println("数据类型不一致");
		}catch(ArrayIndexOutOfBoundsException e){
			System.out.println("缺少命令行参数");
		}catch(ArithmeticException e) {
			System.out.println("除0错误");
		}catch(EcDef e) {
			System.out.println(e.getMessage());
		}
		//获取命令行参数的值，直接运行会报错--->缺少命令行参数
		//run Configurations--->自变量
		
	}
	public static int ecm(int i, int j) throws EcDef{
		if(i<=00 || j<0) {
			throw new EcDef("不能为负数");
		}
		return i/j;
	}
}

面试题：
1、final , finally , finalize 的区别？

结构相似类似：
throw 和 throws：

thow 表示抛出一个异常类的对象，生成异常对象的过程，声明在方法体内。
thows 属于异常处理的一种方式，声明在方法的声明处。

Collection 和 Collections
String 、StringBuffer 、 StringBuilder
ArrayList 、LinkedList
HashMap、LinkedHashMAp
重写、重载

结构不相似：
接口、抽象类
== 、equals();
sleep 、wait()

这篇关于day16：java异常的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！