Java如何自定义异常打印非堆栈信息详解

前言

在学习Java的过程中,想必大家都一定学习过异常这个篇章,异常的基本特性和使用这里就不再多讲了。什么是异常?我不知道大家都是怎么去理解的,我的理解很简单,那就是不正常的情况,比如我现在是个男的,但是我却有着女人所独有的东西,在我看来这尼玛肯定是种异常,简直不能忍。想必大家都能够理解看懂,并正确使用。

但是,光学会基本异常处理和使用不够的,在工作中出现异常并不可怕,有时候是需要使用异常来驱动业务的处理,例如: 在使用唯一约束的数据库的时候,如果插入一条重复的数据,那么可以通过捕获唯一约束异常DuplicateKeyException来进行处理,这个时候,在server层中就可以向调用层抛出对应的状态,上层根据对应的状态再进行处理,所以有时候异常对业务来说,是一个驱动方式。

有的捕获异常之后会将异常进行输出,不知道细心的同学有没有注意到一点,输出的异常是什么东西呢?

下面来看一个常见的异常:

java.lang.ArithmeticException: / by zero
 at greenhouse.ExceptionTest.testException(ExceptionTest.java:16)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
 at java.lang.reflect.Method.invoke(Method.java:597)
 at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
 at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
 at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
 at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
 at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:76)
 at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)
 at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
 at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
 at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
 at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
 at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
 at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
 at org.junit.runner.JUnitCore.run(JUnitCore.java:157)
 at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
 at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
 at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
 at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)

一个空指针异常:

java.lang.NullPointerException
 at greenhouse.ExceptionTest.testException(ExceptionTest.java:16)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
 at java.lang.reflect.Method.invoke(Method.java:597)
 at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:44)
 at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:15)
 at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:41)
 at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:20)
 at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:76)
 at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)
 at org.junit.runners.ParentRunner$3.run(ParentRunner.java:193)
 at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:52)
 at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:191)
 at org.junit.runners.ParentRunner.access$000(ParentRunner.java:42)
 at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:184)
 at org.junit.runners.ParentRunner.run(ParentRunner.java:236)
 at org.junit.runner.JUnitCore.run(JUnitCore.java:157)
 at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
 at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
 at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
 at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)

大家有没有发现一个特点,就是异常的输出是中能够精确的输出异常出现的地点,还有后面一大堆的执行过程类调用,也都打印出来了,这些信息从哪儿来呢? 这些信息是从栈中获取的,在打印异常日志的时候,会从栈中去获取这些调用信息。能够精确的定位异常出现的异常当然是好,但是我们有时候考虑到程序的性能,以及一些需求时,我们有时候并不需要完全的打印这些信息,并且去方法调用栈中获取相应的信息,是有性能消耗的,对于一些性能要求高的程序,我们完全可以在这一个方面为程序性能做一个提升。

所以如何避免输出这些堆栈信息呢? 那么自定义异常就可以解决这个问题:

首先,自动异常需要继承RuntimeException, 然后,再通过是重写fillInStackTrace, toString 方法, 例如,下面我定义一个AppException异常:

package com.green.monitor.common.exception;
import java.text.MessageFormat;
/**
 * 自定义异常类
 */
public class AppException extends RuntimeException {
 private boolean isSuccess = false;
 private String key;
 private String info;
 public AppException(String key) {
 super(key);
 this.key = key;
 this.info = key;
 }
 public AppException(String key, String message) {
 super(MessageFormat.format("{0}[{1}]", key, message));
 this.key = key;
 this.info = message;
 }
 public AppException(String message, String key, String info) {
 super(message);
 this.key = key;
 this.info = info;
 }
 public boolean isSuccess() {
 return isSuccess;
 }
 public String getKey() {
 return key;
 }
 public void setKey(String key) {
 this.key = key;
 }
 public String getInfo() {
 return info;
 }
 public void setInfo(String info) {
 this.info = info;
 }
 @Override
 public Throwable fillInStackTrace() {
 return this;
 }
 @Override
 public String toString() {
 return MessageFormat.format("{0}[{1}]",this.key,this.info);
 }
}

那么为什么要重写fillInStackTrace, 和 toString 方法呢? 我们首先来看源码是怎么一回事.

