ThinkInJava_12_异常

最新推荐文章于 2023-07-26 20:08:43 发布
最新推荐文章于 2023-07-26 20:08:43 发布
阅读量98 收藏
点赞数
分类专栏： thinkinjava
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gosick_/article/details/108719042
版权

12.1 概念

12.2 基本异常

throw new NullPointerException("t = null");
  • 可以抛出任意类型的 Throwable 对象，它是异常类型的根类

12.3 捕获异常

try {
	
} catch(Type1 id1) {
	
} catch(Type2 id2) {
	
}

终止与恢复

  • 终止模型，认为错误非常关键，以至于程序无法返回到异常发生的地方继续执行，一旦异常被抛出，就表明错误已无法挽回，也不能回来继续执行
  • 恢复模型，认为异常处理的工作是修正错误，然后重新尝试调用出问题的方法，并认为第二次能成功，希望异常被处理完后能够继续执行程序

12.4 创建自定义异常

class SimpleException extends Exception {} //自定义异常
public class InheritingExceptions {
    public void f() throws SimpleException {
        System.out.println("Throw SimpleException from f()");
        throw new SimpleException(); //抛出异常
    }
    public static void main(String[] args) {
        InheritingExceptions sed = new InheritingExceptions();
        try {
            sed.f();
        } catch (SimpleException e) { //捕获异常
            System.out.println("Caught it!");
        }
    }
}
/*
Throw SimpleException from f()
Caught it!
*/

e.printStackTrace(System.out); //打印从方法调用处到异常抛出处的方法调用序列

import java.util.logging.*;
import java.io.*;
//通过异常输出日志
class LoggingException extends Exception {
    //与String相关的Logger对象，将其输出发送到System.err
    private static Logger logger =
            Logger.getLogger("LoggingException");
    public LoggingException() {
        StringWriter trace = new StringWriter();
        printStackTrace(new PrintWriter(trace));
        logger.severe(trace.toString());
    }
}
public class LoggingExceptions {
    public static void main(String[] args) {
        try {
            throw new LoggingException();
        } catch (LoggingException e) {
            System.err.println("Caught " + e);
        }
        try {
            throw new LoggingException();
        } catch (LoggingException e) {
            System.err.println("Caught " + e);
        }
    }
}
/*
九月 21, 2020 10:01:13 下午 learn.LoggingException <init>
严重: learn.LoggingException
	at learn.LoggingExceptions.main(LoggingExceptions.java:16)

Caught learn.LoggingException
九月 21, 2020 10:01:13 下午 learn.LoggingException <init>
严重: learn.LoggingException
	at learn.LoggingExceptions.main(LoggingExceptions.java:21)

Caught learn.LoggingException
 */
  • 必须在异常处理程序中生成日志信息

12.5 异常说明

  • 要告知客户端程序员某个方法可能抛出异常的类型，它属于方法声明的一部分
void f() throws TooBig,TooSmall,DivZero {}
  • 说明中抛出的异常必须在方法中写出异常的处理，即try {} catch {}结构

12.6 捕获所有异常

catch(Exception e) {}

//可以调用它从基类 Throwable 中继承的方法
String getMessage();
String getLocalizedMessage()

void printStackTrace()
void printStackTrace(PrintStream)
void printStackTrace(java.io.PrintWriter)

public class ExceptionMethods {
    public static void main(String[] args) {
        try {
            throw new Exception("My Exception");
        } catch(Exception e) {
            System.out.println("Caught Exception");
            System.out.println("getMessage():" + e.getMessage());
            System.out.println("getLocalizedMessage():" + e.getLocalizedMessage());
            System.out.println("toString():" + e);
            System.out.println("printStackTrace():");
            e.printStackTrace(System.out);
        }
    }
}
/*
Caught Exception
getMessage():My Exception
getLocalizedMessage():My Exception
toString():java.lang.Exception: My Exception
printStackTrace():
java.lang.Exception: My Exception
	at learn.ExceptionMethods.main(ExceptionMethods.java:6)
*/

