java基础_06_异常

异常

异常就是在程序执行过程中出现错误时，阻止其继续执行。出现了异常从某种意义上来说就是出现了问题，它可能会导致程序失败。发生异常后，异常以后的代码将不再执行。

 

异常的分类：

Throwable 类是Java语言中所有错误或异常的超类，它有两个子类：Error 、 Exception.

1，Error  

      是系统不可恢复的错误，JVM 发生的错误。这种问题大到我们无法处理。

       如：OutOfMemoryError 堆内存溢出

              StackOverflowError 栈内存溢出

              VirtualMachineError 虚拟机崩溃或所操作的资源用尽

2，Exception 

      程序可以检查处理的异常。又可分为下面两种。

      一：CheckedException ：需要用try...catch...捕获

      二：UncheckedException ：不需要捕获，又叫做RuntimeException.

      注意：  RuntimeException异常。

      1，在函数里内容上抛出 throw  RuntimeException异常，函数上可以不用声明，编译一样通过。

      2，如果在函数上声明了该异常，调用者可以不用进行处理。编译一样通过。之所以不用在函数声明，是因    为不需要让调用者处理。（如果声明调用者必须处理，处理后程序继续运行）

      3，当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码     进行修正。

      4，自定义异常时：如果该异常的发生，无法在继续进行运算，就让自定义异常继承 RuntimeException  

      常见的RuntimeException有：

       IllegalArgumentException ：异常表明向方法传递了一个不合法或不正确的参数。

       IllegalStateException ： 在非法或不适当的时间调用方法时产生的信号。

       NullPointerException ： 当应用程序试图在需要对象的地方使用 null 时，抛出该异常。

       IndexOutOfBoundsException ：数组角标越界。

 

处理异常的方式？

1，使用try  catch  finally  捕获。把可能出现异常的代码入 try{  代码  } 中。

      注意：finally代码块：一定会执行，一般用于关闭资源。

      有一个特殊情况下finally不会执行，它前面有 System.exit(0); 退出语句时 不会执行。

2，直接再抛出异常。这种方式就是让其调用者自己去处理。

      注意：如果程序中出现了异常，要么在内部try catch 处理，要么在函数上声明让调用者处理。

　　　　
   例：
　　　　class Demo
　　　　{
　　　　	int div(int a,int b) throws Exception	//抛出异常，让调用者去处理可能出现的问题。
　　　　    					//调用者必须处理，否者编译失败
　　　　						//也可以抛出多异常 throws ActivationException, AWTException,等等									// 用逗号隔开。抛出几个异常，调用者就得处理几个
　　　　	{
　　　　		return a/b;  //分母可能传0进来
　　　　	}
　　　　}
　　　　class  ExceptionDemo
　　　　{
　　　　	public static void main(String[] args) 
　　　　	{
　　　　		Demo d=new Demo();
　　　　		try
　　　　		{
　　　　			int x=d.div(4,1);	//如果出错这里面后面的语句不在执行
　　　　			System.out.println(x); 
　　　　		}
　　　　		catch (Exception e)	//异常处理
　　　　		{
　　　　			System.out.println("出问题了。。。");
　　　　		}
　　　　		/*
　　　　		//有几个处理几个
　　　　		catch (ActivationException e)
　　　　		{
　　　　		
　　　　		}
　　　　		catch (AWTException e)
　　　　		{
　　　　		
　　　　		}
　　　　		*/
　　　　		finally`//一定会执行的代码，可以不写这个
　　　　		{
　　　　			System.out.println("finally");
　　　　		}
　　　　
　　　　		System.out.println("over");
　　　　	}
　　　　}

 

throw与throws区别？

1，throws  抛出异常(用在函数上)

     throw   抛出自定义的那种异常（用在函数内）

2，throws  后面跟异常类，可以跟多个，用逗号隔开

      throw   后跟的是异常对象

 

自定义异常

程序中一般有自己对异常的要求，所以在程序中大多是自定义异常来处理异常的。

 

自定义异常步骤：

1，自已定义异常类，并继承 Exception ，如果无法在继续进行运算，就继承 RuntimeException 。

      例：

             class FuShuException  extends Exception //自定义异常

             {  }

2，在发生异常的地方抛出自己定义的异常。

      格式 ： throw 自定义异常类

       例：

            在方法div 上抛出自己定义的异常类。

            int div(int a,int b) throws FuShuException //抛出自定义的异常

            {  }

        例：

　　　　用上面的，假定除数不能是负数，自定义抛出异常。

class FuShuException  extends Exception	//自定义异常
{
	private int a;
	FuShuException(String msg)	
	{
		super(msg);	//父类已做好了。。继承就可以了
		
	//	父类做了这些 Exception 是继承超类 Throwable 的
	//	class Throwable //处理异常类超类，直接子类 Exception,Error
	//	{
	//		private String message;
	//		Throwable(String message)
	//		{
	//			this.message=message;
	//		}
	//		public String getMessage()
	//		{
	//			return message;
	//		}
	//	}
	}
	//加入自己的数据例子
	FuShuException(String msg,int a)	
	{
		super(msg);
		this.a=a;
	}

}
class Demo
{

	int div(int a,int b) throws FuShuException	//抛出自定义的异常
	{
		if(b<0)
			throw new FuShuException("分母出现负数了。。。");  //抛出一个自定义异常对象				                                   		                     return a/b;  //分母可能传0进来

		//if(b==0)
		//	throw new ArithmeticException("除0了。。");  //这样写上面方法那里可以不用声明(因为是RuntimeException子类)，如果发生这个异常,程序停止。
	}
}
class  ExceptionDemo
{
	public static void main(String[] args) 
	{
		Demo d=new Demo();
		try
		{
			int x=d.div(4,1);	//如果出错这里面后面的语句不在执行
			System.out.println(x); 
		}
		catch (FuShuException e)	//异常处理
		{
			System.out.println("除负数了。。。");
		}
		System.out.println("over");
	}
}

心得：　　

　　有了异常的处理机制，很好的解决了程序中可能出现的问题，避免程序错误的执行。有了问题就反映给程序员。异常可抛可处理，如果抛出去，则其调用着必须处理或可接着抛。