public class RuntimeException extends Exception {
 static final long serialVersionUID = -7034897190745766939L;
 /** Constructs a new runtime exception with <code>null</code> as its
 * detail message. The cause is not initialized, and may subsequently be
 * initialized by a call to {@link #initCause}.
 */
 public RuntimeException() {
 super();
 }
 /** Constructs a new runtime exception with the specified detail message.
 * The cause is not initialized, and may subsequently be initialized by a
 * call to {@link #initCause}.
 *
 * @param message the detail message. The detail message is saved for
 *  later retrieval by the {@link #getMessage()} method.
 */
 public RuntimeException(String message) {
 super(message);
 }
 /**
 * Constructs a new runtime exception with the specified detail message and
 * cause. <p>Note that the detail message associated with
 * <code>cause</code> is <i>not</i> automatically incorporated in
 * this runtime exception's detail message.
 *
 * @param message the detail message (which is saved for later retrieval
 *  by the {@link #getMessage()} method).
 * @param cause the cause (which is saved for later retrieval by the
 *  {@link #getCause()} method). (A <tt>null</tt> value is
 *  permitted, and indicates that the cause is nonexistent or
 *  unknown.)
 * @since 1.4
 */
 public RuntimeException(String message, Throwable cause) {
 super(message, cause);
 }
 /** Constructs a new runtime exception with the specified cause and a
 * detail message of <tt>(cause==null ? null : cause.toString())</tt>
 * (which typically contains the class and detail message of
 * <tt>cause</tt>). This constructor is useful for runtime exceptions
 * that are little more than wrappers for other throwables.
 *
 * @param cause the cause (which is saved for later retrieval by the
 *  {@link #getCause()} method). (A <tt>null</tt> value is
 *  permitted, and indicates that the cause is nonexistent or
 *  unknown.)
 * @since 1.4
 */
 public RuntimeException(Throwable cause) {
 super(cause);
 }
}

RuntimeException是继承Exception,但是它里面去只是调用了父类的方法,本身是没有做什么其余的操作。那么继续看Exception里面是怎么回事呢?

public class Exception extends Throwable {
 static final long serialVersionUID = -3387516993124229948L;
 /**
 * Constructs a new exception with <code>null</code> as its detail message.
 * The cause is not initialized, and may subsequently be initialized by a
 * call to {@link #initCause}.
 */
 public Exception() {
 super();
 }
 /**
 * Constructs a new exception with the specified detail message. The
 * cause is not initialized, and may subsequently be initialized by
 * a call to {@link #initCause}.
 *
 * @param message the detail message. The detail message is saved for
 *  later retrieval by the {@link #getMessage()} method.
 */
 public Exception(String message) {
 super(message);
 }
 /**
 * Constructs a new exception with the specified detail message and
 * cause. <p>Note that the detail message associated with
 * <code>cause</code> is <i>not</i> automatically incorporated in
 * this exception's detail message.
 *
 * @param message the detail message (which is saved for later retrieval
 *  by the {@link #getMessage()} method).
 * @param cause the cause (which is saved for later retrieval by the
 *  {@link #getCause()} method). (A <tt>null</tt> value is
 *  permitted, and indicates that the cause is nonexistent or
 *  unknown.)
 * @since 1.4
 */
 public Exception(String message, Throwable cause) {
 super(message, cause);
 }
 /**
 * Constructs a new exception with the specified cause and a detail
 * message of <tt>(cause==null ? null : cause.toString())</tt> (which
 * typically contains the class and detail message of <tt>cause</tt>).
 * This constructor is useful for exceptions that are little more than
 * wrappers for other throwables (for example, {@link
 * java.security.PrivilegedActionException}).
 *
 * @param cause the cause (which is saved for later retrieval by the
 *  {@link #getCause()} method). (A <tt>null</tt> value is
 *  permitted, and indicates that the cause is nonexistent or
 *  unknown.)
 * @since 1.4
 */
 public Exception(Throwable cause) {
 super(cause);
 }
}

从源码中可以看到, Exception里面也是直接调用了父类的方法,和RuntimeException一样,自己其实并没有做什么。 那么直接来看Throwable里面是怎么一回事:

public class Throwable implements Serializable {
 public Throwable(String message) {
 fillInStackTrace();
 detailMessage = message;
 }

 /**
 * Fills in the execution stack trace. This method records within this
 * <code>Throwable</code> object information about the current state of
 * the stack frames for the current thread.
 *
 * @return a reference to this <code>Throwable</code> instance.
 * @see java.lang.Throwable#printStackTrace()
 */
 public synchronized native Throwable fillInStackTrace();

