本文主要是介绍Java基础——5、异常处理，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

接上一章
面向对象（下）

目录

• 1、异常的概述与体系结构
• 2、常见异常java.lang.Exception
• • 2.1、举例几个运行时异常:java.lang.RuntimeException
  • • 2.1.1、 java.lang.ArrayIndexOutOfBoundsException: 11
    • 2.1.2、java.lang.NullPointerException
    • 2.1.3、java.lang.ClassCastException
    • 2.1.4、java.lang.NumberFormatException
    • 2.1.5、java.util.InputMismatchException
    • 2.1.6、java.lang.ArithmeticException
• 3、重点、异常处理机制一、try-catch-finally
• 4、重点、异常处理机制二、throws + 异常类型
• 5、手动抛出异常：throw
• • 5.1、RuntimeException运行时异常
  • 5.2、Exception编译时异常
• 6、用户自定义异常类

1、异常的概述与体系结构

2、常见异常java.lang.Exception

2.1、举例几个运行时异常:java.lang.RuntimeException

2.1.1、 java.lang.ArrayIndexOutOfBoundsException: 11

public static void main(String[] args) {
		//java.lang.ArrayIndexOutOfBoundsException: 11
		int[] arr = new int[10];
		System.out.println(arr[11]);//数组下标越界异常
	}

2.1.2、java.lang.NullPointerException

public static void main(String[] args) {
		//java.lang.NullPointerException
		int[] arr = null;
		System.out.println(arr[3]);//空指针异常
		
	}

2.1.3、java.lang.ClassCastException

public static void main(String[] args) {
		//java.lang.ClassCastException
		Object date = new Date();
		String str = (String)date;//类型转换异常  Date类型不能转换为String类型
	}

2.1.4、java.lang.NumberFormatException

public static void main(String[] args) {
		//java.lang.NumberFormatException
		String str = "123";
		str = "abc";
		int num = Integer.parseInt(str);//数字格式异常
		
	}

2.1.5、java.util.InputMismatchException

public static void main(String[] args) {
		//java.util.InputMismatchException 输入不匹配异常
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入int类型的值：");
		int int1 = sc.nextInt();
		System.out.println(int1);
	}

结果如下：

2.1.6、java.lang.ArithmeticException

public static void main(String[] args) {
		//java.lang.ArithmeticException
		int a = 10;
		int b = 0;		
		System.out.println(a/b);//算术异常
	}

3、重点、异常处理机制一、try-catch-finally

异常的处理：抓抛模型
过程一："抛"：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。并将此对象抛出。
				一旦抛出对象以后，其后的代码就不在执行。
过程二："抓"：可以理解为异常的处理方式:
			1、try-catch-finally
			2、throws

格式：
		try {
			//可能出现异常的代码
		} catch (异常类型1 变量名1) {
			//处理异常的方式
		} catch (异常类型2 变量名2) {
			//处理异常的方式
		}finally {
			//一定会执行的代码
		}
		
说明：
1、finally是可以选的。
2、使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，
   就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
3、一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。
   一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况），继续执行其后的代码
4、catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
   catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错。看图一
   

图一

public static void main(String[] args) {
		String str = "123";
		str = "abc";
		try {
			//可能出现异常的代码
			int int1 = Integer.parseInt(str);
			System.out.println(int1);
		} catch (NumberFormatException e) {
			//处理异常的方式
			System.out.println("出现数值转换异常了");
			System.out.println(e.getMessage());//For input string: "abc"
			e.printStackTrace();
			/*
			 * 控制台打印结果如下：
			 * 出现数值转换异常了
			 * For input string: "abc"
			 * java.lang.NumberFormatException: For input string: "abc"
			at java.lang.NumberFormatException.forInputString(NumberFormatException.java:65)
			at java.lang.Integer.parseInt(Integer.java:580)
			at java.lang.Integer.parseInt(Integer.java:615)
			at com.demo11_4.test11_11.ExceptionTest.main(ExceptionTest.java:12)
			 */
		} catch (NullPointerException e) {
			//处理异常的方式
			System.out.println("出现空指针异常了");
		} catch (Exception e) {
			//处理异常的方式
		}finally {
			//一定会执行的代码
		}
	}

5、常用的异常对象处理的方式：
5.1、String getMessage()

5.2、e.printStackTrace();

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

4、重点、异常处理机制二、throws + 异常类型

public class ExceptionTest2 {
	public static void main(String[] args) {
		try {
			method2();//2、调用该方法，发现该方法自带未处理的异常，此时的做法就是try-catch解决异常
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	public static void method2() throws FileNotFoundException, IOException {
		method1();//1、该方法想调用method1方法，要么选择try-catch解决异常，要么就像现在，抛出异常
	}
	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();//关闭流,关闭资源
	}
}

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

2. 体会: try-catch- finally :真正的将异常给处理掉了。
         throws的方式只是将异常抛给了方法的调用者。并没有真正将异常处理掉。

5、手动抛出异常：throw

5.1、RuntimeException运行时异常

public class ExceptionTest3 {
	public static void main(String[] args) {
		Student s = new Student();
		s.regist(-100);
		System.out.println(s);//java.lang.RuntimeException: throw自定义异常，您输入的数据非法！
	}

}

class Student{
	private int id;
	public void regist(int id){
		if (id > 0) {
			this.id = id;
		} else {
			//手动抛出异常对象  RuntimeException运行时异常
			throw new RuntimeException("throw手动抛出异常，您输入的数据非法！");

		}
	}
}

结果如下：

5.2、Exception编译时异常

public class ExceptionTest3 {
	public static void main(String[] args) {
		try {
			Student s = new Student();
			s.regist(-100);
			System.out.println(s);//java.lang.Exception: throw自定义异常，您输入的数据非法！
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

class Student{
	private int id;
	public void regist(int id) throws Exception{
		if (id > 0) {
			this.id = id;
		} else {
			//手动抛出异常对象  编译时异常，需要显示的去处理该异常
			throw new Exception("throw自定义异常，您输入的数据非法！");

		}
	}
}

结果如下：

6、用户自定义异常类

/*
 * 如何自定义异常类？
 * 1、继承于现有的异常结构：RuntimeException 、Exception
 * 2、提供全局常量serialVersionUID
 * 3、提供重载的构造器
 */
public class MyException extends Exception {//1、自定义的异常类
	//随便写一个long型的数 对我自己定义的这个异常类MyException取一个唯一标识
	static final long serialVersionUID = -7034895454074576939L;//2、序列号

	public MyException() {
	}
	//3、
	public MyException(String message) {
		super(message);
	}
}

public class ExceptionTest3 {
	public static void main(String[] args) {
		try {
			Student s = new Student();
			s.regist(-100);
			System.out.println(s);//com.demo11_4.test11_11.MyException: throw自定义的异常类，不能输入负数！
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

class Student{
	private int id;
	public void regist(int id) throws Exception{
		if (id > 0) {
			this.id = id;
		} else {
			//手动抛出异常对象  编译时异常，需要显示的去处理该异常
			throw new MyException("throw自定义的异常类，不能输入负数！");

		}
	}
}

结果如下：

编译时异常：执行javac.exe命名时，可能出现的异常（面对这个问题，就必须得try-catch或者throws抛出异常）
运行时异常：执行java.exe命名时，可能出现的异常RuntimeException

这篇关于Java基础——5、异常处理的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！