异常及其关键字

Java高级部分

学习jdk 中的类，学习类的方法，怎么创建类

常用的

异常：（意外）程序没有语法错误，可能产生运行时的错误

语法错误：--->编译错误

异常产生的原因：

1. 程序员编程出现的错误，数组越界，逻辑问题

2. 用户不正当操作（程序员要有相关的处理方式）

异常的分类：

 

错误：Error

如果应用程序出现了Error，那么将无法恢复，只能重新启动应用程序，最典型的Error的异常是：OutOfMemoryError

一般性异常（受控异常，编译时）：checkedException

当前方法知道如何处理该异常)，则用try...catch来处理该异常

出现了这种异常必须显示的处理，不显示处理java程序将无法编译通过。编译器强制普通异常必须try…catch处理，或用throws声明继续抛给上层调用方法处理，所以普通异常也称为checked异常。

运行时的异常（非受控异常，运行时）：UncheckedException

非受控异常也即是运行时异常（RuntimeException），这种系统异常可以处理也可以不处理，所以编译器不强制用try…catch处理或用throws声明，所以系统异常也称为unchecked异常。

此种异常可以不用显示的处理，例如被0除异常，java没有要求我们一定要处理， 当出现这种异常时，肯定是程序员的问题，也就是说，健壮的程序一般不会出现这种系统异常

异常处理：

运行时的异常（系统异常）：不需要预处理，通过规范代码可以避免

受检异常（编译异常）：必须预处理，否则编译报错，有两种预处理方式

1. 捕获处理

   1.try,catch,finally:

   异常的捕获和处理需要采用try和catch来处理：

    try {
    ​
    }catch (OneException  e){
     
    }catch (TwoException) {
     
    }finally {
     
    }

   1. try中包含了可能产生异常的代码

   2. try后面是catch，catch可以有一个或多个，catch中是需要捕获的异常

   3. 当try中的代码出现异常，下面的代码不会执行，马上会跳转到相应的catch语句中，如果没有异常不会跳转到catch中

               

   写多个catch，先子类后父类

   JDK1.8把多个catch折合在一起，这些异常类型

   catch匹配的原则：从上往下

   finally表示，不管是出现异常或是没有，它里面的代码都执行，finally可以与catch分开使用，但finally必须和try一块使用，如：

                

    try {
        
    }finally{
        
    }

   final：修饰方法，属性，变量，类

   finally：最终地

    finally{
     
    }

   如果语句既有return又有finally，finally中的代码在return之前执行

   2.异常捕获处理：

   ---

   private static void testException() {
         try {
             //1、对可能产生异常的代码进行检视
             //2、如果try代码块的某条语句产生了异常, 就立即跳转到catch子句执行, try代码块后面的代码不再执行
             //3、try代码块可能会有多个受检异常需要预处理, 可以通过多个catch子句分别捕获
         } catch (异常类型1 e1) {
             //捕获异常类型1的异常, 进行处理
             //在开发阶段, 一般的处理方式要么获得异常信息, 要么打印异常栈跟踪信息(e1.printStackTrace())
             //在部署后, 如果有异常, 一般把异常信息打印到日志文件中, 如：logger.error(e1.getMessage());
         } catch (异常类型2 e2) {
             //捕获异常类型2的异常, 进行处理
             //如果捕获的异常类型有继承关系, 应该先捕获子异常再捕获父异常
             //如果没有继承关系, catch子句没有先后顺序
         } finally {
             //不管是否产生了异常, finally子句总是会执行
             //一般情况下, 会在finally子句中释放系统资源
         }
     }
    ​

2. 抛出处理(throw和thows)

3. throw： throw 关键字主动抛出异常。

   throw 异常对象；//写在方法体，抛出一个异常对象 //替换return

   执行 throw 抛出了一个异常， 结束方法

4. throws： throws 关键字用于声明异常。

   throw 异常类1，异常类2，..... //写在方法签名，声明该方法可能抛出什么类型的异常

细节：

如果throw 异常对象，若异常对象类型是非RuntimeException异常，一定在方法内使用throws声明。

若为RuntimeException异常或子类，可用也不可用声明

如果方法调用其他代码（方法），其他代码，给我们抛了一个异常

1. 使用try-catch 处理异常

2. 在方法上使用throws 异常处理，继续往上抛，异常可以一直往上抛，都不处理，只能交给JVM处理，JVM处理方式：中断执行代码，直接在控制台输出异常堆栈信息

重写方法声明抛出异常的原则

1. 重写方法不能抛出比重写方法范围更大的异常类型

   public class A {
        public void methodA() throws IOException{
            ....
        }
    }
    public class B1 extends A {
        public void methodA() throws FileNotFoundException {
            ...
        }
    }
    public class B2 extends A {
        public void methodA() throws Exception { //error
            
        }
    }

自定义异常

---

根据业务需要，自定义一个异常类

步骤：

1. 编写一个类 规范：xxxException

2. 类继承Java.lang.Exception或者子类

3. 根据父类的构造方法生成本类的的构造方法

4. 在业务代码中，使用throw new 自定义异常类()

实例：

---

1. 创建

   用户自定义异常类Myception，用于描述数据取值范围错误信息，用户自己的异常类必须继承现有的异常类。

   class MyException extends Exception {
            private int idnumber ;
            public MyException(String message,int id{
                       super (message) ;
                       this.idnumber = id;
            }
            public int getId( {
                    return idnumber;
            )
    }

2. 使用

    public class Test{
        public void regist(int num) throws MyException {
            if (num <o)
                    throw new MyException("人数为负值，不合理",3);
            else
                    System.out.println("登记人数"+num);
        }
    public void manager() {
            try {
                    regist(100);
            }catch (MyException e){
                    System.out.print("登记失败，出错种类"+e.getId());
            }
            System.out.print("本次登记操作结束");
       }
       public static void main(String args[]){
             Test =new Test();
             t.manager();
       }
    }
    ​