 /**
 * Provides programmatic access to the stack trace information printed by
 * {@link #printStackTrace()}. Returns an array of stack trace elements,
 * each representing one stack frame. The zeroth element of the array
 * (assuming the array's length is non-zero) represents the top of the
 * stack, which is the last method invocation in the sequence. Typically,
 * this is the point at which this throwable was created and thrown.
 * The last element of the array (assuming the array's length is non-zero)
 * represents the bottom of the stack, which is the first method invocation
 * in the sequence.
 *
 * <p>Some virtual machines may, under some circumstances, omit one
 * or more stack frames from the stack trace. In the extreme case,
 * a virtual machine that has no stack trace information concerning
 * this throwable is permitted to return a zero-length array from this
 * method. Generally speaking, the array returned by this method will
 * contain one element for every frame that would be printed by
 * <tt>printStackTrace</tt>.
 *
 * @return an array of stack trace elements representing the stack trace
 *  pertaining to this throwable.
 * @since 1.4
 */
 public StackTraceElement[] getStackTrace() {
 return (StackTraceElement[]) getOurStackTrace().clone();
 }
 private synchronized StackTraceElement[] getOurStackTrace() {
 // Initialize stack trace if this is the first call to this method
 if (stackTrace == null) {
  int depth = getStackTraceDepth();
  stackTrace = new StackTraceElement[depth];
  for (int i=0; i < depth; i++)
  stackTrace[i] = getStackTraceElement(i);
 }
 return stackTrace;
 }

 /**
 * Returns the number of elements in the stack trace (or 0 if the stack
 * trace is unavailable).
 *
 * package-protection for use by SharedSecrets.
 */
 native int getStackTraceDepth();
 /**
 * Returns the specified element of the stack trace.
 *
 * package-protection for use by SharedSecrets.
 *
 * @param index index of the element to return.
 * @throws IndexOutOfBoundsException if <tt>index < 0 ||
 *  index >= getStackTraceDepth() </tt>
 */
 native StackTraceElement getStackTraceElement(int index);

 /**
 * Returns a short description of this throwable.
 * The result is the concatenation of:
 * <ul>
 * <li> the {@linkplain Class#getName() name} of the class of this object
 * <li> ": " (a colon and a space)
 * <li> the result of invoking this object's {@link #getLocalizedMessage}
 * method
 * </ul>
 * If <tt>getLocalizedMessage</tt> returns <tt>null</tt>, then just
 * the class name is returned.
 *
 * @return a string representation of this throwable.
 */
 public String toString() {
 String s = getClass().getName();
 String message = getLocalizedMessage();
 return (message != null) ? (s + ": " + message) : s;
 }

从源码中可以看到,到Throwable就几乎到头了, 在fillInStackTrace() 方法是一个native方法,这方法也就是会调用底层的C语言,返回一个Throwable对象, toString 方法,返回的是throwable的简短描述信息, 并且在getStackTrace 方法和 getOurStackTrace 中调用的都是native方法getStackTraceElement, 而这个方法是返回指定的栈元素信息,所以这个过程肯定是消耗性能的,那么我们自定义异常中的重写toString方法和fillInStackTrace方法就可以不从栈中去获取异常信息,直接输出,这样对系统和程序来说,相对就没有那么”重”, 是一个优化性能的非常好的办法。那么如果出现自定义异常那么是什么样的呢?请看下面吧:

@Test
 public void testException(){
 try {
 String str =null;
 System.out.println(str.charAt(0));
 }catch (Exception e){
 throw new AppException("000001","空指针异常");
 }
 }

那么在异常异常的时候,系统将会打印我们自定义的异常信息:

000001[空指针异常]
Process finished with exit code -1

所以特别简洁,优化了系统程序性能,让程序不这么“重”, 所以对于性能要求特别要求的系统。赶紧自己的自定义异常吧!

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对我们的支持。

您可能感兴趣的文章:

  • java堆栈类使用实例(java中stack的使用方法)
  • 深入JVM剖析Java的线程堆栈
  • Java编程思想里的泛型实现一个堆栈类 分享
  • Java使用Deque实现堆栈的方法
  • Java实现简单堆栈代码
  • 详解Java线程堆栈
  • Java中异常打印输出的常见方法总结
(0)

相关推荐

  • Java编程思想里的泛型实现一个堆栈类 分享

    觉得作者写得太好了,不得不收藏一下. 对这个例子的理解: //类型参数不能用基本类型,T和U其实是同一类型. //每次放新数据都成为新的top,把原来的top往下压一级,通过指针建立链接. //末端哨兵既是默认构造器创建出的符合end()返回true的节点. 复制代码 代码如下: //: generics/LinkedStack.java// A stack implemented with an internal linked structure.package generics; publi

  • Java使用Deque实现堆栈的方法