public class WhoCalled {
    static void f() {
        try {
            throw new Exception();
        } catch (Exception e) {
            //e.getStackTrace() 获取由栈轨迹元素构成的数组
            for(StackTraceElement ste : e.getStackTrace())
                System.out.println(ste.getMethodName());
        }
    }
    static void g() { f(); }
    static void h() { g(); }
    public static void main(String[] args) {
        f();
        System.out.println("--------------------------------");
        g();
        System.out.println("--------------------------------");
        h();
        System.out.println("--------------------------------");
    }
}
/*
f
main
--------------------------------
f
g
main
--------------------------------
f
g
h
main
--------------------------------
 */

catch(Exception e) {
	throw e;
}
//重新抛出异常，把异常信息抛给上一级环境中的异常处理程序

package learn;

public class Rethrowing {
    public static void f() throws Exception {
        System.out.println("originating the exception in f()");
        throw new Exception("thrown from f()");
    }
    public static void g() throws Exception {
        try {
            f();
        } catch(Exception e) {
            System.out.println("Inside g(),e.printStackTrace");
            e.printStackTrace();
            throw (Exception)e.fillInStackTrace();
        }
    }
    public static void h() throws Exception {
        try {
            f();
        } catch(Exception e) {
            System.out.println("Inside h(),e.printStackTrace");
            e.printStackTrace();
            throw (Exception)e.fillInStackTrace();
        }
    }
    public static void main(String[] args) {
        try {
            g();
        } catch(Exception e)  {
            System.out.println("main: printStackTrace()");
            e.printStackTrace();
        }
        try {
            h();
        } catch(Exception e)  {
            System.out.println("main: printStackTrace()");
            e.printStackTrace();
        }
    }
}
/*
originating the exception in f()
Inside g(),e.printStackTrace
main: printStackTrace()
originating the exception in f()
Inside h(),e.printStackTrace
main: printStackTrace()
java.lang.Exception: thrown from f()
	at learn.Rethrowing.f(Rethrowing.java:6)
	at learn.Rethrowing.g(Rethrowing.java:10)
	at learn.Rethrowing.main(Rethrowing.java:28)
java.lang.Exception: thrown from f()
	at learn.Rethrowing.g(Rethrowing.java:14)
	at learn.Rethrowing.main(Rethrowing.java:28)
java.lang.Exception: thrown from f()
	at learn.Rethrowing.f(Rethrowing.java:6)
	at learn.Rethrowing.h(Rethrowing.java:19)
	at learn.Rethrowing.main(Rethrowing.java:34)
java.lang.Exception: thrown from f()
	at learn.Rethrowing.h(Rethrowing.java:23)
	at learn.Rethrowing.main(Rethrowing.java:34)
 */
  • 只是抛出当前异常，printStackTrace将显示原来异常抛出点的调用栈信息，可以调用fillStackTrace方法更新异常信息为重新抛出点的信息
  • 调用fillStackTrace的那一行就变成新的异常发生地了
  • 异常链，在捕获一个异常后抛出另一个异常
Error(cause)
Exception(cause)
RuntimeException(cause)
initCause()

public Object setField(String id,Object value) throws MyException {
	if(value == null) {
		MyException me = 
		new MyException();
		me.initCause(new YourException());
		//通过initCause()把YourException异常对象插入
		throw me;
	}
}

catch(NoSuchFieldException e) {
	throw new RuntimeException(e);
	//使用RuntimeException()构造器把NoSuchFieldException异常转换成RuntimeException异常
}

12.7 Java标准异常

  • RuntimeException 运行时异常不必手动抛出
  • RuntimeException 没有被捕获而直接直达 main ，程序退出前会自动调用 printStackTrace()

12.8 使用 finally 进行清理

try {
} catch() {
} catch() {
} finally {
//这里的代码一定会执行，无论异常是否抛出
}
  • 当要把除内存之外的资源恢复到初始状态的时候，就要用finally，如已打开的文件或绘制的图形
  • 即使在 try { return; } 中有return 语句，也能执行 finally 的清理工作
  • 在 finally 中抛出异常，可能会覆盖 try 中抛出的异常，从而无法在 catch 中捕获异常，这是 Java 的语言缺陷

12.9 异常的限制

