学习Java异常exception

---

异常（Exception）就是Java程序在运行过程中出现的错误，程序编译通过并不代表着在运行时不会出错

一 、疑问：try…catch让程序极度不美观？

在不了解异常的时候，我曾有这样一个疑问：
为什么编译器非要让我添上try…catch呢？
就像下面这个情况：

明明我的代码也没有写错，但只有加上后才能编译通过，
就是这一句“貌似没什么用的话”，使代码变得极度不美观：

这段代码到底有什么用？？为什么要有异常这个鬼东西呢？？

---

二 、疑问：为什么要有异常这个鬼东西呢？

最经典的就是除数为0这个异常的例子：

这里，程序在第七行终止了，
并在控制台报出异常，后面的程序没有执行。

在程序中，异常 可能产生于程序员没有预料到的各种情况，
或是超出了程序员可控范围的环境因素，
比如：没有料到除数为零，或者试图打开一个根本不存在的数据。

我们暂且先不用异常的知识，
这里，我们先这样做：

我们通过If语句和输出一句话，给我们提示，
并且给程序一条可执行的通路。

其实，这也是异常处理的思想：
当程序执行遇到问题时，我们给程序一条通路，
输出错误信息，让程序可以执行到底。

---

三 、疑问：为什么非要用Java提供的异常类？

既然，上面例子中，我们已经让程序跑起来了，
为什么还非要用Java提供的异常呢？

异常是一个在程序执行期间发生的事件，它中断了正在执行程序的正常指令流，
如果我们要自己编写逻辑代码调试，首先就会很 麻烦，
更重要的是，如果不用异常，
会把本来的业务代码和异常处理 搅合 在一起，非常乱；

Java是一门 面向对象 的语言，异常在Java语言中也是作为 类的实例的形式 出现，
当某一方法中发生错误时，这个方法会创建一个异常对象，并且把它传递给正在运行的系统，
而且，处理异常代码和程序主代码分离，即：在编写代码主流程的同时在其他地方处理异常。

---

四 、Java的前辈们总结了哪些异常类？

1.异常的分类：

java把产生的所有异常分成两大类，
它们都是 java.lang.Throwable 的子类，
我们程序中出现的任何异常都能够在分类中找到。

java.lang.Error 系统级的异常(错误)： 如果程序出现了Error，
那么将无法恢复，只能重新启动程序，最典型的Error的异常是：OutOfMemoryError；

java.lang.Exception 程序级的异常： 可以通过代码处理，
它是一切程序级异常的父类，它下面也有两个分支：

一般性异常 jvm不能捕获的异常： 必须通过程序显式处理，如果不处理程序编译不通过，
例如，本文第一个Class反射的例子；

java.lang.RuntimeException jvm能自动捕获的异常： 此种异常可以不用显示的处理，
例如：除0异常，java没有要求我们一定要处理，当然也可以自己显式处理。

2.常见的运行时异常：

异常类	说明
ArithmeticException	算数异常，比如：除数为0
ClassCastException	对象不能转换异常，比如：向下转型
ClassNotFoundException	类找不到异常
NumberFormatException	字符串不能转换为数字异常
StringIndexOutOfBoundsException	字符串索引超出范围异常
NullPointerException	空指针异常，解释：指针就是对象的引用，空指针就是引用的内容为空，比如:String s=null; 如果你还要去操作它，比如：s.equals(“abc”); 那么就会产生空指针异常
NoSuchFieldException	反射找不到属性
NoSuchMethodException	反射找不到方法
ArrayStoreException	数组中包含不兼容的值
NegativeArraySizeException	如果试图创建大小为负的数组，则抛出该异常
IllegalArgumentException	非法参数异常
IllegalAccessException	private权限异常

3.常见的一般性异常：

异常类	说明
SQLException	操作数据库异常
IOException	文件读取时异常
EOFException	END OF FILE 文件已结束
FileNotFoundException	文件未找到异常

---

五、学习异常：

异常的处理方式有两种：
一种是向上抛出异常，由方法的调用者来处理.(throws)，
另一种时捕获该异常，直接进行处理(try…catch)。

1.throws关键字：

throws 的作用是 向上层抛出异常，用在 方法声明 的位置上：

public class ExceptionTest {

    public static void main(String[] args) throws FileNotFoundException{
        
        //创建文件输入流，读取文件
        FileInputStream fis = new FileInputStream("d:/monkey1024.txt");

    }
}

