java之10天 异常

异常的特点:

/**
 *异常的特点:
 *1.异常在子父类覆盖中的体现
 *  子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类. 
 *2.如果父类抛出多个异常,那么子类在覆盖方法时,只能抛出父类异常的子集.
 *3.如果父类或者接口的方法中没有抛出异常,那么子类在覆盖方法时,也不可以抛出异常
 *  如果子类方法发送了异常,就必须要进行 try处理,绝对不能抛出异常.
 */

class AException extends Exception{
	
}
class BException extends AException{
	
}
class CException extends Exception{
	
}
class DException extends CException{
	
}


/**
 * Exception
 *   |--AException
 *       |--BException
 *   |--CException
 *       |--DException
 */
class Fu{
	void show() throws AException{
		System.out.println("Fu show");
	}
	
	void method() throws AException,BException{
		System.out.println("Fu Method");
	}
}

class Zi extends Fu{
	void show() throws BException{ //如果这里为CException  编译不通过
		System.out.println("Zi show");
	}
}

class Zzi extends Fu{
	/*
	void method() throws AException,CException{ //如果这里为CException  编译不通过
		
	}
	void method() throws BException,CException{ //如果这里为CException  编译不通过
		
	}
	void method() throws AException,DException{ //如果这里为CException  编译不通过
		
	}
	void method() throws BException,DException{
		
	}
	void method() throws BException{
		
	}
	void method() throws DException{ 
		
	}
	void method() throws AException{ 
		
	}
	void method() throws CException{ 
		
	}*/
	void method(){ //可以看出 子类在重写父类的方法的时候 可以不抛出异常 也可以不处理父类中的异常
		System.out.println("Zzi Method");
	}
	
}
public class ExceptionDemo1 {

