栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Java异常详解

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Java异常详解

1.异常概述、体系 什么是异常?

异常是程序在“编译”或者“执行”的过程中可能出现的问题,比如:数组索引越界、空指针异常、 日期格式化异常,等…

注意: 语法错误不算在异常体系中。

为什么要学习异常?

异常一旦出现了,如果没有提前处理,程序就会退出JVM虚拟机而终止,研究异常并且避免异常,然后提前处理异常,体现的是程序的安全, 健壮性。

异常体系

Error
系统级别问题、JVM退出等,代码无法控制。

Exception
java.lang包下,称为异常类,它表示程序本身可以处理的问题;

RuntimeException及其子类
运行时异常,编译阶段不会报错。 (空指针异常,数组索引越界异常)

除RuntimeException之外所有的异常
编译时异常,编译期必须处理的,否则程序不能通过编译。 (日期格式化异常)。

编译时异常和运行时异常

什么是异常?
         异常是程序在"编译"或者"执行"的过程中可能出现的问题。
         异常是应该尽量提前避免的。
         异常可能也是无法做到绝对避免的,异常可能有太多情况了,开发中只能提前干预!!
         异常一旦出现了,如果没有提前处理,程序就会退出JVM虚拟机而终止,开发中异常是需要提前处理的。

         研究异常并且避免异常,然后提前处理异常,体现的是程序的安全, 健壮性!!!
         Java会为常见的代码异常都设计一个类来代表。

    异常的体系:
         Java中异常继承的根类是:Throwable。

             Throwable(根类,不是异常类)
          /              
         Error           Exception(异常,需要研究和处理)
                        /            
                       编译时异常      RuntimeException(运行时异常)


         Error : 错误的意思,严重错误Error,无法通过处理的错误,一旦出现,程序员无能为力了,
            只能重启系统,优化项目。
            比如内存奔溃,JVM本身的奔溃。这个程序员无需理会。

         Exception:才是异常类,它才是开发中代码在编译或者执行的过程中可能出现的错误,
            它是需要提前处理的。以便程序更健壮!

    Exception异常的分类:
         1.编译时异常:继承自Exception的异常或者其子类,编译阶段就会报错,
                必须程序员处理的。否则代码编译就不能通过!!

         2.运行时异常: 继承自RuntimeException的异常或者其子类,编译阶段是不会出错的,它是在
                运行时阶段可能出现,运行时异常可以处理也可以不处理,编译阶段是不会出错的,
                但是运行阶段可能出现,还是建议提前处理!!
    小结:
        异常是程序在编译或者运行的过程中可能出现的错误!!
        异常分为2类:编译时异常,运行时异常。
            -- 编译时异常:继承了Exception,编译阶段就报错,必须处理,否则代码不通过。
            -- 运行时异常:继承了RuntimeException,编译阶段不会报错,运行时才可能出现。
        异常一旦真的出现,程序会终止,所以要研究异常,避免异常,处理异常,程序更健壮!!
常见运行时异常

直接继承自RuntimeException或者其子类,编译阶段不会报错,运行时可能出现的错误。

运行时异常示例

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。。。");
        
        int[] arr = {1, 2, 3};
        System.out.println(arr[2]);
        // System.out.println(arr[3]); // 运行出错,程序终止

        
        String name = null;
        System.out.println(name); // null
        // System.out.println(name.length()); // 运行出错,程序终止

        
        Object o = 23;
        // String s = (String) o;  // 运行出错,程序终止

        
        //int c = 10 / 0;

        
        //String number = "23";
        String number = "23aabbc";
        Integer it = Integer.valueOf(number); // 运行出错,程序终止
        System.out.println(it + 1);

        System.out.println("程序结束。。。。。");
    }
}
常见编译时异常

不是RuntimeException或者其子类的异常,编译阶就报错,必须处理,否则代码不通过。

编译时异常
继承自Exception的异常或者其子类,编译阶段报错,必须处理,否则代码不通过。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;


public class ExceptionDemo {
    public static void main(String[] args) throws ParseException {
        String date = "2015-01-12 10:23:21";
        // 创建一个简单日期格式化类:
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
        // 解析字符串时间成为日期对象
        Date d = sdf.parse(date);
        //
        System.out.println(d);
    }
}

2.异常的默认处理流程

