java学习笔记之异常

异常

异常是在运行时期发生的不正常情况。
异常就是java通过面向对象的思想将问题封装成了对象

我们在编程序是遇见的问题有两种：
一般不可处理的，叫做错误（Error）。
错误的特点：是由jvm抛出的严重性的问题。
这种问题发生一般不针对性处理。直接修改程序
可以处理的，叫做异常（Exception）。

class ExceptionDemo 
{
	public static void main(String[] args) 
	{
		int[] arr = new int[1024*1024*800];	
	}
	public static void sleep2(int time)
	{
		if(time<0)
		{
			//这里需要处理方法
		}
		if(time>100000)
		{
			//这里需要处理方法
		}
		System.out.println("睡眠时长为。。。"+time);
	}
}

异常体系

描述不正常的情况的类，就称为异常类。

public static void sleep(int time)
	{
		if(time<0)
		{
//			抛出 new FuTime();	
		}
		if(time>100000)
		{
//			抛出 new BigTime();
		}
		System.out.println("我睡。。。"+time);
	}


class FuTime
{
}
class BigTime
{
}

以前正常流程代码和问题处理代码相结合，
现在将正常流程代码和问题处理代码分离。提高阅读性。

用异常类对其进行描述。
不同的问题用不同的类进行具体的描述。 比如角标越界。空指针等等。

问题很多，意味着描述的类也很多，
将其共性进行向上抽取，形成了异常体系。

该体系的特点：
子类的后缀名都是用其父类名作为后缀，阅读性很强。

自定义异常

如果定义一个数组：
对于角标是整数不存在，可以用角标越界表示，
对于负数为角标的情况，准备用负数角标异常来表示。

负数角标这种异常在java中并没有定义过。
那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述。并封装成对象。
这种自定义的问题描述成为自定义异常。

注意：如果让一个类称为异常类，必须要继承异常体系，因为只有称为异常体系的子类才有资格具备可抛性。
才可以被两个关键字所操作，throws throw

自定义异常时，要么继承Exception。要么继承RuntimeException。

异常的分类：

1. 编译时被检测异常:只要是Exception和其子类都是，除了特殊子类RuntimeException体系。
   这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
   这样的问题都可以针对性的处理。
2. 编译时不检测异常(运行时异常):就是Exception中的RuntimeException和其子类。
   这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的而或者引发了内部状态的改变导致的。
   那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止,让调用者对代码进行修正。

所以，如果继承了Exception，就要声明抛出，否则编译失败。

throws 和throw的区别

1. throws使用在函数上。
   throw使用在函数内。
2. throws抛出的是异常类，可以抛出多个，用逗号隔开。
   throw抛出的是异常对象。

异常捕捉

经常会看到一个“必须对其进行捕捉或者声明以便抛出”
声明:throws
抛出:throw
捕捉：
这是可以对异常进行针对性处理的方式。

具体格式为：

try		//(意为尝试)
{
		//内部写需要被检测异常的代码。
}
catch (异常类 变量)		//(意为捕捉)该变量用于接收发生的异常对象
{
		//内部写处理异常的代码。
}

	/*try 和 catch 单独组合在一起是可以的，用于异常的处理*/

finally		(意为最终化)
{
		//内部写一定会被执行的代码。
}

那么什么时候try，什么时候抛呢？

如果在建立功能时发生了问题，
如果这个问题能处理，就try——catch；
如果处理不了，那么就抛。

只要将需要检测的语句放在try中即可，不要什么语句都放在try中
程序的异常在被解决后会继续执行

输出异常信息的方法：

e.getMessage()
		打印异常信息
	"String:"+e//(默认变为e.toString())
		打印异常名称，信息
	e.printStackTrace()
		/*打印异常名称，信息，和位置
		（jvm默认的异常处理就是调用异常对象的这个方法）*/

多catch情况：

如果我们在定义功能时，抛出的异常不止一个，
例如：

