<pre name="code" class="java">/*
 异常：就是程序在运行时出现的不正常情况、
 异常的由来：问题也就是现实生活中的一个具体事物，也可以通过java的类的形式进行描述。并封装成对象。
 			其实就是java对不正常情况进行描述后的对象体现。

对于问题的划分：
比较严重的，java通过Error类进行描述（对于Error一般不编写针对性的代码对其进行处理）
 非严重的，java通过Exception得进行描述（对于Exception可以使用针对性的处理方式进行处理）
 
 try 
 {
 	
 }
 
异常处理：
java提供了特有的语句进行处理

try 
{
 	需要被检测的代码；
 }
 catch（异常类   变量）
 {
 	处理异常的方法
 }
 
 对捕获的异常进行常见的方法操作
e.getMessage()异常信息
e.toString()异常名称 ：异常信息
e.printStackTrace()打印异常名称，异常信息，异常位置（jvm默认的异常处理机制）
 
 
 对多异常的处理：
 1、声明异常时，建议声明更为具体的异常，这样处理更具体。
 2、对方声明几个异常，就对应有几个catch块
 	如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。
 
 建立在进行catch处理时，catch中一定要定义具体处理方式
 不要简单定义一句e.printStackTrace(),一般是将错误写入日志文件，一边查找修复BUG
 
 自定义异常：
 （java中没有的项目特有的异常）
 例：
 需求：在项目中，除数是-数，也视为是错误的:
 1、当函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
 在内部try catch 或 函数声明上让调用者处理，一般在函数内处理异常，函数上需要声明；
 2、 处理后会发现打印结果中只有异常名称，却没有异常处理信息，此时就需要定义异常处理信息。
 	异常信息定义：
 	1，父类中Exception已经把异常信息操作完成了，所以子类只要在构造时，将异常信息 传递给父类（通过super）
 	就可以直接通过getMessage方法获取自定义的异常信息。
 	
注意：
自定义必须继承Exception或其子类。
原因：异常体系中异常类和异常对象都被抛出，具备可抛性，可抛性是Throwable独有特点，
只有异常体系中的类和对象才可以被throws和throw操作。

throws 和throw的区别：
throws定义在函数上，抛出的是异常类，可以跟多个。
throw定义在函数内，抛出的是异常对象。


Exception中有一个特殊的子类异常RuntimeException
RuntimeException：（当异常发生时，期望程序停止）
1，如果在函数内容上抛出该异常，函数上可以不用声明；如果在函数上声明了该异常，
调用者可以不用进行异常处理


异常分两种;
1.编译时被检测的异常。要声明和处理方法。
2.编译时不被检测的异常，（运行时异常，RuntimeException类）
 
 */



/*①  class Exception extends Throwable//该类包含了复写接收方法
{
	Exception(String message)
	{
		super(message);
	}
}*/


class FuException extends RuntimeException//RuntimeException异常处理
{
	FuException(String str)
	{
		super(str);
	}
}
class Du
{
	int di(int a,int b)//此处不用在声明异常
	{
	if(b<0)
		throw new ArithmeticException("chilin");
	return a/b;
	}
}

class FuSException extends Exception//目的：生成对象
{
	/*private String str;
	public FuSException(String str)//复写
	{
		this.str=str;
	}
	public String getMessage()
	{
		return str;
	}*/
	private int s;
	FuSException(String str,int s)
	{
		
		super(str);//Exception 已经包含了上面的操作如①
		this.s=s;
	}
	int gets()
	{
		return s;
	}
}
class DuiX
{
	int div(int a,int b)throws FuSException
	{
		if(b<0)
			throw new FuSException("BY fushu ",b);//throw抛出一个异常对象，构造异常内容
		return a/b;
	}
}

class YiChang
{
	int yiC(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//多异常处理//在功能上通过throws声明该功能可能有问题。
	{
		int arr[]=new int[a];
		System.out.println(arr[4]);
		
		return a/b;
	}
}

class MI 
{
	public static void main(String[] args)//throws Exception//抛给虚拟机
	{
		DuiX d=new DuiX();
		try{
			d.div(4, -9);//抛出了异常，必须处理
		}
		catch(FuSException e)
		{
			System.out.println(e.toString());
			System.out.println("fushu");
			System.out.println(e.gets());
		}
		
		Du t=new Du();//此时不要处理方法
		t.di(4, -9);
		
		//YiChang y=new YiChang();
		//int d=y.yiC(3,0);异常
		//System.out.println(d);
		//int d;
		
		
		/*try//处理异常
		{
			d=y.yiC(4, 0);
			System.out.println(d);
		}
		catch(ArithmeticException e)
		{
			System.out.println("error");
			System.out.println(e.getMessage());//打印异常信息
			System.out.println(e.toString());//打印异常名称 ：异常信息
			e.printStackTrace();//打印异常名称，异常信息，异常位置（jvm默认的异常处理机制）
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			System.out.println("over");
		}
		catch(Exception e)
		{
			e.printStackTrace();
		}*/
		System.out.println("over");
	}
}
finally：一定执行的代码块，一般用于关闭某些资源