java异常分类，异常处理，自定义异常

什么是异常？
程序运行过程中产生的不正常的情况统称为异常！
Throwable 类是 Java 语言中所有错误或异常的超类。提供了错误堆栈实现等一系列方法。有两个直接子类：Error & Exception

程序错误一般分为三种：

1.编译错误；2.运行时错误；3.逻辑错误。

（1）编译错误是因为程序没有遵循语法规则，编译程序能够自己发现并且提示我们错误的原因和位置，这个也是我们在刚接触编程语言最常遇到的问题。

（2）运行时错误是因为程序在执行时，运行环境发现了不能执行的操作。

（3）逻辑错误是因为程序没有按照预期的逻辑顺序执行。异常也就是指程序运行时发生错误，而异常处理就是对这些错误进行处理和控制。

先说一下java异常体系结构图吧：
java异常分类，异常处理，自定义异常
两个子类区别：

Error：程序不应该捕捉的错误，应该交由JVM来处理。一般可能指非常重大的错误。这个错误我们一般获取不到，也无法处理！
Exception：程序中应该要捕获的错误。这个异常类及它的子类是我们需要学习获取要处理的。

（1）RuntimeException：运行时异常，也叫未检查异常，是Exception的子类，但不需捕捉的异常超类，但是实际发生异常时，还是会导致程序停止运行的的，只是编译时没有报错而已。比如除数为零，数组空指针等等，这些都是在运行之后才会报错。此类异常，可以处理也可以不处理，并且可以避免。

（2）在Exception的所有子类中除了RuntimeException类和它的子类，其他类都叫做非运行时异常，或者叫已检查异常，通常被定义为Checked类，是必须要处理可能出现的异常，否则编译就报错了。Checked类主要包含：IO类和SQL类的异常情况，这些在使用时经常要先处理异常（使用throws或try catch捕获）。

java几种常见的异常：
运行时异常：
1，java.lang.ArrayIndexOutOfBoundsException 数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2，ArithmeticException 算术错误情形，如以零作除数，算术条件异常。
3 java.lang.SecurityException 安全性异常
4，IllegalArgumentException 方法接收到非法参数，非法参数异常！
5，java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
6，java.lang.NegativeArraySizeException 数组长度为负异常
7 java.lang.ClassNotFoundException 找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
8 java.lang.NullPointerException 空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等。
9，java.lang.NumberFormatException（数字格式转换异常）
10，java.lang.ClassCastException(强制类型转换异常)

IOException
1， IOException 操作输入流和输出流时可能出现的异常
2， EOFException 文件已结束异常
3， FileNotFoundException 文件未找到异常

异常的产生：

自动产生：当程序遇到错误代码，会产生异常，程序终止
手动产生：throw new 异常类名();
throw必须定义在在方法体中，用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止，它后面的语句执行不到，然后在包含它的所有try块中（可能在上层调用函数中）从里向外寻找含有与其匹配的catch子句的try块。

下面看一个手动抛出异常的例子：

package prac;
public class t2 {
	public static void main(String[] args) throws Exception {
		// TODO Auto-generated method stub
		m1();
	}

	public static void m1() throws Exception {
		System.out.println("m1----------start");
		m2();
		// 手动抛出受查异常
		throw new Exception();
		//System.out.println("m1----------end");
	}

	public static void m2() {
		System.out.println("m2----------start");
		// 手动抛出运行时异常，需要携带信息“程序因为异常而终止”
		throw new RuntimeException("程序因为异常而终止");
		//System.out.println("m2----------end");
	}
}
程序运行结果为：
m1----------start
m2----------start
Exception in thread "main" java.lang.RuntimeException: 程序因为异常而终止
	at prac.t2.m2(t2.java:31)
	at prac.t2.m1(t2.java:21)
	at prac.t2.main(t2.java:16)

异常的处理：

异常的处理分为消极的处理（自己处理不了，就往调用它的地方上抛throws，异常没有解决，只是抛出）和积极处理（异常捕获，捕捉异常通过try-catch语句或者try-catch-finally语句实现）

消极的处理：
语法：public void m1() throws 异常类名1,异常类名2{}
特点：相当于推卸责任，最终问题依然无法得到解决。
允许编译通过。
当上抛的异常为非运行（已检查）时异常时，调用此方法的调用者必须处理。
当上抛的异常为运行（未检查）时异常时，可以处理可以不处理。

积极的处理：(异常捕获)
将异常直接捕获，并且做出处理
语法：

try{
	  //异常代码
	}catch(异常类名 引用名){  

		//当异常产生执行的代码
	}

try 后的catch代码块只能匹配成功一个
catch后声明的异常为父类时，它能够捕捉的异常为它本身+所有子类异常（多态的体现）
注意：catch代码块捕获异常时，子类异常必须定义在父类异常前面，否则会编译出错