这里因为输入了字符串，但这个字符串地址可能是错的，
系统找不到，于是这里就会产生异常，需要给出万一系统找不到，程序的出路。

那 jvm 是怎么知道这个地方容易出现问题呢？
来看下FileInputStream的源码：

public FileInputStream(String name) throws FileNotFoundException {

    this(name != null ? new File(name) : null);
    
}

可见，源码里面在构造方法上抛出了FileNotFoundException，所以jvm知道。

2.try…catch关键字：

try…catch…的作用是 处理异常 ，当try代码块中的语句发生异常时，
程序会跳转到catch代码块中执行，然后，再执行catch代码块之后的代码，
而不会执行try代码块中异常语句之后的代码。

public class ExceptionTest2
 {
	public static void main(String[] args) {
	
         try {
     	    int a = Integer.parseInt(args[0]);
    		int b = Integer.parseInt(args[1]);
    		System.out.println(a/b);
		}catch (ArrayIndexOutOfBoundsException e) {
		    System.out.println("数组下标越界了!");
		}catch(ArithmeticException e){
			System.out.println("除数不能为0！");
		}catch(Exception e){
			System.out.println("其它异常");
		}
	}
}

上面的实例使用了多个catch语句来捕捉异常，
但要注意的是，catch(Exception e)必须卸载最后面，
否则，其他捕获异常的代码永远得不到执行，就没有什么意义了。

3.try…catch…finally关键字：

无论程序是否发生异常，都会执行finally代码块中的语句，一般用于关闭资源，
除非在执行 finally 语句体之前 JVM 退出，比如 System.exit(0)

public class FinallyTest {
public static void main(String[] args){

        int i = f1();
        System.out.println(i); 

    }

    public static int f1(){

        int i = 10;
        try{
            return i;
        }finally{
            System.out.println("finally中的语句");
        }

    }

}

4.throw关键字：

throw 则是抛出一个具体的异常类的对象，
一般用在 方法体 中，并在方法处throws声明throw的异常，
在调用的时候，比如main方法中，用try…catch捕获该异常，
用的不是很多，一般用在自定义异常。

5.自定义异常：

当你觉得java里的异常无法满足需求时，可以自定义异常：
其步骤是：
①创建自定义异常类：

public class AgeException extends Exception {//创建自定义异常，继承Exception类
	public AgeException(String message) {//构造方法
		super(message);//父类构造方法，有参的构造方法，必须显式地写出来
		
	}
}

/*
		*父类中有三个常用的函数：
		*e.getMessage():输出：年龄有误必须是0到120
		*e.toString():输出：NameException: 姓名长度有误!
		*e.printStackTrace():输出：NameException: 姓名长度有误!
		*							at PersonB.setName(MyExceptionTest.java:28)
		*							at MyExceptionTest.main(MyExceptionTest.java:7)
		*/

②在方法体中throw抛出该异常：

throw new NameException("姓名长度有误!");

③在方法声明出throws要抛出的异常：

public void setName(String name) throws NameException {...}

④在方法调用者中try…catch捕获异常：

try {
			pb.setName("helloworldxxxx");
		} catch (NameException e) {
			System.out.println(e.getMessage());
		}

下面是完整的实例：

public class MyExceptionTest {
	public static void main(String[] args) {
	
		PersonB pb = new PersonB();
		
		try {
			pb.setName("helloworldxxxx");
		} catch (NameException e) {
			System.out.println(e.getMessage());
		}
		
		try {
			pb.setAge(10000);
		} catch (AgeException e) {
			System.out.println(e.getMessage());
		}
		
	
	}
}

class PersonB{
	private int age;
	private String name;
	
	public void setName(String name) throws NameException {
		if(name.length()<5 || name.length() >=10)
			throw new NameException("姓名长度有误!");
		this.name = name;
	}
	
	public String getName() {
		return name;
	}
	
	public void setAge(int age)throws AgeException {
		if(age < 0 || age >120)
			throw new AgeException("年龄有误必须是0到120");
		this.age = age;	
	}
	
	public int getAge() {
		return age;
	}
}

public class AgeException extends Exception {
	public AgeException(String message) {
		super(message);
	}
}

public class NameException extends Exception {
	public NameException(String message) {
		super(message);
	}
}