黑马程序员_java异常机制

------- android培训、java培训、期待与您交流! ----------

一、异常的概念

1、异常:程序在运行时出现不正常情况。
  异常的由来:问 题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述,并封装成对象,其实就是java对不正常情况进行描述后的对象体现。

对于问题的划分有两种:一种是严重的问题,一种是非严重的问题:
1)、对于严重的,java通过Error类来进行描述;对于Error一般不编写针对性的代码进行处理。
2)、对于非严重的,java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容。 比如:不正常情况的情况,引发原因等。
异常的继承关系:
Throwable

|---Error

|---Exception

2、异常分为两种:

1)、编译时被检测的异常;

2)、编译时不被检测的异常(运行时异常: RuntimeException及其子类)。


3、异常的好处:

1)、可以将问题进行封装;

2)、将正常流程代码和问题处理代码相分离,便于阅读。


二、异常的的处理

1、异常的处理方式

Java提供了特殊的语句对异常进行处理。

try

{

需要被检测的代码;

}

catch(异常类 变量)

{

处理异常的代码(处理方式);

}

finally

{

一定会执行的代码;

}

finally代码块:定义一定会执行的代码,通常用于关闭资源。只有一种情况finally执行不到:System.exit(0); 即系统退出,Jvm停止。

注:catch是用于处理异常,如果没有catch就代表异常没有被处理过,如果该异常是检测异常,那么必须声明。


2、对捕获到的异常对象进行常见操作

StringgetMessage(): 获取异常的信息;

toString(): 获取异常名称,异常信息;

printStackTrace(): 获取异常名称,异常信息,异常出现的位置。

演示示例:

class Demo
{
	public int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException
	{
		int[] arr = new int[a];
		System.out.println(arr[4]);
		return a/b;
	}
}
class ExceptionDemo 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(5,0);
			System.out.println("x= "+x);
		}
		catch (ArithmeticException e)  //此处想到于Exception e = new ArithmeticException;
		{
			System.out.println("出现除数为零错误!!!");
			System.out.println(e.getMessage()); //获取异常信息;
			System.out.println(e.toString());  //获取异常名称,异常信息;
			e.printStackTrace(); //获取异常名称,异常信息,异常出现的位置;
		}
		catch (ArrayIndexOutOfBoundsException e)
		{
			System.out.println("出现角标越界错误!!!");
			System.out.println(e.getMessage());
			System.out.println(e.toString());
			e.printStackTrace();
		}
		System.out.println("over");
	}
}
其实 java对异常的处理机制就是在调用printStackTrace方法,打印异常在堆栈中的跟踪信息。

在函数上声明异常,便于提高安全性,让调出进行处理,不处理编译失败。

3、对多异常的处理:

1)、声明异常时,建议声明更为具体的异常,这样可以更加具体的处理异常;

2)、对方声明几个异常,就对应几个catch块,不要定义多余的catch块。如果多个catch块中出现继承关系,父类(Exception)异常catch块放在最下面。(如果放在上面,有的子类异常catch块将执行不到);

3)、建议在catch处理时,catch中一定要定义具体处理方式,不要简单一句e.printStackTrace(),也不要简单地就写一条输出语句。

4、自定义异常

 因为项目中会出现一些特有的问题,而这些问题并没有被java所描述并封装,所以对这些特有的问题可以按照java对问题封装的思想将这些特有的问题进行自定义的异常封装。

 当在函数内部出现了throw抛出异常对象,那么就必须要给出对应的处理动作,要么在内部try  catch处理,要么在函数上声明让调用者处理。

一般情况下,函数内出现异常,函数需要声明。如果发现打印的结果中只有异常名称,没有异常信息,是因为自定义的异常并未定义所属信息。

5、如何自定义异常

因为父类中已经把异常信息的操作都完成了,所以子类只要在构造时将异常信息通过super传递给父类,那么就可以直接通过getMessage方法获取自定义异常信息。

演示示例:

class FuShuException extends Exception   //自定义负数异常;继承Exception
{
	private int value;
	FuShuException(String message,int value)
	{
		super(message);       //将异常信息传递给父类;
		this.value = value;
	}

	public int getValue()
	{
		return value;
	}
}

class Demo
{
	public int div(int a,int b) throws FuShuException  //抛出负数异常
	{
		if(b<0)
			throw new FuShuException("除数出现负数了",b);
		return a/b;
	}
}

class ExceptionDemo1 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		try
		{
			int x = d.div(4,-3);	
			System.out.println("x = "+x);
		}
		catch (FuShuException e)
		{
			System.out.println(e.toString());         //通过父类获取异常信息;
			System.out.println("出现的负数是:"+e.getValue());
		}
		System.out.println("over");
	}
}

自定义异常都必须继承Exception。原因:异常体系有一个特点,因为异常类和异常对象都被抛出,它们都具备可抛性,这个可抛性是Throwable这个体系中独有的特点。只有这个体系中的类和对象才可以被throws和throw操作。

throw和throws的区别:

1)、throws使用在函数上。而throw使用在函数内;

2)、throws后面跟的是异常类类,还可以跟多个,中间用逗号隔开。而throw后面跟的是异常对象。

例如:

class Demo

     {

                    int div(int a, int b)throws FuShuException

           {

                            If(b<0)

                                   throw new FuShuException(“出现除以负数的情况了”);

}

}

三、RuntimeException

1、Exception中有一个特殊的子类异常RuntimeException:运行时异常。

其特点为:

1)、如果在函数内中抛出该异常,函数上可以不用声明,编译照常通过;

2)、 如果在函数上声明了该异常,调用者可以不进行处理,编译照常通过。

原因:之所以不用在函数上声明,是因为不需要让调用者处理。当该异常发生时希望程序停止。因为在运行时出现了无法继续运算的情况,希望程序停止后对代码进行修正。

自定义异常时,如果该异常导致程序无法再继续运行,就让自定义异常继承RuntimeException。

演示示例:

abstract class Shape
{
	abstract void getArea();
}

class NoValueException extends RuntimeException  //继承RuntimeException是因为当半径为负值后
{                                                //无法继续运算,让程序停止,修正代码
	NoValueException(String message)
	{
		super(message);
	}
}

class Circle extends Shape
{
	double radius;
	public static final double PI=3.14;
	Circle(double radius)
	{
		if(radius <= 0)
			throw new NoValueException("半径不能为负数"); //抛出RuntimeException的子类异常;
		this.radius = radius;                             //方法上不用声明;后续也不用处理
	}

	void getArea()
	{
		System.out.println(radius*radius*PI);
	}
}

class ExceptionDemo2 
{
	public static void main(String[] args) 
	{
		Circle c = new Circle(-5.0);
		c.getArea();

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

四、异常在子父类覆盖中的体现

1、子类在覆盖父类时,如果父类的方法抛出异常,那么在子类的覆盖方法中,只能抛出父类异常或者父类异常的子类;

2、如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集;

3、如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。如果子类方法中发生了异常,就必须进行try处理,绝对不能抛出。


五、异常处理的原则

1、处理方式有两种:try或者throw;

2、调用到抛出异常的功能时,抛出几个就处理几个,一个try对应多个catch;

3、当出现多个catch,父类的catch放在最下面;

4、Catch内需要定义针对性的处理方式,不要简单的定义printStackTrace输出语句,也不要不写。

当捕获到的异常本功能处理不了时,可以继续在catch中抛出。

try

{

       thrownew AException();

}

catch (AException e)

{

       throwe;

}

如果异常处理不了,但并不属于该功能出现的异常,可以将异常转换后再抛出和该功能相关的异常。或者异常可以处理,但需要将异常产生的和本功能相关的问题提供出去,让调用者知道并处理,也可以将捕获的异常处理后,转换新的异常。

try

{

       thrownew AException();

}

catch (AException e)

{

       //对AException处理;

       thrownew BException();

}


------- android培训、java培训、期待与您交流! ----------

你可能感兴趣的:(Java学习日志)