黑马程序员------面向对象（No.8）(自定义异常、throw(throws)、RuntimeException、覆盖时异常、异常总结)

---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流！ ---------------------- 

自定义异常

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

 

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。

要么在内部try-catch处理。
要么在函数上声明让调用者处理

 

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

 

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

 

自定义异常要求：
必须是自定义类继承Exception。

 

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具有可抛性，

这个可抛性是Throwable这个体系中独有特点。

只有这个体系中的类和对象才可以被throws和throw操作。

/*
需求：在本程序中，对于除数是-1，也视为是错误的是无法进行运算的，
那么就要对这个问题进行自定义描述。
*/

//自定义异常：必须是自定义类继承Exception。
//自定义异常类要定义信息。否则会发现打印的结果中只有异常的名称，没有异常的信息。
class FuShuException extends Exception{
	private int num;
	//因为父类中已经把异常信息的操作都完成了。
	//所以父类只要在构造时，将异常信息传递给父类通过super语句，
	//那么就可以直接通过getMessage方法获取自定义的异常信息。
	FuShuException(String msg,int num){
		super(msg);
		this.num = num;
	}
	public int getValue(){
		return num;
	}
}
class Demo{
	//一般情况下，函数内出现异常，函数上需要声明。

	//当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
	//要么在内部try-catch处理。
	//要么在函数上声明让调用者处理
	int div(int a,int b)throws FuShuException{
		if(b<0){
			//手动通过throw关键字抛出一个自定义异常对象
			throw new FuShuException("这里出现负数异常",b);
		}
		return a/b;
	}
}
class ExceptionDemo{
	public static void main(String[] args){ 
		Demo d = new Demo();
			try{
			int x = d.div(5,-1);
			System.out.println(x);
			}catch(FuShuException e){
				System.out.println(e.getMessage()+" "+e.getValue());
			}
		System.out.println("over");
	}
}

运行结果：

throws和throw的区别

1.thows用在函数上   后面跟异常类，可以跟多个，用逗号分开

2.throw用在函数内   后面跟的是异常对象。

 

RuntimeException

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

1.如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。

2.如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。

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

 

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

 

对于异常分两种

1.编译时被检测的异常。一定要在方法上声明，一定要对其进行处理。有两种方式。

2.编译时不被检测的异常。（运行时异常，RuntimeException以及其子类）不用在方法上声明，也不用处理

//如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。
//如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。
class FuShuException extends RuntimeException{
	private int num;
	FuShuException(String msg,int num){
		super(msg);
		this.num = num;
	}
	public int getValue(){
		return num;
	}
}
class Demo{
	//RuntimeException的子类异常可以不用声明 throws FuShuException
	//非RuntimeException异常一定要声明throws FuShuException，否则不能编译通过。
	int div(int a,int b){
		if(b<0){
		throw new FuShuException("这里出现负数异常",b);
		}
		return a/b;
	}
}
class ExceptionDemo{
	public static void main(String[] args){ 
		Demo d = new Demo();
		int x = d.div(5,-1);
		System.out.println(x);
		System.out.println("over");
	}
}

finally

finally代码块：定义一定执行的代码

通常用于关闭资源，或者一定要执行一次的代码。

//finally代码块：定义一定执行的代码
//通常用于关闭资源，或者一定要执行一次的代码。
class FuShuException extends Exception{
	FuShuException(String msg){
		super(msg);
	}
}
class Demo{
		int div(int a,int b)throws FuShuException{
		if(b<0){
		throw new FuShuException("这里出现负数异常");
		}
		return a/b;
	}
}
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(e.toString());
			//return;
		}finally{
			System.out.println("finally");//finally中放的是一定要执行的代码
		}
		System.out.println("OVER");
	}
}

 

小例子

记住一点：catch是用于处理异常。如果没有catch就代表异常类没有被处理过，如果该异常是检测时异常。那么必须声明。

/*
public void method(){ //这里不需要声明 throws Exception 也能编译通过
	try
	{
		throw new Exception();
	}
	catch (Exception e)
	{
		语句
	}
}
*/
/*
public void method() throws Exception{ //这里要声明（除非RuntimeException） throws Exception 不然不能编译通过
	try
	{
		throw new Exception();
	}
	finally
	{
		关闭资源语句
	}
}
*/

异常覆盖时的异常特点

 

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

1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类

2.如果父类方法抛出多个异常，那么子类在覆盖方法时，只能抛出父类异常的子类。

3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。

4.如果子类的方法发生了异常，就必须用try-catch处理。绝对不能抛出！

class AException extends Exception{
}
class BException extends Exception{
}
class CException{
}
/*
Exception
   |--AException
      |--BException
   |--CException
*/
class Fu{
	public show() throws AException{
	}
}
class Zi{
	//public show() throws AException{}
	//public show() throws BException{}
	/*public show(){
		try{}
		catch (...){处理语句}AException、BException、CException都可以在内部被处理，就不用抛出了~
	}*/
}

 

附加吧：

 

异常的好处：

1.将问题进行封装。

2.将正常流程代码和问题处理代码相分离，方便阅读。

 

异常的处理原则：

1.两种方式：try或者抛出

2.调用到抛出异常功能时，抛出几个，处理几个。一个try对应多个catch。

3.多个catch，父类的catch放在下面。

4.catch内需要定义针对性的处理方式。不要太简单的定义printStackTrace，输出语句；也不要不写。

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

try
{
	throw new AException();
}
catch (AException e)
{
	throw e;
}

      如果该异常类处理不了，但并不属于该功能出现的异常。可以将该异常转换后，再抛出和该功能相关的异常。

  或者异常可以处理，当需要将异常产生的和本类功能相关的问题提供出去，让调用者知道并处理，也可以将捕获异常处理后转换新的异常

try
{
	throw new AException();
}
catch (AException e)
{
	//对AException进行处理
	throw new BException;
}

练习题 请参阅  传智播客毕向东Java基础视频教程-day10-06-面向对象(练习四).avi
 

---------------------- ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ---------------------- 

详情请查看：http://edu.youkuaiyun.com