    本文实例讲述了Java使用Deque实现堆栈的方法.分享给大家供大家参考.具体如下: import java.util.ArrayDeque; import java.util.Deque; public class IntegerStack { private Deque<Integer> data = new ArrayDeque<Integer>(); public void push(Integer element) { data.addFirst(element); }

  • Java中异常打印输出的常见方法总结

    前言 Java异常是在Java应用中的警报器,在出现异常的情况下,可以帮助我们程序猿们快速定位问题的类型以及位置.但是一般在我们的项目中,由于经验阅历等多方面的原因,依然有若干的童鞋在代码中没有正确的使用异常打印方法,导致在项目的后台日志中,没有收到日志或者日志信息不完整等情况的发生,这些都给项目埋下了若干隐患.本文将深入分析在异常日志打印过程中的若干情况,并给出若干的使用建议. 1. Java异常Exception的结构分析 我们通常所说的Exception主要是继承于Throwable而来,

  • 深入JVM剖析Java的线程堆栈

    在这篇文章里我将教会你如何分析JVM的线程堆栈以及如何从堆栈信息中找出问题的根因.在我看来线程堆栈分析技术是Java EE产品支持工程师所必须掌握的一门技术.在线程堆栈中存储的信息,通常远超出你的想象,我们可以在工作中善加利用这些信息. 我的目标是分享我过去十几年来在线程分析中积累的知识和经验.这些知识和经验是在各种版本的JVM以及各厂商的JVM供应商的深入分析中获得的,在这个过程中我也总结出大量的通用问题模板. 那么,准备好了么,现在就把这篇文章加入书签,在后续几周中我会给大家带来这一系列的专

  • 详解Java线程堆栈

    写在前面: 线程堆栈应该是多线程类应用程序非功能问题定位的最有效手段,可以说是杀手锏.线程堆栈最擅长与分析如下类型问题: 系统无缘无故CPU过高. 系统挂起,无响应. 系统运行越来越慢. 性能瓶颈(如无法充分利用CPU等) 线程死锁.死循环,饿死等. 由于线程数量太多导致系统失败(如无法创建线程等). 如何解读线程堆栈 如下面一段Java源代码程序: package org.ccgogoing.study.stacktrace; /** * @Author: LuoChong400 * @Des

  • Java实现简单堆栈代码

    本文实例为大家分享了Java实现简单堆栈的具体代码,供大家参考,具体内容如下 /** * Created by Frank */ public class ToyStack { /** * 栈的最大深度 **/ protected int MAX_DEPTH = 10; /** * 栈的当前深度 */ protected int depth = 0; /** * 实际的栈 */ protected int[] stack = new int[MAX_DEPTH]; /** * push,向栈中添

  • java堆栈类使用实例(java中stack的使用方法)

    JAVA 中,使用 java.util.Stack 类的构造方法创建对象. public class Stack extends vector 构造方法 : public Stack() 创建一个空 Stack. 方法:  1. public push  (item )  把项 压入栈顶.其作用与 addElement (item ) 相同. 参数 item 压入栈顶的项 . 返回: item 参数 : 2. public pop () 移除栈顶对象,并作为函数的值 返回该对象. 返回:栈顶对象

  • Java如何自定义异常打印非堆栈信息详解

    前言 在学习Java的过程中,想必大家都一定学习过异常这个篇章,异常的基本特性和使用这里就不再多讲了.什么是异常?我不知道大家都是怎么去理解的,我的理解很简单,那就是不正常的情况,比如我现在是个男的,但是我却有着女人所独有的东西,在我看来这尼玛肯定是种异常,简直不能忍.想必大家都能够理解看懂,并正确使用. 但是,光学会基本异常处理和使用不够的,在工作中出现异常并不可怕,有时候是需要使用异常来驱动业务的处理,例如: 在使用唯一约束的数据库的时候,如果插入一条重复的数据,那么可以通过捕获唯一约束异常

  • Java如何获取属性的注释信息详解

    前言 注解是JavaSE5.0开始提供的一项新特性,利用此特性可以通过特定的注解标签为程序提供一些描述性信息.这些描述性信息可以在编译或运行时为编译器.运行环境提供附加的信息,从而简化开发.本文将详细介绍Java获取属性注释信息的相关内容,下面来一起看看详细的实现代码 实例代码 1.数据模型 package com.example.demo; import java.util.List; /** * Description: * * @author jack * @date 2021/7/13

  • SpringBoot打印启动时异常堆栈信息详解

    SpringBoot在项目启动时如果遇到异常并不能友好的打印出具体的堆栈错误信息,我们只能查看到简单的错误消息,以致于并不能及时解决发生的问题,针对这个问题SpringBoot提供了故障分析仪的概念(failure-analyzer),内部根据不同类型的异常提供了一些实现,我们如果想自定义该怎么去做? FailureAnalyzer SpringBoot提供了启动异常分析接口FailureAnalyzer,该接口位于org.springframework.boot.diagnosticspack

  • java 中同步、异步、阻塞和非阻塞区别详解

    java 中同步.异步.阻塞和非阻塞区别详解 简单点说: 阻塞就是干不完不准回来,一直处于等待中,直到事情处理完成才返回: 非阻塞就是你先干,我先看看有其他事没有,一发现事情被卡住,马上报告领导. 我们拿最常用的send和recv两个函数来说吧... 比如你调用send函数发送一定的Byte,在系统内部send做的工作其实只是把数据传输(Copy)到TCP/IP协议栈的输出缓冲区,它执行成功并不代表数据已经成功的发送出去了,如果TCP/IP协议栈没有足够的可用缓冲区来保存你Copy过来的数据的话

  • java 线程公平锁与非公平锁详解及实例代码

    java 线程公平锁与非公平锁详解 在ReentrantLock中很明显可以看到其中同步包括两种,分别是公平的FairSync和非公平的NonfairSync.公平锁的作用就是严格按照线程启动的顺序来执行的,不允许其他线程插队执行的:而非公平锁是允许插队的. 默认情况下ReentrantLock是通过非公平锁来进行同步的,包括synchronized关键字都是如此,因为这样性能会更好.因为从线程进入了RUNNABLE状态,可以执行开始,到实际线程执行是要比较久的时间的.而且,在一个锁释放之后,其

  • Java 类型信息详解和反射机制介绍

    RTTI RTTI(RunTime Type Information)运行时类型信息,能够在程序运行时发现和使用类型信息,把我们从只能在编译期知晓类型信息并操作的局限中解脱出来 传统的多态机制正是 RTTI 的基本使用:假设有一个基类 Shape 和它的三个子类 Circle.Square.Triangle,现在要把 Circle.Square.Triangle 对象放入 List<Shape> 中,在运行时,先把放入其中的所有对象都当作 Object 对象来处理,再自动将类型转换为 Shap

  • C#使用stackalloc分配堆栈内存和非托管类型详解

    目录 stackalloc 表达式 stackalloc 分配 System.Span<T> 或 System.ReadOnlySpan<T> 类型 stackalloc 分配 指针类型 stackalloc分配内存的注意点 非托管类型 Unmanaged type stackalloc 表达式 stackalloc表达式在栈(stack)上分配内存块. 在方法执行期间创建的栈中分配的内存块会在方法返回时自动丢弃.不能显式释放使用 stackalloc 分配的内存.stackall

  • Java编程思想对象的容纳实例详解

    Java提供了容纳对象(或者对象的句柄)的多种方式,接下来我们具体看看都有哪些方式. 有两方面的问题将数组与其他集合类型区分开来:效率和类型.对于Java来说,为保存和访问一系列对象(实际是对象的句柄)数组,最有效的方法莫过于数组.数组实际代表一个简单的线性序列,它使得元素的访问速度非常快,但我们却要为这种速度付出代价:创建一个数组对象时,它的大小是固定的,而且不可在那个数组对象的"存在时间"内发生改变.可创建特定大小的一个数组,然后假如用光了存储空间,就再创建一个新数组,将所有句柄从

  • Android 中Crash时如何获取异常信息详解及实例

    Android 中Crash时如何获取异常信息详解 前言: 大家都知道,Android应用不可避免的会发生crash,无论你的程序写的多完美,总是无法完全避免crash的发生,可能是由于Android系统底层的bug,也可能是由于不充分的机型适配或者是糟糕的网络状况.当crash发生时,系统会kill掉你的程序,表现就是闪退或者程序已停止运行,这对用户来说是很不友好的,也是开发者所不愿意看到的,更糟糕的是,当用户发生了crash,开发者却无法得知程序为何crash,即便你想去解决这个crash,

  • Java中Exception和Error的区别详解

    世界上存在永远不会出错的程序吗?也许这只会出现在程序员的梦中.随着编程语言和软件的诞生,异常情况就如影随形地纠缠着我们,只有正确的处理好意外情况,才能保证程序的可靠性. java语言在设计之初就提供了相对完善的异常处理机制,这也是java得以大行其道的原因之一,因为这种机制大大降低了编写和维护可靠程序的门槛.如今,异常处理机制已经成为现代编程语言的标配. 今天我要问你的问题是,请对比Exception和Error,另外,运行时异常与一般异常有什么区别? 典型回答 Exception和Error都

随机推荐