Java程序中异常的相关知识

package Java学习;
/**
 * 
 * @author zhaocx1
 *
 */
/*
 * 异常：就是程序在运行时出现不正常情况。    
 * 异常由来：问题也是现实生活中一个具体的事物，也可以通过Java的类的形式进行描述，并封装成对象。
 * 		    其实就是Java对不正常情况进行描述后的对象体现。
 * 把问题封装成对象就是异常。
 * 对于问题的划分：两种：一种是严重的问题，一种非严重问题。
 * 
 * 对于严重问题：Java通过Error类进行描述。
 * 		对于error一般不编写针对性的代码对其进行处理。
 * 对于非严重的：Java通过Exception类进行描述。
 * 		对于exception可以使用针对性的处理方式进行处理。
 * 
 * 无论error或者exception都具有一些共性内容。 比如：不正常情况的信息，引发原因等。
 * 
 * Throwable    --error ;--exception;
 * 2.异常的处理
 * Java 提供了特有的语句进行处理。
 * try
 * {
 *     需要被检测的代码；
 * }
 * catch(异常类  变量)
 * {
 *		处理异常的代码;(处理方式)
 * }
 * finally
 * {
 * 		一定会执行的语句。
 * }
 * 
 * 3.对捕获到的异常对象进行常见方法操作。
 *   String getMessage;获取异常的信息。
 *   
 * 在函数上声明异常：
 * 便于提高安全性，让调用者进行处理，不处理编译失败。 
 */

class Demo {

	int div(int a, int b) throws Exception// 在功能上通过throws的关键字声明了该功能有肯能会出现问题。
	{
		return a / b;
	}
}

