异常

异常：java在运行时期出现的不正常情况。

1.概述：按照面向对象的思想对问题进行描述和封装，将问题变成对象，里面包含着问题的名称，信息以及位置等。
2.常见的问题：一种可处理的；向上抽取到一个父类中：Exception(异常)
一种是通常不处理的，向上抽取到一个父类中Error.通常都是由jvm或者系统抛出的严重问题，解决方法是修改代码。

3.无论是错误还是异常，都有名称、信息、位置等共性内容，向上抽取到父类中Throwable(可抛).
4.异常的体系：Throwable的子类有 Exception 和 Error.
5.问题的发生是可以抛出的，所以他们的父类是Throwavle,而且这个体系和其它体系都有不同，是因为这个体系中的类以及其对象都具备着可抛性。

6.可抛性：可以被throw或者throws关键字所操作。

		class Demo
		{
			void show(int index)
			{
				int[] arr = new int[3];
				if(index>=arr.length)
					throw new ArrayIndexOutOfBoundsException("数组角标越界啦！！越界角标是："+index);

				System.out.println(arr[index]);

				System.out.println("haha");
			}
		}

		class  ExceptionDemo
		{
			public static void main(String[] args) 
			{
				Demo d = new Demo();
				d.show(3);
				System.out.println("over");
			}
		}

7.异常分两种：一种是编译时需要被检测的异常，Exception及其子类，可以进行针对性的处理；

一种是编译时不被检测的异常，Exception中一个特殊子类体系RuntimeException，通常不编写处理方式，直接让程序停止，让调用者进行代码的修正。
意味着：我们在自定义异常时，可以继承Exception，也可以继承RuntimeException.

8.针对性处理：可以通过java提供的指定的处理代码完成。
try
{
需要被检测的代码；
}
catch (异常类 变量名)
{
异常的处理代码；
}
finally
{
一定执行的代码；
}

9.异常处理的基本原则：1.在catch异常时，对方功能声明的是什么异常，catch里就处理什么异常，这样处理才具有针对性。
2.如果对方函数声明多个异常，则必须由对个catch分别对这些异常进行处理。
3.如果出现多catch，父类catch则必须放在最下面。


10.异常抛出的基本原则：1.功能中用throw关键字抛出了异常，如果没有被catch处理，就必须用throws关键字在函数上进行声明。


注意：RuntimeException及其子类除外，也就说，功能中throw抛出的是RuntimeException和其子类对象，函数上可以不用throws进行声明。
  函数上用throws进行声明的原因：是为了让调用者在调用该功能时，进行定义预先的处理方式。
11.抛出和try处理：功能内部可以进行处理吗？可以就catch；不可以就必须throws。

12.自定义异常：当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作，一般在函数上用throws关键字标示可能出现异常，好处是可以让调用者预先进行问题的处理。

getMessage:信息；toString:名称+信息；printStackTrace:名称+信息+位置；

	class FuShuException extends Exception
	{
		FuShuException()
		{
			super();
		}
		FuShuException(String message)
		{
			super(message);
		}
	}

	class Demo
	{
		int div(int a,int b)throws FuShuException//在函数上用throws关键字标示有可能有问题。
											//这样的好处在于可以让调用者预先进行问题的处理。
		{
			if(b==0)
				throw new ArithmeticException("哎呀！除数为零了。完了！");//抛出的是java已有的异常的对象。 
			if(b<0)
				throw new FuShuException("除数不可以是负数：错误的负数值时："+b);//抛出了自定义异常对象。
			return a/b;
		}
	}
	class ExceptionDemo2 
	{
		public static void main(String[] args)throws  FuShuException//主函数调用了有异常的方法，
																//处理方式是声明继续抛出。抛给了jvm
		{
			Demo d = new Demo();
			int num = d.div(4,-1);
			System.out.println("num="+num);
			System.out.println("Hello World!");
		}
	}

13.throw和throws的区别：
throw用在函数内，用于抛出异常对象，后面跟的都是异常的对象。
throws用在函数上，用于声明异常，后面跟的都是异常类，而且可以跟多个，用逗号隔开；

14.小细节：throw在函数中的出现，可以用于结束函数的运行，相当于return。
函数内发生异常函数上不声明，是为了让调用者对代码进行修正，而这种异常都是RuntimeException及其子类。

注意：没catch，没处理。

15.异常讲解常见实例

除数为零，和除数不能为负数。

		class FuShuException extends Exception
		{
			FuShuException()
			{
				super();
			}
			FuShuException(String message)
			{
				super(message);
			}
		}

		class Test
		{
			int div(int a,int b)throws FuShuException//在函数上用throws关键字标示有可能有问题;这样的好处在于可以让调用者预先进行问题的处理。
			{
				if(b==0)
					throw new ArithmeticException("哎呀！除数为零了。完了！");//抛出的是java已有的异常的对象。 
				if(b<0)
					throw new FuShuException("除数不可以是负数：错误的负数值时："+b);//抛出了自定义异常对象。
				return a/b;
			}
		}
		class ExceptionT 
		{
			public static void main(String[] args)//throws  FuShuException//主函数调用了有异常的方法，处理方式是声明继续抛出。抛给了jvm
			{
				Demo d = new Demo();
				try
				{
					int num = d.div(4,-1);
					System.out.println("num="+num);
				}
				catch (FuShuException e)
				{

					System.out.println("message:"+e.getMessage());//信息
					System.out.println("tostring:"+e.toString());//名称+信息
					e.printStackTrace();//名称+信息+位置。其实jvm的默认处理方式，就是调用了这个方法。
					System.out.println("异常被我抓住啦！！");
				}
				System.out.println("Hello World!");
			}
		}

1 6.finally 语句：这个代码块中定义的是一定会执行的代码。
1.不能被catch块中的return语句结束，可是能被System.exit(0)结束。
2.主要用于关闭资源，只要使用了资源，就一定要将其关闭。
3.应用：数据库的连接，连接——操作——关闭。可能在操作过程中出现异常，没关闭数据库，就需要把关闭数据库放在finally语句里面。


17.组合方式：
try{}catch (){}、try{}catch(){}、try{}finally{}(这种用于关闭资源)

18.异常在覆盖时的细节
1.子类在覆盖父类方法时，如果父类方法抛出了异常，子类覆盖的方法只能抛出父类方法异常或其子类。
2.父类方法如果抛出多个异常，子类在覆盖父类方法时，只能抛出父类异常的子集。
3.如果父类中的方法没有抛出异常，子类覆盖父类时，绝对不能声明异常。只能进行 try{} catch 处理；如果处理不了，那就应该让程序
停掉，让调用者知道。即在catch中抛出RuntimeException异常或其子类对象，这时不用抛，RuntimeException不用在函数上声明。