异常处理与自定义异常应用-优快云博客

本文链接：https://blog.youkuaiyun.com/fmi110/article/details/46913695

/*
异常总结：

异常是什么：
是对问题的描述，将问题进行对象的封装。

异常体系：
Throwable
|--Error
|--Exception
|--RuntimeException
   |--.....

异常体系的特点：异常体系中的所有类以及所建立的对象都具备可抛性
  也就是说可以被throw和throws关键字所操作
  只有异常体系具备这个特点。

throw和throws的用法：
  throw定义在函数内部，用于抛出异常对象。
  throws定义在函数上，用于抛出异常类，可以用多个逗号隔开。
  当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败。

注意，RuntimeException除外，也就是说，函数内如果抛出的RuntimeException异常，函数
可以不用声明

如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try。

异常有两种：
    编译时被检测异常
          该异常在编译时，如果没有处理（没有抛出也没有try），编译失败
      该异常被标识，代表可以被处理。
    运行时异常（编译时不检测）
          在编译时，不需要处理，编译器不检查。
      该异常的发生，建议不处理，让程序停止，需要对代买进行修正。

异常处理语句：

try
{
  需要检测的代码;
}
catch
{
  处理异常的代码;
}
finally
{
  一定会执行的代码（系统不提前退出的情况下）
}
有三种结合方式
try{}
catch{}
---------------
try{}
finally{}
---------------
try{}
catch{}
finally{}

注意：
1 finally中定义的通常是关闭资源代码，因为资源必须释放。
2 finally只有一种情况不会执行。当执行System.exit(0);finally不会被执行。因为System.exit(0)执行后系统退出，jvm结束。

自定义异常：
定义类继承Exception 或者 RuntimeExcption
1 为了让该自定义类具备可抛性。
2 为了让该类具备操作异常的共性方法。

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。
将异常信息传递给父类的构造函数。
class MyException extends Exception
{
  MyException(String msg)
  {
    super(msg);
  }
}

自定义异常：按照java面向对象的思想，将程序中出现的特有问题进行封装。

异常的好处：
1 将问题进行封装
2 将正常流程代码和问题处理代码相分离，方便于阅读。

异常的处理原则：
1 处理方式有两种：try 或 throws
2 调用到抛出异常的功能时，抛出几个，就处理几个
3 一个try 对应多个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();
}

异常的注意事项：
在子父类覆盖时：
1 子类抛出的异常必须是父类异常的子类或者子集
2 如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛

*/

运用异常的练习

/*
需求：有一个圆形和长方形
都可以获取面积。对于面积如果出现非法的数值，视为获取面积出现问题。
问题通过异常来表示。

分析及设计：定义接口，接口中含有求面积的方法
			定义类圆，构造函数有参数半径，实现接口
			定义类矩形，构造函数含参数长和宽，实现接口
			自定义异常类：
				方法一：继承 类Exception 在函数内部抛出异常，则函数需要声明，异常抛出后需要catch处理
				方法二：继承 类RuntimeException ，程序遇到异常的抛出，此时不需要在函数声明异常
*/
/*自定义异常 方法一
class NoValueException extends Exception
{
	NoValueException(String msg)
	{
		super(msg);
	}
}
*/
/*自定义异常 方法二 */


/* 自定义异常  方法一 继承类Exception时，在函数内部抛出异常时，函数需要声明异常
class Rec implements Shape
{
	private int len,wid;

	Rec(int len,int wid) throws NoValueException  //在函数内部抛出异常时，函数需要声明异常
	{
		if(len<=0 || wid <= 0)
			throw new NoValueException("出现负数"); //函数内部抛出异常
		this.len = len;
		this.wid = wid;
	}

	public void getArea()
	{
		System.out.println("矩形面积："+len*wid);
	}
}
*/
class NoValueException extends RuntimeException
{
	NoValueException(String msg)
	{
		super(msg);
	}
}


interface Shape
{
	abstract void getArea();
}
/* 自定义异常  方法二 */
class Rec implements Shape  //矩形类
{
	private int len,wid;

	Rec(int len,int wid) 
	{
		if(len<=0 || wid <= 0)
			throw new NoValueException("参数负数，非法");
		this.len = len;
		this.wid = wid;
	}

	public void getArea()
	{
		System.out.println("矩形面积："+len*wid);
	}
}

class Circle implements Shape  //圆形类
{
	private double radius;
	public static final double PI = 3.14;

	Circle(double radius) 
	{
		if( radius <=0)
			throw new NoValueException("参数负数，非法");
		this.radius = radius ;
		
	}

	public void getArea()
	{
		System.out.println("圆形面积："+PI*radius*radius);
	}
}

class ExceptionTest1
{
	public static void main(String[] args) 
	{		
/*	方法一	
		try
		{
			Rec r = new Rec(4,5);
			r.getArea();
		}
		catch (NoValueException e)
		{
			System.out.println("计算失败");
			System.out.println(e.toString());
		}
*/	
		Rec r = new Rec(4,5);
		r.getArea();
		
		Circle c = new Circle(12);
		c.getArea();
		System.out.println("\n*************程序结束*************");
	}
}

网上看到的补充一些

注意：如果我们使用的是try-catch-finally语句块，而我们又需要保证有异常时能够抛出异常，
那么在finally语句中就不要使用return语句了（finally语句块的最重要的作用应该是释
放申请的资源），因为finally中的return语句会导致我们的throw e被抛弃，
在这个try-catch-finally的外面将只能看到finally中的返回值（除非在finally中抛出异常）。
（我们需要记住：不仅throw语句是abrupt completion 的原因，return、break、continue等
这些看起来很正常的语句也是导致abrupt completion的原因。）

boolean testEx1() throws Exception
    {
        boolean ret = true;
        try
        {
		 ret = testEx2();
		}
        catch (Exception e)
        {
            throw e;
        }
        finally
        {
            System.out.println("testEx1, finally; return value=" + ret);
        }
    }
    boolean testEx2() throws Exception
    {
        boolean ret = true;
        try
        {
			throw new Exception();
        }
        catch (Exception e)
        {
            throw e;
        }
        finally
        {
            System.out.println("testEx2, finally; return value=" + ret);
            return ret;//这个语句导致函数抛出的异常e语句被抛弃，e不能被testEx1捕捉！！！，则testEx1中的catch部分不执行
        }
    }

java 之 异常

java 之异常