1.默认会在出现异常的代码那里自动的创建一个异常对象:ArithmeticException;
2.异常会从方法中出现的点这里抛出给调用者,调用者最终抛出给JVM虚拟机;
3.虚拟机接收到异常对象后,先在控制台直接输出异常栈信息数据;
4.直接从当前执行的异常点干掉当前程序;
5.后续代码没有机会执行了,因为程序已经结束。

小结:
异常一旦出现,会自动创建异常对象,最终抛出给虚拟机,虚拟机,只要收到异常,就直接输出异常信息,干掉程序。
默认的异常处理机制并不好,一旦真的出现异常,程序立即结束。

public class ExceptionDemo {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。。。。。。。");
        chu(10, 0);
        System.out.println("程序结束。。。。。。。。。。");
    }

    public static void chu(int a , int b){
        System.out.println(a);
        System.out.println(b);
        int c = a / b;
        System.out.println(c);
    }
}
3.编译时异常的处理机制

编译时异常是编译阶段就出错的,所以必须处理,否则代码根本无法通过。

编译时异常的三种处理形式

1.出现异常直接抛出去给调用者,调用者也继续抛出去;
2.出现异常自己捕获处理;
3.前两者结合,出现异常直接抛出去给调用者,调用者捕获处理;

异常处理方式1 —— throws

throws:
用在方法上,可以将方法内部出现的异常抛出去给本方法的调用者处理。

这种方式并不好,发生异常的方法自己不处理异常,如果异常最终抛出去给虚拟机将引起程序结束。

抛出异常格式

方法 throws 异常1 ,异常2 ,异常3 ..{
	//方法体
}

//Exception代表可以抛出一切异常。
方法 throws Exception{ 
}

代码示例

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class ExceptionDemo01 {

//    public static void main(String[] args) throws ParseException, FileNotFoundException {
//        System.out.println("程序开始。。。。。");
//        parseTime("2011-11-11 11:11:11");
//        System.out.println("程序结束。。。。。");
//    }
//
//    public static void parseTime(String date) throws ParseException, FileNotFoundException {
//        SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
//        Date d = sdf.parse(date);
//        System.out.println(d);
//
//        InputStream is = new FileInputStream("E:/meinv.jpg");
//    }

    public static void main(String[] args) throws Exception {
        System.out.println("程序开始。。。。。");
        parseTime("2011-11-11 11:11:11");
        System.out.println("程序结束。。。。。");
    }

    public static void parseTime(String date) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);

        InputStream is = new FileInputStream("E:/meinv.jpg"); //多个异常遇到其中一个就结束了
    }

}
异常处理方式2 —— try…catch…

监视捕获异常,用在方法内部,可以将方法内部出现的异常直接捕获处理,发生异常的方法自己独立完成异常的处理,程序可以继续往下执行。

语法格式

try{
       // 监视可能出现异常的代码!
}catch(异常类型1 变量){
       // 处理异常
}catch(异常类型2 变量){
       // 处理异常
}...

//建议格式
try{
    // 可能出现异常的代码!
}catch (Exception e){
    e.printStackTrace(); // 直接打印异常栈信息
}
//Exception可以捕获处理一切异常类型!

代码示例

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;


public class ExceptionDemo02 {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。");
        parseTime("2011-11-11 11:11:11");
        System.out.println("程序结束。。。。");
    }

    public static void parseTime(String date) {
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
            Date d = sdf.parse(date);
            System.out.println(d);

            InputStream is = new FileInputStream("E:/meinv.jpg");
        } catch (Exception e) {
            e.printStackTrace(); // 打印异常栈信息
        }
    }


//    public static void parseTime(String date) {
//        try {
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
//            Date d = sdf.parse(date);
//            System.out.println(d);
//
//            InputStream is = new FileInputStream("E:/meinv.jpg");
//        } catch (FileNotFoundException|ParseException e) {
//            e.printStackTrace(); // 打印异常栈信息
//        }
//    }

//    public static void parseTime(String date) {
//        try {
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
//            Date d = sdf.parse(date);
//            System.out.println(d);
//
//            InputStream is = new FileInputStream("E:/meinv.jpg");
//        } catch (FileNotFoundException e) {
//           e.printStackTrace(); // 打印异常栈信息
//        } catch (ParseException e) {
//           e.printStackTrace();
//        }
//    }