	public static void main(String[] args) {
		
		Fu f=new Zi();
		
		try {
			f.show();
		} catch (AException e) {  //可以看出  如果这里是 AException 那么处理 BException 没有问题,而CException不能在这个catch处理
			e.printStackTrace();
		}
		
		Fu ff=new Zzi();  //不管 子类重写是否抛出异常 使用多态调用的时候   还是要进行异常处理
		try {
			ff.method();
		} catch (BException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (AException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		Zzi zz=new Zzi();
		zz.method();
		
		
		/**打印
		 * Zi show
		 * Zzi Method
		 * Zzi Method
		 */
	}

}

异常练习

/**
 * 异常练习
 * 1.有一个圆形和长方形
 *   都可以获取面积,对与面积如果出现非法数值,视为是获取面积出现的问题
 *   问题通过异常来表示
 *   现对这个程序进行基础设计
 */
interface Shape{
	void getArea();
}

//添加异常子类
class NoValueException extends Exception{
	NoValueException(String msg){
		super(msg);
	}
}

class NoValue1Exception extends RuntimeException{
	NoValue1Exception(String msg){
		super(msg);
	}
}

class Rectangle implements Shape{
	private int len,wid;
	Rectangle(int len,int wid) throws NoValueException{
		//学了异常后  就不这么干了
		if(len<=0 || wid<0){  //问题代码和  正常代码 结合紧密
			System.out.println("错了");
		}else{
			this.len=len;
			this.wid=wid;
		}
		
		//使用异常来处理  (使用 分层的思想来理解更好)
		if(len<=0 || wid<0)
			throw new NoValueException("出现非法值");  //满足条件后就跳转了 不用加 else了
		
		this.len=len;
		this.wid=wid;
		
	}
	public void getArea(){
		System.out.println(len*wid);
	}
}
class Circle implements Shape{
	private int  radius;
	Circle(int radius){
		if(radius<=0) // 使用运行时异常来处理
		    throw new NoValue1Exception("出现非法值");
		
		this.radius=radius;
	}
	public void  getArea(){
		System.out.println(Math.PI*Math.pow(radius, 2));
	}
}


public class ExceptionDemo2 {
	
	public static void main(String[] args) {
		try {
			Rectangle r=new Rectangle(-3,4);  //其实 -3  传递进去 这个 长方形 是没有意义的 ,那后面的 什么 求面积  都是没有意义的 ,所以  这个异常 我们不需要处理 ,应改为 RuntimeException 让程序终止 
			r.getArea();
		} catch (NoValueException e) {
			System.out.println(e.toString());
		}
		System.out.println("Rec over");
		
		//这样设计才合理
		Circle c=new Circle(-3);  //这样这句 出现 RuntimeException 异常后 程序就会终止  后面的 "计算面积"  和  "Circle over" 都不会执行 
		c.getArea();  
		System.out.println("Circle over");
	}

}

异常的总结

/**
 *异常的总结
 *是什么?  是对问题的米哦啊数,将问题进行对象的封装'
 *-----------------------------------
 *异常体系:
 *Throwable
 *  |--Error
 *  |--Exception
 *       |--RuntimeException
 *
 *异常体系的特点: 异常体系中的所有类以及建立的对象都具备可抛性
 *            也就是说可以被throw 和throws关键字所操作.
 *            只有异常体系具备这个特点.
 *-----------------------------------
 *throw 和 throws的用法:
 *
 *throw定义在函数内,用于抛出异常对象
 *throws 定义在函数上,用于抛出异常类,可以抛出多个用都好分开.
 *
 *当函数内容有throw抛出异常对象,并未进行try处理,必须要在函数上声明,否则编译失败.
 *注意:RuntimeException除外.也就是,函数内部如果抛出的RuntimeException异常,函数上可以不用声明
 *
 *-----------------------------------
 *如果函数声明了异常,调用者需要进行处理,处理方法可以throws 和try
 *
 *异常有两种:
 *   编译时被检测异常 :
 *       该异常在编译时,如果没有处理(没有  throws 和  try),编译失败.
 *       该异常被标识,代表这可以被处理
 *   运行时异常(编译是不检测):
 *       在编译时,不需要处理,编译器不检查
 *       该异常的发生,建议不出力,让程序停止,需要对代码进行修正.
 *-----------------------------------
 *异常处理的语句
 *try {
 *    需要检测的代码
 *}catch(){
 *  处理异常的代码
 *}finally{
 *  一定会执行的代码
 *}
 *
 *有三种结合形式
 *   1: try{ }catch(){}
 *   2: try{}finally{}
 *   3: try{}catch(){}finally{}
 *   
 *注意:
 *   1.finally中定义的通常是,关闭资源代码,因为资源必须要释放.
 *   2.finally只有一种情况不会被执行,但执行到 System.exit(0);finally不会被执行.
 *-----------------------------------   
 *自定义异常:
 *   定义类继承 Exception和RuntimeException
 *   1.为了让该自定义类具备可抛性
 *   2.让该类具备操作异常的共性方法.
 *   当要定义自定义异常的信息时,可以使用父类已经定好的功能.
 *   异常信息可以传递给父类构造函数
 *   class MyException extends Exception{
 *     MyException(String message){
 *        super(message);
 *      }
 *   }
 *  自定义异常: 按照java的面向对象的思想,将程序中出现的特有问题进行封装. 
 * 
 *异常的好处
 *  1.将问题进行封装
 *  2.将正常流程代码和问题处理代码相分离,方便阅读.
 *-----------------------------------    
 *异常处理的原则:
 *  1.处理方式有两种:  try 或者   throws
 *  2.调用到抛出异常的功能时,抛出几个,就处理几个.
 *     一个 try 对应 多个 catch
 *  3.多个catch.父类的catch放在最下面.
 *  4.catch内需要定义针对性的处理方式.不要简单额定义 printStackTracke,或输出语句 ,不要不写.
 *    当捕获到的异常,本功能处理不了时,可以继续在catch中抛出.
 *    try{
 *    	throw new AException();
 *    }catch(AException e){
 *       throw e;
 *    }
 *    如果该异常处理不了.但并不属于该功能出现的异常,可以将异常转换后,再抛出和该功能相关的异常.(比如前面例子:Teacher 讲课 冒烟问题)
 *    或者异常可以处理,但需要异常产生的和本功能相关的问题提供出去,让调用者知道,并处理.也可以将捕获异常后,转换新的异常.
 *    try{
 *    	throw new AException();
 *    }catch(AException e){
 *    	//对 AException进处理    转转  和  数据库操作失败 等类是问题
 *      throw new BException();
 *    }
 *----------------------------------- 
 *异常的注意事项
 *  在父子类覆盖时:
 *  1.子类抛出的异常必须是父类的异常或者父类异常的子类或者 子集
 *  2.如果父类或者接口没有异常抛出,子类覆盖出现异常,只能用 try不能抛出去
 *  
 *参阅 例子
 *  1.老师用电脑上课
 *  2.图像面积
 */