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 {//自定义异常，继承RuntimeExceptionNoValueException(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");}}