class BaseballException extends Exception {}
class Foul extends BaseballException {}
class Strike extends BaseballException {}
abstract class Inning {
    public Inning() throws BaseballException {}
    public void event() throws BaseballException {
        //没有真的抛出异常
    }
    public abstract void atBat() throws Strike,Foul;
    public void walk() {} //不抛出受检查的异常
}
class StormException extends Exception {}
class RainedOut extends StormException {}
class PopFoul extends Foul {}

interface Storm {
    public void event() throws RainedOut;
    public void rainHard() throws RainedOut;
}

public class StormyInning extends Inning implements Storm {
    //构造器可以增加新的异常，但必须处理基类异常 BaseballException
    public StormyInning()
        throws RainedOut,BaseballException {}
    public StormyInning(String s)
        throws Foul,BaseballException {}
    //普通方法必须按照基类抛出异常，不能添加
    //void walk() throws  PopFoul {}
    //接口不能向基类中已存在的方法中添加异常
    //public void event() throws RainedOut {}
    //即使基类中有异常，你也可以不抛出异常
    public void event() {}
    //覆盖的方法可以抛出继承的异常
    public void atBat() throws PopFoul {}
    public static void main(String[] args) {
        try {
            //导出类
            StormyInning si = new StormyInning();
            si.atBat();
        } catch(PopFoul e) {
            System.out.println("Pop Foul");
        } catch(RainedOut e) {
            System.out.println("Rained Out");
        } catch(BaseballException e) {
            System.out.println("Baseball Exception");
        }
        try {
            //基类
            Inning i = new StormyInning();
            i.atBat();
        } catch(Strike e) {
            System.out.println("Strike");
        } catch(Foul e) {
            System.out.println("Foul");
        } catch(RainedOut e) {
            System.out.println("RainedOut");
        } catch(BaseballException e) {
            System.out.println("Baseball Exception");
        }
    }
}
  • 声明抛出的异常实际可以不抛出
  • 接口中有和基类中相同的方法，则在导出类中该方法不能抛出新的异常
  • 如果接口中抛出的异常不是来自基类，则没有限制添加新的异常
  • 异常限制对构造器不起作用，派生类构造器的异常必须包含基类构造器的异常说明，派生类构造器不能捕获基类抛出的异常
  • 派生类普通方法抛出了异常，基类中没有抛出，就会发生编译错误
  • 覆盖后的方法可以不抛出任何异常
  • main 中，如果处理派生类对象，则只要处理这个类声明的异常，如果声明为基类，则要求处理捕获基类的异常

12.10 构造器

import java.io.*;

public class InputFile {
    private BufferedReader in;
    public InputFile(String fname) {
        try {
            in = new BufferedReader(new FileReader(fname));
        } //这里是打开文件错误，不需要关闭文件
            catch (FileNotFoundException e) {
            //throw e;
        } //其他类型的错误则必须关闭文件
            catch (Exception e) {
            try {
                in.close();
            } catch (IOException e) {

            }
            throw e;
        }
    }
    public String getLine() {
        String s;
        try {
            s = in.readLine();
        } catch (IOException e) {
            //将读行错误异常转化为一个RuntimeException,表示一个编程错误
            throw new RuntimeException("readLine() failed");
        }
        return s;
    }
    public void dispose() {
        try {
            in.close();
        } catch(IOException e) {
            throw new RuntimeException("in.close() failed");
        }
    }
}

12.11 异常匹配

  • 抛出异常，会匹配最近的处理程序
  • 派生类异常也可以匹配基类的处理程序
class BException extends Exception {}
class DException extends BException {}
public class Human {
    public static void main(String[] args) {
        try {
            throw new DException();
        } catch(DException e) {
            System.out.println("DException");
        } catch(Exception e) {
            System.out.println("Exception");
        }

        try {
            throw new DException();
        } catch(BException e) {
            System.out.println("BException");
        }
    }
}
/*
DException
BException
 */

