异常和包-CSDN博客

本文链接：https://blog.csdn.net/xiaoxixuewu/article/details/99311053

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

public static void main(String[] args) {
		Demo d = new Demo();
		try {
			int x = d.div(4, 1);
			System.out.println("x="+x);
		}
		catch (Exception e)
		{
			System.out.println(e.toString());
		}
		System.out.println("over");
	}
}
class Demo{
	int div(int a,int b)throws Exception //在功能上通过throws的关键字声明了该功能有可能会出现问题
	{
		return a / b;
	}
}

对多异常的处理：

1.声明异常时，建议声明更为具体的异常，这样处理的话可以更具体。

2.对方声明几个异常，就对应有几个catch块。不要声明多余的catch块。如果多个catch块中的异常会出现继承关系，父类异常catch块放到最下边。

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

public static void main(String[] args) {
		Demo d = new Demo();
		try {
			int x = d.div(4, -1);
			System.out.println("x="+x);
		}
		catch (Exception e)
		{
			System.out.println(e.toString());
			System.out.println("出现负数了");
		}
		System.out.println("over");
	}
}
class Demo{
	int div(int a,int b)throws Exception //在功能上通过throws的关键字声明了该功能有可能会出现问题
	{
		if(b < 0)
			throw new FuShuException();//手动通过throw关键字抛出一个自定义异常
		return a / b;
	}
}
class FuShuException extends Exception{
	
}

自定义异常：必须是自定义继承exception（异常体系都有一个特点，因为异常类和异常对象都会抛出，他们都具有可抛性，这个可抛性是throwable这个体系中独有特点，只有这个体系中的类和对象才可以被throw和throws操作）区别：throws使用在函数上，throw使用在函数内。throws后面跟的是异常类，可以跟多个，逗号隔开。throw后跟的是异常对象。

RuntimeException 子类异常

public static void main(String[] args) {
		Demo d = new Demo();
		try {
			int x = d.div(4, 0);
			System.out.println("x="+x);
		}
		catch (Exception e)
		{
			System.out.println(e.toString());
			//System.out.println("出现负数了");
		}
		finally
		{
			System.out.println("一定执行的语句");
		}
		System.out.println("over");
	}
}
class Demo{
	int div(int a,int b)//throws ArithmeticException//throws Exception //在功能上通过throws的关键字声明了该功能有可能会出现问题
	{
		if(b < 0)
			throw new FuShuException("出现除数为负数了");
		if(b==0)
			throw new ArithmeticException("被零除了");
		return a / b;
	}
}
class FuShuException extends RuntimeException{
	FuShuException(String msg){
	super();
	}
}

finally：定义一定执行的语句通常用于关闭资源。或者某些代码一定要执行。

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

异常求长方形和圆形面积练习：

public static void main(String[] args) {		
			Rec r=new Rec(3,4);
		    r.getArea();	
		    Circle c = new Circle(8);
		    c.getArea();
	}
}
class NoValueException extends RuntimeException{//声明这个异常类是可以自定义异常信息。
	NoValueException(String message){
		super(message);
	}
}
interface Shape{
	void getArea();
}
class Rec implements Shape {
	private int wid,len;
	Rec(int wid,int len)throws NoValueException{
		if(wid<=0||len<=0)
			throw new NoValueException("出现非法值");
		this.len=len;
		this.wid=wid;
	}
	public void getArea(){
		System.out.println(wid*len);
	}
}
class Circle implements Shape{
	private int radius;
	public static double PI=3.14;
	Circle(int radius){
		if(radius < 0)throw new NoValueException("非法值");
		this.radius=radius;
	}
	public void getArea() {
		System.out.println(radius*radius*PI);
	}
}

总结：

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

------异常体系：throwable-->Error和Exception-->RuntimeException

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

throw和throws：throws使用在函数上，throw使用在函数内。throws后面跟的是异常类，可以跟多个，逗号隔开。throw后跟的是异常对象。

当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败。（RuntimeException除外）如果函数上抛出RuntimeException异常，函数上可以不用声明。

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

-------异常有两种：

异常处理的几种方式：1
try {需要被检测的代码
}
catch(){处理异常的代码
}
2
try {}
catch(){}
finally{一定执行的语句
}
3
try {}
finally {}
注意：finally通常是定义的关闭资源代码，因为资源必须释放。当遇到System.exit(0);的时候不会执行。

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