finally代码块：一定会执行此代码块中的代码，常用来关闭资源，

	try{
	
	}catch(){
	
	}finally{
		//无论是否产生异常，一定会去执行的代码
	}
注意：finally代码块中不要定义return语句

下面一个程序详细介绍异常的处理：

package work;

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Scanner;

/**
 * @author 超伟
 * @date 2019年5月13日  
 * @version 1.0.0  
 */
public class t4 {
	public static void main(String[] args) {
		System.out.println("main1");
		int n;
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		ma(n);
		System.out.println("main2");
	}
	public static void ma(int n){
		try {
			System.out.println("m1");
			mb(n);
			System.out.println("m2");
		} catch (EOFException e) {
			//e.printStackTrace();
			System.out.println("EOFException    ");
		} catch (IOException e) {
			System.out.println("IOException e111");
		}catch (SQLException e) {
			System.out.println("SQLException");
		}catch (Exception e) {
			System.out.println("Exception");
		}finally{
			System.out.println("in finally");
		}
	}
	
	public static void mb(int n) throws Exception {
		System.out.println("mb1");
		if (n==1) {
			throw new EOFException();
		}
		if (n==2) {
			throw new FileNotFoundException();
		}
		if (n==3) {
			throw new SQLException();
		}
		if (n==4) {
			throw new NullPointerException();
		}
		System.out.println("mb2");
	}	
}
程序运行结果为：
main1
1
m1
mb1
EOFException    
in finally
main2

throw和throws的区别

这只是有点相似的关键字，并没有任何关联，要学会区分。

throw是用在方法体里面的，一般是放在判断情况的后面，手动抛出异常。

throws只能用在需要捕获异常的方法的方法名的括号后面使用。

自定义异常：

为什么要自定义异常？
当Java内置的异常都不能明确的说明异常情况的时候，需要创建自己的异常。

自定义一个异常类，需要继承于Exception或者其子类。
若想要这个异常类为运行时异常，需继承于RuntimeException或者其子类。
一般定义为运行时异常

自定义的异常类需要至少无参有参两个构造方法
例如：

package work;
import java.io.EOFException;
import java.util.Scanner;
public class t5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		try {
			m(n);
			
		} catch (MyException1 e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			System.out.println(e.getMessage());
		}catch (MyException2 e) {
			// TODO: handle exception
			e.printStackTrace();
			System.out.println(e.getMessage());
		}	
	}
	
	public static void m(int n) throws MyException1{
		if (n==1) {
			throw new MyException1("我自己定义的非运行时异常");
		}
		else {
			throw new MyException2("这是我定义的一个运行时异常！！！");
		}
	}
}
//自定义异常
//已检查异常，非运行时异常
class MyException1 extends EOFException{
	public MyException1() {
		super();
	}

	public MyException1(String s) {
		super(s);
	}
}
//未检查异常
//运行时异常
class MyException2 extends RuntimeException{
	public MyException2() {
	}
	public MyException2(String message) {
		super(message);
	}
}

方法覆盖，在继承中的异常的提现：
方法覆盖需要满足的3个条件
1.返回值类型方法名参数列表完全一致
2.访问修饰符相同或更宽
3.子类中方法不能抛出比父类更多、更宽的异常

package work;

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;

/**
 * @author 超伟
 * @date 2019年5月13日  
 * @version 1.0.0  
 */
public class t8 {
	/**
	 * @param args 
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}
}
class Super{
	public void ma() throws IOException{
		
	}
}
interface IA{
	void mb();
}
class MySub extends Super implements IA{
	//父类抛出一个非运行时异常，子类可以抛出一个或者多个父类抛出的异常的子类异常
	/*public void ma() throws IOException,FileNotFoundException,EOFException{
	}*/
	//父类抛出一个非运行时异常，子类可以抛出一个或者多个运行时异常
	public void ma() throws SecurityException,ClassCastException{
	}
	public void mb() {
	}
}

Java异常处理的原则和技巧
1，避免过大的try块。不要把不会出现异常的代码放到try块里面，尽量保持一个try块对应一个或多个异常。
2，细化异常的类型。不要不管什么类型的异常都写成Excetpion。
3，catch块尽量保持一个块捕获一类异常。不要忽略捕获的异常，捕获到后要么处理，要么转译，要么重新抛出新类型的异常。
4，不要把自己能处理的异常抛给别人。
5，不要用try…catch参与控制程序流程。异常控制的根本目的是处理程序的非正常情况。

所以像那些可以预料的错误，尽量在执行之前就做好相应的处理，

比如除数为零或空指针问题，要做事前判断再运行程序。

持续更新中…

java异常分类，异常处理，自定义异常

异常的产生：

异常的处理：

自定义异常：

相关推荐