public int method(int[] arr,int index)throws /*NullPointerException,*/FuShuIndexException
	{	
		if(arr==null)
			throw new NullPointerException("没有任何数组实体");
		if(index<0)
			throw new FuShuIndexException();
		return arr[index];
	}

那么处理多个：

catch(NullPointerException e)
		{
			System.out.println(e.toString());
		}
	catch (FuShuIndexException e)
		{
			System.out.println("string:"+e.toString());
		}

要注意一个细节：
多类catch情况中存在父类catch情况时，一定要把父类catch放在最下面！否则编译失败。

什么时候用try？

只要使用到了声明异常的方法，就要用try。
只要代码中有抛出异常的动作，如果能处理，也可以try。
见到了异常就需要做处理，要么抛要么try——catch。

异常——异常处理原则：

1. 函数内容如果抛出需要检测的异常，那么函数上必须要声明。
   否则必须在函数内用trycatch捕捉，不然编译就会失败。

2. 如果调用到了声明异常的函数，要么try——catch要么throws，否则编译失败。因为程序有很强的安全隐患！

3. 什么时候catch，什么时候throws 呢？
   如果功能内容可以解决，用catch。
   如果解决不了，用throws告诉调用者，由调用者解决 。

4. 一个功能如果抛出了多个异常，
   那么调用时，必须有对应多个catch进行针对性的处理。
   内部有几个需要检测的异常，就抛几个异常，
   抛出几个，就catch几个。

finally代码块

首先，我们让数组角标为正数：

    class Demo
{
	public int show(int index)throws ArrayIndexOutOfBoundsException
	{
		if(index<0)
			throw new ArrayIndexOutOfBoundsException("数组角标越界！！");
		int[] arr = new int[3];
		return arr[index];
	}
}

class ExceptionDemo5 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			int num = d.show(1);
			System.out.println("num="+num);
		}
		catch (ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			System.out.println("finally");
		}
		System.out.println("over");
	}
}

运行结果：
num=0
finally
over

如果我们让数组角标为负数：

    class Demo
{
	public int show(int index)throws ArrayIndexOutOfBoundsException
	{
		if(index<0)
			throw new ArrayIndexOutOfBoundsException("数组角标越界！！");
		int[] arr = new int[3];
		return arr[index];
	}
}

class ExceptionDemo5 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{		
			int num = d.show(-1);
			System.out.println("num="+num);
		}
		catch (ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
		}
		finally
		{
			System.out.println("finally");
		}
		System.out.println("over");
	}
}

运行结果：
java.lang.ArrayIndexOutOfBoundsException: 数组角标越界！！
finally
over

如果我们让 catch 输出后返回，那么：

    class Demo
{
	public int show(int index)throws ArrayIndexOutOfBoundsException
	{
		if(index<0)
			throw new ArrayIndexOutOfBoundsException("数组角标越界！！");
		int[] arr = new int[3];
		return arr[index];
	}
}

class ExceptionDemo5 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{		
			int num = d.show(-1);
			System.out.println("num="+num);
		}
		catch (ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			return;
		}
		finally
		{
			System.out.println("finally");
		}
		System.out.println("over");
	}
}

运行结果：
java.lang.ArrayIndexOutOfBoundsException: 数组角标越界！！
finally

over没有了，但finally仍执行。
因为over是函数内部的代码，程序在catch输出后已经返回了，而finally是一定会执行的代码。

finally 有一种情况执行不到，这种情况是: System.exit(0);
这个语句用于退出jvm。

那么，finally代码块有什么用？
作用很大，而且很重要！——finally通常用于关闭(释放)资源。

try-catch-finally 代码块组合特点：

1. try catch finally

2. try-catch(多个)当没有必要资源需要释放时，可以不用定义finally。

3. try-finally 异常无法直接catch处理，但是资源需要用finally关闭。
   必须要声明，因为没有处理。

    void show()throws Exception
{
	try
	{
		//开启资源。
		throw new Exception();
	}
	finally
	{
		//关闭资源。
	}
}