public class ExceptionDemo {
	public static void main(String[] args) {//主函数，整个程序的切入点
		Demo d = new Demo();//通过实例化一个demo，用来调用该类中的方法
		try {
			int x = d.div(4, 0);//将会出现异常的代码方法try语句中
			System.out.println("x==" + x); // 因为该部分代码有异常，抛给catch，所以该部分代码不会被执行。
		} catch (Exception e) {// Exception a=new ArithmeticException();
			System.out.println("除零啦");
			System.out.println(e.getMessage());// /by zero;
			
			System.out.println(e.toString());//打印异常的名称，可以不写，打印的更全面。
		    e.printStackTrace();//异常名称，异常信息，异常出现的位置。
		                        //其实jvm默认的异常处理机制，就是在调用printStackrace方法。
		                        //打印异常的堆栈的跟踪信息。

package Java学习;

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * 对多异常的处理： 1.生命异常时，建议声明更为具体的异常，这样处理的可以更具体。 2.对方声明几个异常，就对应几个catch块。
 * 不要定义多余的catch块。 如果多个catch块中的异常出现继承关系，父类异常catch放在最下面。
 * 
 * 建议在进行的catch处理时，catch中一定要定义 具体的处理方式。 不要简单定义一句 e.printStackTrace(),
 * 也不要简单的就书写一条输出语句。
 */

class Demo1 {
	int div(int a, int b) throws ArithmeticException,
			ArrayIndexOutOfBoundsException // 在功能上通过throws的关键字声明了该功能有肯能会出现问题，throws后面可以跟多个异常，中间用都好隔开
	{
		int[] arr = new int[a];
		System.out.println(arr[4]);
		return a / b;
	}
}

public class ExceptionDemo1 {
	public static void main(String[] args) // throws Exception
	{
		Demo1 d = new Demo1();
		try {// 将会出现异常的代码放到try语句中
			int x = d.div(5, 0);
			System.out.println("x=" + x);
		}

		/*
		 * //两个异常不可能同时存在，当脚标越界时，除0运算停止，ArithmeticException异常不会被执行到，相反同样。 catch
		 * (ArithmeticException e) { System.out.println(e.toString()); //
		 * 异常名称：异常信息。 出现的异常信息最全。 System.out.println("被零除啦"); } catch
		 * (ArrayIndexOutOfBoundsException e) {
		 * System.out.println(e.toString()); // 异常名称：异常信息。 出现的异常信息最全。
		 * System.out.println("角标越界"); }
		 */
		catch (Exception e) {// catch用来捕捉异常，跟异常信息
			System.out.println("haha" + e.toString());// 多态体现特点
		}

		System.out.println("over");
	}
}

package Java学习;

/*
 *因为项目中会出现特有的问题。
 *而这些问题并未被Java多描述并封装对象。
 *所以对于这些特有的问题可以按照Java对问题封装的思想，将特有的问题，进行自定义的异常封装。
 *称为i自定义异常。
 * 
 *需求：在本程序中，对于除数是-1，也视为是错误的是无法进行预算的。
 *    那么就需要对这个问题进行自定义描述。
 *
 *当在函数内部出现了throw抛出异常对象，那就必须要给对应的处理动作。
 *要么在内部try catch处理。
 *要么在函数上声明调用者处理。
 *
 *一般情况下，函数内出现异常，函数上需要声明.
 *
 *发现打印的结果中只有异常的名称，却没有异常的信息。
 *因为自定义的异常并未定义信息。
 *
 *如何定义异常信息呢？
 *因为父类中已经把异常信息的操作都完成了。
 *所以子类只要在构造时，将异常信息传递给父类通过super语句。
 *那么就可以直接通过getMessage方法获取自定义的异常信息。
 *
 *自定义异常：
 *必须是自定义类继承Exception。
 *
 *继承Exception原因：
 *异常体系有一个特点：因为异常类和异常对象都被抛出。
 *它们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
 *只有这个体系中的类和对象才可以被throws和throw使用。
 *
 *throws和throw的区别：
 *throws使用在函数上。
 *throw使用在函数内。
 *throws后面跟的异常类,可以跟多个，用逗号隔开。
 *throw后面跟的是异常对象。
 */
class FuShuException extends Exception // 自定义异常，必须要继承异常的父类Exception,建立的目的就是为了声明异常对象， getMessage
{

	FuShuException(String msg) {//对自定义类进行构造函数

		super(msg);//通过super调用父类异常信息的功能
	}
}

class Demo2 {//定义一个类抛出自定义异常，向程序的调用者声明该功能会出现异常
	int div(int a, int b) throws FuShuException {
		if (b < 0)
			throw new FuShuException("出现了除数是负数的情况");// 手动通过throw关键字抛出一个自定义异常对象。
		return a / b;
	}
}

public class ExceptionDemo3 {
	public static void main(String[] args)//主函数，整个程序运行的切入点
	{
		Demo2 d = new Demo2();//实例化对象，来调用对象的方法
		try {
			int x = d.div(4, -1);
			System.out.println("x=" + x);
		} catch (FuShuException e) {//catch后面对异常进行处理，括号里跟异常类
			System.out.println(e.toString());//打印异常信息
			System.out.println("出现负数了");
		}

	}
}

package Java学习;
/**
 * 
 * @author zhaocx1
 *
 */
/*
 * Exception中有一个特殊的子类异常RuntimeException运行时异常。
 * 
 * 如果在函数内容抛出异常，函数上可以不用声明，编译一样通过。
 * 如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。
 * 
 * 之所以不用在函数声明，是应为不需要让调用者处理。
 * 当该异常发生，希望程序停止，因为在运行时，出现了无法继续运行的情况，希望停止程序后，对代码进行修正。
 *
 * 自定义异常时，如果该异常的发生，无法在继续进行运算。
 * 就让自定义异常继承RuntimeException  

 * 对于异常分两种：
 * 1.编辑时被检测的异常。
 * 2.编译时不被检测的异常（运行时异常。RuntimeException以及 其子类）     
 */
class FuShuException1 extends RuntimeException {//自定义异常继承异常中一个特殊的子类运行时异常
	FuShuException1(String msg) {//对异常类进行构造函数
		super(msg);//调用异常父类中的异常信息方法
	}
}

class Demo3 {
	int div(int a, int b) {//当类抛出RuntimeException或者其子类的时候，如果函数上抛出异常，不需要对函数内容进行处理，如果函数内进行异常处理，函数上不需要抛出异常
		if (b < 0)
			throw new FuShuException1("出现了除数为负数了");//判断时候符合，不符合抛出异常
		if (b == 0)
			throw new ArithmeticException("被零除啦");
		return a / b;
	}
}

public class ExceptionDemo4 {
	public static void main(String[] args) //throws Exception
	{
		Demo3 d = new Demo3();//对类进行实例化，以调用类中的方法

		int x = d.div(4, -9);//对类中的函数进行初始化，判断是否符合条件
		System.out.println("x=" + x);//输出打印结果

		//System.out.println("出现负数了");

	}
}

package Java学习;
/**
 * 
 * @author zhaocx1
 * 异常练习：
 */
/*
 * 毕老师用电脑上课。
 *
 * 开始思考上课中出现的问题。
 * 比如：电脑蓝屏。
 *	        电脑冒烟。
 * 要对问题进行描述，封装成对象。
 * 
 * 可是当冒烟发生后，出现讲课进度无法继续。
 * 出现了讲师的问题，课时计划无法完成。
 */
class LanPingException extends Exception//自定义异常继承异常父类
{
	LanPingException(String message)//对异常类进行构造函数
	{
		super(message);//调用异常父类异常信息的方法
	}
}
class MaoYanException extends Exception
{
	MaoYanException(String message)
	{
		super(message);
	}
}
class NoPlanException extends Exception
{
	NoPlanException(String msg)
	{
		super(msg);
	}
}
class Computer {
	private int state = 1;

	public void run() throws LanPingException, MaoYanException {
		if (state == 2)
			throw new LanPingException("蓝屏了");
		if (state == 3)
			throw new MaoYanException("冒烟了");
		System.out.println("电脑运行");
	}

	public void reset() {
		System.out.println("电脑重启");
	}
	//自定义一个电脑类，在电脑运行的时候会出现异常：蓝屏和冒烟，某种状态会出现蓝屏异常，另外一种情况会出现冒烟异常
}

class Teacher {
	private String name;
	private Computer cmpt;

	Teacher(String name) {
		this.name = name;
		cmpt = new Computer();
	}

	public void prelect() throws NoPlanException {
		try {
			cmpt.run();
		} catch (LanPingException e) {
			cmpt.reset();

		} catch (MaoYanException e) {
			throw new NoPlanException("课时无法继续");
		}
		System.out.println("讲课");
	}
}

public class ExceptionTest {
	public static void main(String[] args) {
		Teacher t = new Teacher("毕老师");
		try {
			t.prelect();
		} catch (NoPlanException e) {
			System.out.println("换老师，或者换电脑");
		}
	}

}

package java学习;

/**
 * 
 * @author zhaocx1
 * 
 */
/*
 * finally代码块：定义一定执行的代码。 通常用于关闭资源。
 */
class FuShuException extends Exception {// 自定义异常继承异常的父类
	FuShuException(String msg) {// 对自定义异常进行构造函数，后面传递异常信息
		super(msg);
	}
}

class Demo3 {
	int div(int a, int b) throws FuShuException {// 在函数上声明该 函数内容会出现异常，以便调用者进行处理

		if (b < 0)// 定义一个异常情况，告诉调用者出现该情况会有异常
			throw new FuShuException("除数是负数了");// 抛出异常信息
		return (a / b);
	}

}

public class ExceptionDemo5 {
	public static void main(String[] args) {// 主函数，整个程序的切入点
		Demo3 d = new Demo3();// 对对象进行实例化，以便调用对象中的方法
		try {
			int x = d.div(4, 0);//调用类中的函数
			System.out.println("x=" + x);//输出打印函数的结果
		} catch (FuShuException e) {// 打印异常信息
			System.out.println(e.toString());
		} finally {// finally中存放的是一定会被执行的代码。
			System.out.println("finally");
		}
		System.out.println("over");
	}
}

package java学习;

//记住一点：catch是用于处理异常，如果没有catch就代表异常没有处理过，如果该异常时检测时异常，那么必须声明。
/*
 * 第一种格式：try{} catch(){};第二种格式：try{} catch(){} finally{};第三种格式：try{} finally{}
 * 
 */

public class ExceptionDemo6 {
	public void main(String[] args) {
		System.out.println("hello world");
	}
}

package java学习;

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

class AException extends Exception {
}

class BException extends AException {
}

class CException extends Exception {
}

/*
 * Exception |--AException |--BException |--CException
 */
class Fu {// 定义一个父类抛出异常
	void show() throws AException, CException {

	}
}

class Zi extends Fu {// 子类在覆盖父类时，如果父类的方法抛出， 那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类
	void show() throws CException {// 覆写父类的方法
	}
}

class Test {
	void function(Zi z) throws CException {// 当一个类中的方法传入父类的参数，必须要抛出父类的异常的子集
		try {// 对类中异常信息进行处理
			z.show();
		} catch (CException e) {

		}

	}
}

class ExceptionZiFu {
	public static void main(String[] args) throws CException {// 主函数在调用异常类时必须要抛出该类中的异常
		Test t = new Test();// 对类进行实例化，以便调用类中的方法
		t.function(new Zi());
	}
}

package java学习;
/**
 * 
 * @author zhaocx1
 * 异常练习
 */
/*
 *有一个圆形和长方形；
 *都可以获取面积，对于面积如果出现非法数值，视为是获取面积出现问题。
 *问题通过异常来表示。
 *现对这个程序进行基本设计。
 *
 */

class NoValueException extends RuntimeException {//自定义异常，继承RuntimeException
	NoValueException(String message) {//对自定义异常进行构造函数，并传递需要抛出的异常信息
		super(message);//调用父类的功能
	}
}

interface Shape {//定义一个获取面积的接口，让下面的类能够实现接口，调用接口中的方法
	void getArea();
}

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 Circle implements Shape {//定义一个类：圆，实现上面的接口，以便调用接口中方的方法
	private int radius;//私有化一个成员变量
	private static final double PI = 3.14;//私有化一个全局常量

	Circle(int radius) throws NoValueException {//将会出现异常的函数内容在函数上声明异常信息
		if (radius <= 0)
			throw new NoValueException("半径不能小于0");//函数内抛出异常
		this.radius = radius;//调用本类中的对象
	}

	public void getArea() {
		System.out.println(radius * radius * PI);//调用接口中的方法，输出打印方法结果
	}
}

public class ExceptionDemo {
	public static void main(String[] args) {//主函数，整个函数的切入点

		try {//调用类中的异常函数，对函数进行初始化值
			Rec r = new Rec(3, 4);
			r.getArea();
			Circle c = new Circle(-8);
			c.getArea();

		} catch (NoValueException e) {//catch处理异常，打印异常信息
			System.out.println(e.toString());

			// Circle c = new Circle(-8);
			System.out.println("不成立");

		}

		System.out.println("over");
	}
}

package java学习;
/**
 * 
 * @author zhaocx1
 *
 */
/*
 *异常：
 *是什么？ 是对问题的描述，将问题进行对象的封装。
 *异常体系：
 *Throwable
 *      --Error
 *      --Exception
 *          --RuntimeException
 *异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。
 *			 也就是说可以被throw和throws关键字多操作。
 *throw和throws的用法：
 *throw定义在函数内，用于抛出异常对象。
 *throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
 *
 *当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，否则编译失败，
 *注意：RuntimeException除外。也就是说，函数内如果抛出RuntimeException异常，函数上可以不用声明。
 *
 *如果函数声明了异常，调用者需要进行处理。处理方法可以throws可以try.
 *
 *异常有两种：
 *		编译时被检测异常
 *			该异常在编译时如果没有处理（没有抛也没有try）
 *			该异常被标示，代表着可以被处理。
 *		运行时异常（编译时不检测）
 *			在编译时，不需要处理，编译器不检查。
 *			该异常的发生，建议不处理，让程序停止。需要对代码进行修正。
 *异常处理的语句：
 *try{需要被检测的代码}
 *catch{处理异常的代码}
 *finally{一定会执行的代码}
 *有三种格式：
 *1.try{} catch{}
 *2.try{} catch{} finally{}   注意：1.finally中定义的通常是关闭资源代码。因为资源必须释放。
 *3.try{} finally{}				  2.finally只有一种情况不会执行。当执行到System.exit(0);finally不会执行。
 *
 *自定义异常：
 *自定义继承Exception或者RuntimeException
 *1.为了让该自定义具备 可抛性
 *2.让该类具备操作异常的共性方法。
 *当要定义自定义异常的信息时，可以使用父类已经定义好的功能。
 *异常信息传递给父类的构造函数。
 *	class MyException extends Exception
 *		{
 *			NyException(String message)
 *			{
 *			super(message);
 *			}
 *		}
 *自定义异常：按照Java的面向对象思想，将程序中出现的特有问题进行封装。 
 *
 *异常的好处：
 *1.将问题进行封装。
 *2.将正常流程代码和问题处理代码想分离，方便于阅读。
 *
 *异常处理原则：
 *1.异常处理原则：try或者throws。
 *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)
 *  {
 *      //对AExcception先处理。 
 *      throw new BException;
 *  } 比如：汇款的例子。
 *  
 *  异常的注意事项：
 *    在子父类覆盖时：
 *    1.子类抛出的异常必须是父类的异常的子类或者自己。
 *    2.如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。
 *
 *参阅例子：  老师用电脑上课  图形面积
 */

public class ExceptionSub {
	public static void main(String[] args) {
		System.out.println("hello world");
	}

}