//    public static void parseTime(String date) {
//        try {
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM-dd HH:mm:ss");
//            Date d = sdf.parse(date);
//            System.out.println(d);
//        } catch (ParseException e) {
//            // 解析出现问题
//            System.out.println("出现了解析时间异常哦,走点心!!");
//        }
//
//        try {
//            InputStream is = new FileInputStream("E:/meinv.jpg");
//        } catch (FileNotFoundException e) {
//            System.out.println("您的文件根本就没有啊,不要骗我哦!!");
//        }
//    }
}
异常处理方式3

1.方法直接将异通过throws抛出去给调用者;
2.调用者收到异常后直接捕获处理;

在开发中按照规范来说第三种方式是最好的:底层的异常抛出去给最外层,最外层集中捕获处理。

实际应用中,只要代码能够编译通过,并且功能能完成,那么每一种异常处理方式似乎也都是可以的。

代码示例

import java.io.FileInputStream;
import java.io.InputStream;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;


public class ExceptionDemo03 {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。");
        try {
            parseTime("2011-11-11 11:11:11");
            System.out.println("功能操作成功~~~");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("功能操作失败~~~");
        }
        System.out.println("程序结束。。。。");
    }

    public static void parseTime(String date) throws Exception {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy、MM-dd HH:mm:ss");
        Date d = sdf.parse(date);
        System.out.println(d);

        InputStream is = new FileInputStream("D:/meinv.jpg");
    }

}
4.运行时异常的处理机制

运行时异常编译阶段不会出错,是运行时才可能出错的,所以编译阶段不处理也可以。

建议在最外层调用处集中捕获处理即可。

代码示例

public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始。。。。。。。。。。");
        try {
            chu(10, 0);
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("程序结束。。。。。。。。。。");
    }

    public static void chu(int a , int b) { // throws RuntimeException{
        System.out.println(a);
        System.out.println(b);
        int c = a / b;
        System.out.println(c);
    }
}
5.自定义异常

自定义异常的必要
1.Java无法为这个世界上全部的问题提供异常类;
2.如果企业想通过异常的方式来管理自己的某个业务问题,就需要自定义异常类了;

自定义异常的好处
1.可以使用异常的机制管理业务问题,如提醒程序员注意;
2.同时一旦出现bug,可以用异常的形式清晰的指出出错的地方;

自定义编译时异常

1.定义一个异常类继承Exception;
2.重写构造器;
3.在出现异常的地方用throw new 自定义对象抛出;

作用
编译时异常是编译阶段就报错,提醒更加强烈,一定需要处理。

自定义运行时异常

1.定义一个异常类继承RuntimeException;
2.重写构造器;
3.在出现异常的地方用throw new 自定义对象抛出;

作用
提醒不强烈,编译阶段不报错!!运行时才可能出现。

代码示例

ExceptionDemo.java

public class ExceptionDemo {
    public static void main(String[] args) {
//        try {
//            checkAge(-34);
//        } catch (ItheimaAgeIlleagalException e) {
//            e.printStackTrace();
//        }

        try {
            checkAge2(-23);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void checkAge2(int age)  {
        if(age < 0 || age > 200){
            // 抛出去一个异常对象给调用者
            // throw :在方法内部直接创建一个异常对象,并从此点抛出
            // throws : 用在方法申明上的,抛出方法内部的异常
            throw new ItheimaAgeIlleagalRuntimeException(age + " is illeagal!");
        }else {
            System.out.println("年龄合法:推荐商品给其购买~~");
        }
    }

    public static void checkAge(int age) throws ItheimaAgeIlleagalException {
        if(age < 0 || age > 200){
            // 抛出去一个异常对象给调用者
            // throw :在方法内部直接创建一个异常对象,并从此点抛出
            // throws : 用在方法申明上的,抛出方法内部的异常
            throw new ItheimaAgeIlleagalException(age + " is illeagal!");
        }else {
            System.out.println("年龄合法:推荐商品给其购买~~");
        }
    }
}

ItheimaAgeIlleagalException.java

public class ItheimaAgeIlleagalException extends Exception{
    public ItheimaAgeIlleagalException() {
    }

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

ItheimaAgeIlleagalRuntimeException.java

public class ItheimaAgeIlleagalRuntimeException extends RuntimeException{
    public ItheimaAgeIlleagalRuntimeException() {
    }

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

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/970600.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号