黑马程序员_【总结】_ 异常知识梳理_(end)

异常知识梳理

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

---------------------------------------------------------------------------------------------------------------------------------------------

1、throws 声明异常------throw  捕获异常
2、声明异常时，建议声明更为具体的异常，这样处理可以更具体
3、在函数内部出现throw抛出异常对象，那么就必须给要对应的处理动作
4、自定义异常:  必须是自定义类继承Exception

继承Exception原因：

1、异常体系有一个特点，因为异常类和异常对象都需要被抛出，

他们都具备可抛性，这个可抛性是Throwable这个体系中独有特点

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

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

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

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

6、自定义的异常时:如果该异常的发生，无法在继承进行运算

就让自定义类异常继承RuntimeException

7、异常，分两种

1、编译时，被检测出的异常   （方法后需要抛出异常。）

2、编译时，不被检测出的异常（运行时的异常就是RuntimeException异常）

-----------------------------------------------------------
【1】
1
Throwable

Error  严重性问题

Exception非严重性，针对性进行处理。

都是以父类名作为后缀。

问题也是现实生活中的一个具体事物，也可以通过Java的类的形式进行描述

并封装成对象，其实就是Java对不正常情况进行描述后的对象体现。

2、异常的处理
Java提供了特有的语句进行处理
try{

需要被检测的代码

}
catch(异常类 变量){

处理异常的代码（也就是处理方式）

}
finally{

一定会执行的语句。

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

String getMessage()： 获取异常信息

4、声明异常\ 捕获异常

throws 声明异常

throw  捕获异常

5、对多异常的处理

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

2、对声明几个异常，对应几个 catch 块，

如果多个catch块中的异常出现了继承关系，父类异常catch块放在最下面。

建立在进行catch处理时，catch 块中一定要具体的处理方法。

而不是 e.printStackTrace() 或 简单的输出语句

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


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


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


一般情况在 函数内出现异常，函数上需要声明.


发现打印的结果中只有异常名称，却没有异常的信息
因为自定义的异常并未定义信息


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


自定义异常:  必须是自定义类继承Exception
继承Exception原因：
异常体系有一个特点，因为异常类和异常对象都需要被抛出，
他们都具备可抛性，这个可抛性是Throwable这个体系中独有特点

只有这个体系中的类和对象才可以被throws 和throw 操作。
【3】
throws和throw区别
throws使用在函数上
throw 使用在函数内


throws 后面跟的是异常类，可以跟多个，用逗号隔开      就是：()这个位置{}
throw  后面跟的是异常对象。
【4】
【【异常中的特殊子类异常】】
Exception 中有一个特殊的子类异常RuntimeException 运行时异常
如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过
如果在函数上声明该异常，调用者可以不用进行处理，编译一样通过


之所以在函数上声明，是因为不需要调用者处理
当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，
希望停止程序后，由程序员对代码进行修正。
【m】
自定义的异常时:如果该异常的发生，无法在继承进行运算
就让自定义类异常继承RuntimeException


对于异常，分两种

1、编译时，被检测出的异常   （方法后需要抛出异常。）

2、编译时，不被检测出的异常（运行时的异常就是RuntimeException异常）

（方法中抛出了非Run异常或其子类，上面没有标识，就视为有安全隐患的。）

【【【【结论：如果自定义异常，要么继承Exception要么继承RuntimeException】】】】

class FuException extends Exception{
		private int value;
		//这个也可以，里面有默认的。
		FuException(){
			super();
		}
		FuException(String msg,int value){
			super(msg);
			this.value=value;
		}
		public int getValue(){
			return value;
		}
	/*	
	}【m】
	class FuException extends RuntimeException{
		private int value;
		//这个也可以，里面有默认的。
		FuException(){
			super();
		}
		FuException(String msg,int value){
			super(msg);
			this.value=value;
		}
		public int getValue(){
			return value;
		}
	class Demo_3{
		int div(int a,int b) //这里不在需要声明
		{
			if(b <0){
				throw new FuException("出现负数",b);//手动通过throw 关键字抛出一个自定义的异常
			}
			if(b =0){
				throw new FuException("出现0",b);//手动通过throw 关键字抛出一个自定义的异常
			}
			return a/b;
		}
	}
	*/		
	}
	class Demo_3{
		int div(int a,int b) throws FuException{
			if(b <0){
				//System.out.println("出现异常:");
				throw new FuException("出现负数",b);//手动通过throw 关键字抛出一个自定义的异常
			}
			return a/b;
		}
	}
	public class D_Exception {
		public static void main(String[] args){
			Demo_3 d=new Demo_3();
			try{
				int x=d.div(4,2);
				System.out.println("x="+x);
			}
			catch(FuException e){
				//System.out.println(e.toString());
				//System.out.println("出现负数");
				System.out.println("负数:"+e.getValue());
			}
			//catch(Exception e){	
			//}
			System.out.println("over");
		}
	}
	/*
	class Person_1{
		 public void checkName(String name){
			 //if(name.equals("lisi")){//一旦[a]处传入NULL，那么就回报NullPointerException异常
			 						   程序就停掉了。如何修正：
			 if("lisi".equalse(name)){//if(name!==null&&name.equals("lisi")){			 						   
				 System.out.println("YES");
			 }else {
				 System.out.println("NO");
			 }
		 }
	}
	main(){
		Person_1 p=new Person_1();
		p.checkName(null);//[a]
	}
	*/

【5】


 毕老师用电脑上课。
 老师、电脑、俩类，上课是行为.
 
 上课中会出现各种问题，产生异常。 
 比如电脑、蓝屏、冒烟儿    ：接下来进行描述，封装成对象            （自定义异常
 蓝屏后只许重启即可
 而  当冒烟发生后，会出现进度无法继续。
  就出现了讲师的问题，课时计划无法完成。     （又多了个类
 
 【通过state来手动设置异常】

//蓝屏异常
class LPException extends Exception{
//蓝屏是可以处理的,大多时候重启即可，那么这里就需要电脑的重启功能了
	private Comeputer comp;
	LPException(String message){
		super(message);
	}
	public void goReset(){
		comp.reset();
	}
}
//冒烟异常
class MYException extends Exception{ //RuntimeException{//冒烟了无法处理了
	MYException(String message){
		super(message);
	}	
}
//人为异常
class NoPlanException extends Exception{
	NoPlanException(String message){
		super(message);
	}
}
class Comeputer {
	private int state =3;//2表示蓝屏 3冒烟
	public void run()throws LPException,MYException{//抛出可能有的异常
		if(state==2){
			throw new LPException("电脑蓝屏了。");//抛出异常
		}
		if(state==3){
			throw new MYException("电脑冒烟儿了");//抛出异常
		}
		System.out.println("comepter run");
	}
	public void reset(){
		state=1;
		System.out.println("comepter  reset");
	}
}
class Teacher{
	private String name;
	private Comeputer cmpt;	
	Teacher(String name){//初始化老师名字、电脑
		this.name=name;
		cmpt=new Comeputer();
	}	
	public void prelect()throws NoPlanException{//MYException{//讲课方法		
		try{
			cmpt.run();
		}
		catch(LPException e){
			cmpt.reset(); 
		}
		catch(MYException e){//接收到冒烟异常然后抛出冒烟后无法继续讲课的问题，这个问题就好处理			
			test(); 
			throw new NoPlanException("课时无法继续"+e.getMessage());
			//这里的逻辑是，冒烟是不可处理异常，发生该异常后，处理就是换电脑，换老师等延续课时的方案。
			//test();  throw 后面是不能更语句的。他和return一样是结束语句。
		}
		//System.out.println("开始讲课");
	}
	public void test(){
		System.out.println("大家做练习吧");
	}
}

电脑冒烟儿了，就相当于 error ， 属于严重的问题，

而 出现了这种情况，却是可以有其他方式处理的，

可以借用电脑，可以替换个老师，可以自习，可以放假。
【6】
【异常练习】
 有一个圆形和长方形
 都可以获取面积，对于面积如果出现非法数值，视为是货获取面积出现的问题
 
 问题通过异常来表示
 先有对这个程序进行基本设计
 
 正常代码，和问题处理代码分隔开。
 
 写代码的过程中，遇到问题，用代码封装起来，问题也是一个对象。
 */

//面积接口
interface Shape{
	double getArea();
}
//负数或零异常
class FLException extends RuntimeException { //Exception{
	FLException(String msg){
		super(msg);
	}//
}
//长方形 
class Rec implements Shape{	
	private int len,wid;	
	Rec(int len,int wid) {//throws FLException //使用Runtaime异常这里就不用在写，main方法中也不用在写。
		if(len<=0 ||wid<=0)
			throw new FLException("数值错误！");
		
		this.len=len;
		this.wid=wid;
	}
	public double getArea(){
		System.out.println("Area:"+len*wid);
		return len*wid;
	}
}
//圆形
class Yuan implements Shape{
	private double r;
	private static final double PI=2.14;  //设为全局常量
	Yuan(double r){
		if(r<=0)
			throw new FLException("非法！");
		
		this.r=r;
	}
	public double getArea(){
		System.out.println("Area:"+r*r*PI);
		return r*r*PI;
	}
}
public class D_Exp_Test1 {
	public static void main(String[] args) {
		Rec r=new Rec(23,4);
		r.getArea();	
		Yuan yu=new Yuan(-3);
		yu.getArea();
	}
}

---------------------------------------------------------------------------------------------------------------------------------------------

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

黑马官网

----------------------------------------------