12.12 其他可选方式

  • 只有在你知道如何处理的时候才抛出异常
    （1）受检查的异常：这种在编译时被强制检查的异常称为"受检查的异常"。即在方法的声明中声明的异常。
    （2）不受检查的异常：在方法的声明中没有声明，但在方法的运行过程中发生的各种异常被称为"不被检查的异常"。这种异常是错误，会被自动捕获。
    为了保证程序健壮性
  • 必须要有一致的，使用异常来报告错误的模型
  • 必须要有类型检查，不管是在编译期间还是运行期间
public static void main(String[] args) throws Exception {}
//在main中添加Exception异常说明，通过把它传递到控制台，就不必在main中写try-catch语句了

12.13 异常使用指南

1）在恰当的级别处理
2）解决问题并且重新调用产生异常的方法
3）进行少量的修补，然后绕过异常发生的地方继续执行
4）用别的数据进行计算，以替代方法预计会返回的值
5）把当前运行环境下能做的事情做完，然后把相同的异常抛到更高层
6）把当前运行环境下能做的事情做完，然后把相同的异常抛到更高层
7）终止程序
8）进行简化
9）让类库和程序更安全

十年水流东
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot异常处理
剪刀手何金银的技术博客
11-14 770
异常 类似于springboot大部分的设计，当有异常发生时，springboot会在底层寻找所有的类型为HandlerExceptionResolver的组件来处理异常,核心源码： // Check registered HandlerExceptionResolvers... ModelAndView exMv = null; if (this.handlerExceptionResolvers != null) { for (HandlerExceptionResolver reso
基于SpringMVC的异常处理
m0_58615792的博客
05-26 117
一. 异常处理的思路 系统中的异常分为两类： 编译期异常，通过try...catch捕获异常，从而获取异常信息 运行期异常RuntimeException，通过规范代码开发、测试等手动，减少运行时异常的发生 系统开发中处理异常的思路： 注意：实际开发中，大多数的异常都可以直接抛。但是有少数情况，需要try..catch：service层的事务管理。 如果没有使用Spring帮我们管理事务的话，即我们自己处理事务，就必须try..catch 如果使用了Sp...
spring mvc 事务配置+异常处理
iteye_18362的博客
03-05 191
在http://gary-bu.iteye.com/blog/2024022  中我们了解了如何配置一个springmvc,如何在spring配置文件中配置一个dbcp数据源,在web.xml配置上下文监听器,分发器,视图解析器等,而这篇主要看一下如何在上次的基础上配置事务. spring事务分声明式事务和编程式事务,我们今天主要说一下声明式事务,spirng的事务是通过AOP代理实现的,其...
springMVC--异常处理
最新发布
m0_73557631的博客
07-26 942
Spring MVC 通过HandlerExceptionResolver 处理程序的异常，包括Handler 映射、数据绑定以及目标方法执行时发生的异常。主要处理Handler 中用@ExceptionHandler 注解定义的方法。ExceptionHandlerMethodResolver 内部若找不到@ExceptionHandler 注解的话， 会找@ControllerAdvice 类的@ExceptionHandler 注解方法, 这样就相当于一个全局异常处理器。
SpringMvc自定义拦截器和全局异常处理器
法毅的博客
01-16 264
拦截请求，常用的就是没登陆的时候，跳砸昏登陆页面。我们这里模拟一下，只让他走登陆接口。 新建拦截器实现HandlerInterceptor 接口，实现三个方法，一般只用第一个就好。 public class AuthorInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse respons.
Thinking_in_Java_4th_Edition_thinkinjava4pdf_
09-30
《Thinking in Java》是Bruce Eckel的经典之作，第四版（thinkinjava4pdf）为许多Java程序员和学习者提供了深入理解这门语言的宝贵资源。这本书以其详尽的解释、丰富的示例和全面覆盖Java核心概念而著名。尽管标题...
ThinkinJava
03-18
3. **异常处理**：介绍如何使用try-catch-finally语句块来捕获和处理程序运行时可能出现的错误，确保程序的健壮性。 4. **集合框架**：详述了ArrayList、LinkedList、HashSet、HashMap等集合类的使用，以及泛型、...
thinkinjava4源码-Thinking_in_java_4th:java编程思想4
05-20
12. **设计模式**：书中涵盖了多种设计模式，如工厂模式、单例模式、观察者模式等，这些都是解决常见问题的成熟解决方案。 通过这个源码库，读者可以跟随书中的章节逐步实践，加深对Java编程的理解。同时，这也是一...
ThinkinJava.pdf
04-23
3. **异常处理**：Java中的异常处理是程序健壮性的重要部分，书中有专门章节介绍如何使用try-catch-finally结构来捕获和处理异常。 4. **集合框架**：Java集合框架包括List、Set、Map等接口和其实现类，如ArrayList...
springmvc之异常处理（包含处理步骤）
快乐学习
02-26 1281
这个注解是异常注解，放在类上面，代表这个类统一处理异常，是rest开头的，代表处理rest风格的异常，基于AOP思想，所以又含有advice，通常配合@ExceptionHandler使用，这个异常代表指定要拦截哪些异常。：设置异常指定的处理方案，功能等同于控制器方法，出现异常后终止原始控制器执行，并转入当前的方法执行。（4）表现层抛出的异常：因数据收集、校验等规矩导致（例如：不匹配的数据类型间导致异常）（3）业务层抛出的异常：因业务逻辑书写错误导致（遍历业务书写操作，导致索引异常等）
springboot项目处理异常流程
睡竹的博客
03-20 818
springboot项目处理异常流程
Java编程思想读书笔记——通过异常处理错误(二)
mengzm的博客
10-22 277
12.7 Java标准异常 Throwable可以表示任何作为异常被抛出的类，其可分为两类对象：Error和Exception。 Error表示编译时和系统错误，一般不需关心； Exception表示可以被抛出的基本类型，通常关心该类型。 异常的名称都是可以望文知意的。 12.7.1 特例：RuntimeException 运行时异常由Java虚拟机自动抛出，不必在异常说明中列出，
全局事务处理+ 异常处理 springboot
pingzhuyan的博客
01-05 1094
1. 全局事务处理 @Transactional(rollbackFor= RuntimeException.class) 默认就是拦截运行时异常 下面是不拦截运行时异常 通常是不需要写的 2. 全局异常处理 package sso.exception; import lombok.extern.slf4j.Slf4j; import org.springframework.web.bind.annotation.ExceptionHandler; import org.sprin...
SpringBoot-异常处理
爱笑的boy的博客
08-13 1056
SpringBoot-异常处理
Springboot全局异常处理
程序三两行
11-26 3566
springboot默认发生4xx错误时候，pc端响应的页面如下如果是移动端（手机端）将会响应json格式的数据，如下。
SpringBoot实现自定义异常类。
weixin_60414376的博客
02-06 7655
SpringBoot异常类创建与简化返回给前端的异常消息
SpringBoot错误处理机制以及自定义异常处理
热门推荐
不清不慎的博客
04-10 2万+
上篇文章我们讲解了使用Hibernate Validation来校验数据，当校验完数据后，如果发生错误我们需要给客户返回一个错误信息，因此这节我们来讲解一下SpringBoot默认的错误处理机制以及如何自定义异常来处理请求错误。 一、SpringBoot默认的错误处理机制 我们在发送一个请求的时候，如果发生404 SpringBoot会怎么处理呢？我们来发送一个不存在的请求来验证一下看看页...
springboot-数据校验、异常处理、单元测试、打包、日志
inke的博客
07-07 3014
springboot-数据校验、异常处理、单元测试、打包、日志springboot-数据校验
Spring boot 开启事务回滚
weixin_44039105的博客
09-16 808
Springboot中事务的使用： 1、启动类加上@EnableTransactionManagement注解，开启事务支持（其实默认是开启的）。 2、在使用事务的public（只有public支持事务）方法（或者类-相当于该类的所有public方法都使用）加上@Transactional注解。 在实际使用中一般是在service中使用@Transactional，那么对于controller->service流程中： 如果controller未开启事务，service中开始了事务，service成功
基于面向对象的Java程序设计经典教程
ThinkinJava ThinkinJava 是一本经典的 Java 编程书籍，由 Bruce Eckel 撰写。该书籍对 Java 语言进行了详细的介绍，从基本语法到高级特性，涵盖了面向对象编程、网络编程、多线程处理、虚拟机性能等方面。 在本书...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值