异常

异常

概念

在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如：客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。

就是执行过程中遇到的错误,不包含代码编译错误.

Java 异常可以分为两类:
1.Error:程序不能处理的,会抛出错误,程序控制不了 如 JVM系统内部错误、内存不够用等严重情况。
2.Exception:运行时,由于各种原因导致,程序不能正常运行，通过异常处理机制可以处理. 如:空指针异常,网络中断,试图读取不存在的文件等

解决方法:
1.遇到异常就终止程序
2.预先考虑会遇到的异常并且设定办法处理.

异常的体系

Throwable类有两个直接子类：Exception类、Error类。Error表示错误，可能是编译期错误或者系统错误，往往程序中并不处理。Exception表示异常，是所有异常类的父类，是程序员所关心的。

异常分为运行期异常与编译器异常两种
运行期异常:程序运行时出现的异常，RuntimeException的所有子类都是运行期异常

public class ExceptionDemo {
    public static void main(String[] args) {
        //异常:数组下标越界异常  ArrayIndexOutOfBoundsException
       int [] a=new int[4];
        a[5]=10;       /** //*Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5 异常类型
        at com.ff.javaexcption.day1.ExcptionDemo.main(ExcptionDemo.java:7)   异常位置*/

        //算数条件异常  ArithmeticException
/*        int a=1;
        int b=0;   //根本异常原因
        System.out.println(a/b);  //异常位置*/

        //抛出表示代码尝试将对象转换为不属于实例的子类   强制类型转换异常 ClassCastException
/*      String s="123";
        Object object=s;
        Integer s1= (Integer) object;*/

        //当应用程序尝试在需要对象的情况下使用null时抛出  ,空指针异常 NullPointerException
/*       String ss=null;
       ss.length();*/

/*         //NumberFormatException  格式化异常
       int i=Integer.parseInt("wsa");*/
    }
}

编译器异常:在编译期间提示要处理的.如IOException,SQLException

public class ExceptionDemo {
    public static void main(String[] args) {
        int a1=9999999999999;
    }
}

异常处理

java默认的异常处理方式:在控制台抛出对应类型的异常类现象.

Java的异常处理是通过5个关键字来实现的：try、catch、 finally、throw、throws

捕获异常

try{
可能会发生异常的代码
}catch(异常类型 引用名){
异常处理代码
}finally{
必须执行代码
}

try

用来检测代码块是否异常,try中如果有语句块出现异常,那么try中异常语句后面的代码就不会执行,程序会去执行catch块,

catch

把抓到的类型匹配的异常捕获，保证程序能继续运行下去,catch可以对try中出现的异常进行处理,与其它对象一样，可以访问一个异常对象的成员变量或调用它的方法.

getMessage() 获取异常信息，返回字符串
printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

finally

finally中是总会执行的语句,无论是否异常.

finally的一些方法

public class ExceptionDemo6 {
    public static void main(String[] args) {
        //System.out.println(test());//空指针  继续执行 0
        System.out.println(test());//继续执行  输出异常
        //System.out.println(test2());//空指针 继续执行 1
        }
    
//体现finally的作用 
    public static  int test(){
        try{
            String s=null;
            s.length();
        }/*catch (NullPointerException n){
            System.out.println("空指针");     //先执行finally 再return 0;
            return 0;
        }*/catch (NumberFormatException n){
            System.out.println("错误");
            return 0;
        }finally {
            System.out.println("继续执行");
        }
        System.out.println("aaaaa");
        return 1;
    }

    public static  int test2(){
        try{
            String s=null;
            s.length();
        }catch (NullPointerException n){
            System.out.println("空指针");
            return 0;
        }finally {
            System.out.println("继续执行");
            return 1;
        }
    }
}

throws

作为方法的声明,此方法可能出现异常,throws后面声明多个异常类型,多为编译期异常

例:public void test throws 异常1，异常2，异常3{

​ }

//任何方法都可以使用throws关键字声明异常类型，包括抽象方法。
//子类重写父类中的方法，子类方法不能声明抛出比父类类型更大的异常。
//使用了throws的方法，调用时必须处理声明的异常，要么使用try-catch，要么继续使用throws声明
public abstract class ExceptionDemo8  {
    public abstract void  a1() throws NumberFormatException;
    public abstract void  a2() throws NumberFormatException;
}




public class ExceptionDemo7   extends ExceptionDemo8{
    public static void main(String[] args) {
        try{
            chufa(6,0);
        }catch (ArithmeticException e){
            System.out.println("除数不能为0");
        }


        try {
            a("2000-20-20");         //编译期异常,必须得处理
        } catch (ParseException e) {
            e.printStackTrace();
            System.out.println("格式不正确");
        }
    }

    public static int chufa(int a, int b) throws  ArithmeticException{ //运行时异常,可处理可不处理
        return a/b;
    }

    public static void a(String s) throws ParseException {  //编译期异常,必须得处理
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat();
        simpleDateFormat.parse(s);
    }

    @Override
    public void a1() throws NumberFormatException {

    }

    @Override
    public void a2() throws NumberFormatException {
    }
}

throw

在方法中主动抛出异常,相当于程序出现异常情况,后面的程序不执行,在不满足条件的情况下以抛出异常的形式告诉调用处

语法：throw throw new 异常类构造方法

public class ExceptionDemo9  {
    public static void main(String[] args)  {
/*
        try{
            s(101);
        }catch (NullPointerException e){
            System.out.println(e.getMessage());
        }
*/
        try {
            s1("11");
        } catch (ParseException e) {
            e.printStackTrace();
            System.out.println();
        }

    public  static  int s( int i) throws ScoreException  {
/*       if (i<0 | i>100){
           throw new NullPointerException();   //可以处理也可以不处理
       }
       return i;*/

//    public  static void s1( String s) throws ParseException {   //必须处理  或者 声明异常
//
//            throw new ParseException(s,s.length());
    }

自定义异常

就是自己定义的异常类,由于java中封装的异常类都与语法相关的,在我们业务中出现一些不满足条件的情况时,用自定义异常类来表示.

基本语法
public class 异常类名 extends Exception/RuntimeException{
public 异常类名(String msg){
super(msg);
}
}
自定义异常类中一般没有其他方法,只是重载需要使用的构造方法,

public class ScoreException extends Exception {
    public ScoreException() {
        super();
    }

    public ScoreException(String message) {
        super(message);
    }
}



public class ExceptionDemo9  {
    public static void main(String[] args)  {  //必须用throws抛出或者使用try-catch
        try {
            s(1001);
        } catch (ScoreException e) {
            e.printStackTrace();
            System.out.println(e.getMessage());
        }
    }
public  static  int s( int i) throws ScoreException  {
        if (i<0 | i>100){
            throw new ScoreException("成绩不正确");
        }
        return i;
    }
    }

throws.throw与自定义异常的区别

throws:作为方法的声明,此方法可能出现异常,throws后面声明多个异常类型,多为编译期异常,

throw:在方法中主动抛出异常,相当于程序出现异常情况,后面的程序不执行,在不满足条件的情况下以抛出异常的形式告诉调用处.

自定义异常:由于java中封装的异常类都与语法相关的,在我们业务中出现一些不满足条件的情况时,用自定义异常类来表示.