精华内容
下载资源
问答
  • 异常类
    千次阅读
    2022-03-19 22:57:19

    why?

    在开发中一般是禁止写if···else···的,虽然if···else···很好理解,但那样显得代码不专业,而且有时候会有点冗余!

    what?

    在python中一般都有一个异常类,这里面有一些自带的异常,比如:TypeError、ValueError 等,但这些远远不能满足我们的需求,我们时常会定义自己的异常包,然后导入这个包,这样就可以愉快的开发了,下面就来展示一下如何定义自己的异常类。

    how?

    我们想让函数返回值不是我们想要的时候就抛出异常,我们完全可以用C语言的if···else··语句,但是为了演示我们是用python的try···except···raise表示抛出异常,就是在返回值不等于True的时候就抛出异常

    #一般都会让异常继承这个类,(或者是更高级的BaseException)
    #默认大家知道__init__和__str__
    class NotEqual(Exception):
        def __init__(self, msg):
            self.msg = msg
            
        def __str__(self):
            return self.msg
    
    class OPT():
        def test_suit(self, a):
            if a > 10:
                return True
            else:
                return False
    
        def test(self):
            try:
                if ( (True != self.test_suit(5)) or
                     (True != self.test_suit(15)) ):
                #raise表示抛出异常,后面必须是定义过的异常类,
                #括号中的内容是大家想让程序打印的内容
                	raise NotEqual("not equal")	
            except NotEqual as e:
                print("{}".format(e))
    
    
    if __name__ == '__main__':
        option = OPT()
        option.test()
    
    #运行结果
    >>>$ python test.py
    >>>  not equal
    

    程序结尾处的print表示打印到终端(屏幕)的内容,在开发中我们还应当加上python的日志系统(self.logger.debug("……")),让输出的内容打印到日志中,方便我们定位问题。

    end

    本来True == False不是异常,只是一个非真值,但在这里我们将其处理成了异常,因为python肯定没有这样的异常,所以我们必须在开始要定义一个异常类,这样就可以用了。

    更多相关内容
  • Java异常类

    千次阅读 2021-03-06 02:15:29
    异常指不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。异常是一个事件,它发生在程序运行期间,干扰了正常的指令流程。...Java异常类层次结构图:在 Java 中,所有的异常都有一个共同的祖先 ...

    异常指不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。异常是一个事件,它发生在程序运行期间,干扰了正常的指令流程。Java通 过API中Throwable类的众多子类描述各种不同的异常。因而,Java异常都是对象,是Throwable子类的实例,描述了出现在一段编码中的 错误条件。当条件生成时,错误将引发异常。

    Java异常类层次结构图:

    c8b0274c85d5e3dbd2349d18bfe0f70f.png

    在 Java 中,所有的异常都有一个共同的祖先 Throwable(可抛出)。Throwable 指定代码中可用异常传播机制通过 Java 应用程序传输的任何问题的共性。

    Throwable: 有两个重要的子类:Exception(异常)和 Error(错误),二者都是 Java 异常处理的重要子类,各自都包含大量子类。

    Error(错误):是程序无法处理的错误,表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关,而表示代码运行时 JVM(Java 虚拟机)出现的问题。例如,Java虚拟机运行错误(Virtual MachineError),当 JVM 不再有继续执行操作所需的内存资源时,将出现 OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)一般会选择线程终止。

    这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时,如Java虚拟机运行错误(Virtual MachineError)、类定义错误(NoClassDefFoundError)等。这些错误是不可查的(因为不知道什么时候会出现这类问题,不好指定同时也没有定义),因为它们在应用程序的控制和处理能力之 外,而且绝大多数是程序运行时不允许出现的状况。对于设计合理的应用程序来说,即使确实发生了错误,本质上也不应该试图去处理它所引起的异常状况。在 Java中,错误通过Error的子类描述。

    Exception(异常):是程序本身可以处理的异常(很多错误提前可以预知如除数为0就会报错)。

    Exception 类有一个重要的子类 RuntimeException。RuntimeException 类及其子类表示“JVM 常用操作”引发的错误。例如,若试图使用空值对象引用、除数为零或数组越界,则分别引发运行时异常(NullPointerException、ArithmeticException)和 ArrayIndexOutOfBoundException。

    注意:异常和错误的区别:异常能被程序本身可以处理,错误是无法处理。

    Java的异常(包括Exception和Error)按照编译器是否在编译期间检查分为可查的异常(checked exceptions)和不可查的异常(unchecked exceptions)。

    可查异常(编译器要求必须处置的异常):正确的程序在运行中,很容易出现的、情理可容的异常状况。可查异常虽然是异常状况,但在一定程度上它的发生是可以预计的,而且一旦发生这种异常状况,就必须采取某种方式进行处理。

    除了RuntimeException及其子类(编译器不做检查如空指针异常)以外,其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它,也就是说,当程序中可能出现这类异常,要么用try-catch语句捕获它,要么用throws子句声明抛出它,否则编译不会通过。

    不可查异常(编译器不要求强制处置的异常):包括运行时异常(RuntimeException与其子类)和错误(Error)。

    Exception 这种异常分两大类运行时异常和非运行时异常(编译异常)。程序中应当尽可能去处理这些异常。

    按照程序执行的过程划分

    运行时异常:都是RuntimeException类及其子类异常,如NullPointerException(空指针异常)、IndexOutOfBoundsException(下标越界异常)等,这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理。这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生。运行时异常的特点是Java编译器不会检查它,也就是说,当程序中可能出现这类异常,即使没有用try-catch语句捕获它,也没有用throws子句声明抛出它,也会编译通过(  如果所有方法都层层上抛获取的异常,最终JVM会进行处理,处理也很简单,就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException,则该方法的调用者可选择处理该异常)。

    非运行时异常 (编译异常):是RuntimeException以外的异常,类型上都属于Exception类及其子类。从程序语法角度讲是必须进行处理的异常,如果不处理,程序就不能编译通过。如IOException、SQLException等以及用户自定义的Exception异常,一般情况下不自定义检查异常。

    Java中的异常处理机制

    在 Java 应用程序中,异常处理机制为:抛出异常,捕捉异常。

    抛出异常:当一个方法出现错误引发异常时,方法创建异常对象并交付运行时系统,异常对象中包含了异常类型和异常出现时的程序状态等异常信息。运行时系统负责寻找处置异常的代码并执行。

    捕获异常:在方法抛出异常之后,运行时系统将转为寻找合适的异常处理器(exception handler)。潜在的异常处理器是异常发生时依次存留在调用栈中的方法的集合。当异常处理器所能处理的异常类型与方法抛出的异常类型相符时,即为合适 的异常处理器。运行时系统从发生异常的方法开始,依次回查调用栈中的方法,直至找到含有合适异常处理器的方法并执行。当运行时系统遍历调用栈而未找到合适 的异常处理器,则运行时系统终止。同时,意味着Java程序的终止。

    对于运行时异常、错误或可查异常,Java技术所要求的异常处理方式有所不同。

    由于运行时异常(RuntimeException及其子类)的不可查性,为了更合理、更容易地实现应用程序,Java规定,运行时异常将由Java运行时系统自动抛出,允许应用程序忽略运行时异常(如:“除数为0”等ArithmeticException,是RuntimException的子类。而运行时异常将由运行时系统自动抛出,不需要使用throw语句)。

    对于方法运行中可能出现的Error,当运行方法不欲捕捉时,Java允许该方法不做任何抛出声明。因为,大多数Error异常属于永远不能被允许发生的状况,也属于合理的应用程序不该捕捉的异常(在编写程序时不需要考虑Error)。

    对于所有的可查异常(除了RuntimeException及其子类),Java规定:一个方法必须捕捉,或者声明抛出方法之外。也就是说,当一个方法选择不捕捉可查异常时,它必须声明将抛出异常,因为Java编译器会检查它,也就是说,当程序中可能出现这类异常,要么用try-catch语句捕获它,要么用throws子句声明抛出它,否则编译不会通过。

    能够捕捉异常的方法,需要提供相符类型的异常处理器。所捕捉的异常,可能是由于自身语句所引发并抛出的异常,也可能是由某个调用的方法或者Java运行时 系统等抛出的异常。也就是说,一个方法所能捕捉的异常,一定是Java代码在某处所抛出的异常。简单地说,异常总是先被抛出,后被捕捉的。

    任何Java代码都可以抛出异常,如:自己编写的代码、来自Java开发环境包中代码,或者Java运行时系统。无论是谁,都可以通过Java的throw语句抛出异常。

    1.从方法中抛出的任何异常都必须使用throws子句。

    2.捕捉异常通过try-catch语句或者try-catch-finally语句实现。

    3.总体来说,Java规定:对于可查异常必须捕捉、或者声明抛出(throw)。允许忽略不可查的RuntimeException和Error。

    例1:

    packagecn.czbk.no9;public classExceprtionTest {/***@paramargs*/

    public static voidmain(String[] args) {int a=6;int b=0;/*** 除数为0,属于RuntimeException,属于不可查异常

    * 编译器不会对其做检查。

    * 运行时异常由系统jvm自动抛出不需要主动throw*/

    int c=a/b;

    System.out.println(c);

    }

    }

    运行时异常由系统即JVM主动抛出不需要手动throw

    0b1cfcfa6a7a09b0b32bcb89872077ac.png

    那么我们要让程序正常通过,就要处理这个运行时异常。

    packagecn.czbk.no9;public classExceprtionTest {/***@paramargs*/

    public static voidmain(String[] args) {int a=6;int b=2;/*** 除数为0,属于RuntimeException,属于不可查异常

    * 编译器不会对其做检查。

    * 运行时异常由系统jvm自动抛出不需要主动throw*/

    try{if(b==0){//在运行过程中出现的异常都是属于上面讲的异常类的实例

    throw newArithmeticException();//由于是RuntimeException所以可以不用显示抛出

    }else{

    System.out.println("a/b="+(a/b));

    }

    }catch(ArithmeticException e) {//TODO: handle exception

    System.out.println("除数不能为0");

    }

    System.out.println("程序正常结束!");

    }

    }

    try-catch-finally语句

    try{//可能会发生异常的程序代码

    } catch(Type1 id1) {//捕获并处理try抛出的异常类型Type1

    } catch(Type2 id2) {//捕获并处理try抛出的异常类型Type2

    } finally{//无论是否发生异常,都将执行的语句块

    }

    实例:

    packagecn.czbk.no9;importjava.util.Scanner;public classExceptionTest1 {public static voidmain(String[] args) {int[] intArray = new int[4];int a = 20;int c=0;//数组初始化赋值

    for (int i = 0; i <= 3; i++) {

    intArray[i]=i;

    }//根据输入的值判断循环次数

    Scanner in=newScanner(System.in);

    String text=in.nextLine();//将输入的String转为Int

    int x=Integer.parseInt(text);for (int i = x; i >= 0; i--) {//将不可查异常即RuntimeException进行捕获处理

    try{int b =intArray[i];

    c=a/b;

    }/*** 如果抛出的异常对象属于catch子句的异常类,或者属于该异常类的子类,则认为生成的异常对象与catch块捕获的异常类型相匹配。

    * 一旦某个catch捕获到匹配的异常类型,将进入异常处理代码。

    * 一经处理结束,就意味着整个try-catch语句结束。

    * 其他的catch子句不再有匹配和捕获异常类型的机会。

    * 对于有多个catch子句的异常程序而言,应该尽量将捕获底层异常类的catch子 句放在前面,

    * 同时尽量将捕获相对高层的异常类的catch子句放在后面。

    * 否则,捕获底层异常类的catch子句将可能会被屏蔽。*/

    catch(ArrayIndexOutOfBoundsException e) {//TODO: handle exception

    System.out.println("数组下标越界,原数组中没有intArray["+i+"]");

    }catch(ArithmeticException e) {//TODO: handle exception

    System.out.println("intArray[" + i + "]" + "除数不能为0");

    }catch(Exception e) {//TODO: handle exception

    System.out.println("其他未想到的运行时异常");

    }finally{

    System.out.println("i为"+i+"计算结果 a/b="+a+"/"+intArray[i]+"="+c);

    }

    }

    }

    }

    总结:

    try 块:用于捕获异常。其后可接零个或多个catch块,如果没有catch块,则必须跟一个finally块。

    catch 块:用于处理try捕获到的异常。

    finally 块:无论是否捕获或处理异常,finally块里的语句都会被执行。当在try块或catch块中遇到return语句时,finally语句块将在方法返回之前被执行。在以下4种特殊情况下,finally块不会被执行:

    1)在finally语句块中发生了异常。

    2)在前面的代码中用了System.exit()退出程序。

    3)程序所在的线程死亡。

    4)关闭CPU。

    8aea6ba2f9b2295f6843d44839562bc2.png

    抛出异常

    1. throws抛出异常

    methodname throwsException1,Exception2,..,ExceptionN

    {

    }

    方法名后的throws Exception1,Exception2,...,ExceptionN 为声明要抛出的异常列表。当方法抛出异常列表的异常时,方法将不对这些类型及其子类类型的异常作处理,而抛向调用该方法的方法,由他去处理。例如:

    Throws抛出异常的规则:

    1) 如果是不可查异常(unchecked exception),即Error、RuntimeException或它们的子类,那么可以不使用throws关键字来声明要抛出的异常,编译仍能顺利通过,但在运行时会被系统抛出。

    2)必须声明方法可抛出的任何可查异常(checked exception)。即如果一个方法可能出现受可查异常,要么用try-catch语句捕获,要么用throws子句声明将它抛出,否则会导致编译错误

    3)仅当抛出了异常,该方法的调用者才必须处理或者重新抛出该异常。当方法的调用者无力处理该异常的时候,应该继续抛出,而不是囫囵吞枣。

    4)调用方法必须遵循任何可查异常的处理和声明规则。若覆盖一个方法,则不能声明与覆盖方法不同的异常。声明的任何异常必须是被覆盖方法所声明异常的同类或子类。

    2. 使用throw抛出异常

    void method1() throws IOException{} //合法//编译错误,必须捕获或声明抛出IOException

    voidmethod2(){

    method1();

    }//合法,声明抛出IOException

    void method3()throwsIOException {

    method1();

    }//合法,声明抛出Exception,IOException是Exception的子类

    void method4()throwsException {

    method1();

    }//合法,捕获IOException

    voidmethod5(){try{

    method1();

    }catch(IOException e){…}

    }//编译错误,必须捕获或声明抛出Exception

    voidmethod6(){try{

    method1();

    }catch(IOException e){throw newException();}

    }//合法,声明抛出Exception

    void method7()throwsException{try{

    method1();

    }catch(IOException e){throw newException();}

    }

    判断一个方法可能会出现异常的依据如下:

    1)方法中有throw语句。例如,以上method7()方法的catch代码块有throw语句。

    2)调用了其他方法,其他方法用throws子句声明抛出某种异常。例如,method3()方法调用了method1()方法,method1()方法声明抛出IOException,因此,在method3()方法中可能会出现IOException。

    throw总是出现在函数体中,用来抛出一个Throwable类型的异常。程序会在throw语句后立即终止,它后面的语句执行不到,然后在包含它的所有try块中(可能在上层调用函数中)从里向外寻找含有与其匹配的catch子句的try块。

    我们知道,异常是异常类的实例对象,我们可以创建异常类的实例对象通过throw语句抛出。该语句的语法格式为:

    throw new exceptionname;

    例如抛出一个IOException类的异常对象:

    throw new IOException;

    要注意的是,throw 抛出的只能够是可抛出类Throwable 或者其子类的实例对象。下面的操作是错误的:

    throw new String("exception");

    这是因为String 不是Throwable 类的子类。

    如果抛出了检查异常,则还应该在方法头部声明方法可能抛出的异常类型。该方法的调用者也必须检查处理抛出的异常。

    如果所有方法都层层上抛获取的异常,最终JVM会进行处理,处理也很简单,就是打印异常消息和堆栈信息。如果抛出的是Error或RuntimeException,则该方法的调用者可选择处理该异常。

    packagecn.czbk.no9;public classExceptionTest3 {public void pop() throwsMyException{

    String s="测试用";throw newMyException(s);

    }public static void main(String[] args) throwsMyException{

    ExceptionTest3 et=newExceptionTest3();

    et.pop();

    }

    }class MyException extendsException{

    String message;publicMyException(String errorMessage){

    message=errorMessage;

    }publicString getMessage(){returnmessage;

    }

    }

    在main函数继续抛出的话会在运行后会显示如下内容

    885afa5e1ecff882a1d59e8a39f18f63.png

    如果不抛出而是选择处理的话如下所示

    packagecn.czbk.no9;public classExceptionTest3 {public void pop() throwsMyException{

    String s="测试用";throw newMyException(s);

    }public static voidmain(String[] args){

    ExceptionTest3 et=newExceptionTest3();try{

    et.pop();

    }catch(MyException e) {//TODO: handle exception

    e.getPrintMessage();

    }

    }

    }class MyException extendsException{

    String message;publicMyException(String errorMessage){

    message=errorMessage;

    }public voidgetPrintMessage(){

    System.out.println(message);

    }

    }

    c8263d3dfa03021848ec9c759817a195.png

    4.4 Throwable类中的常用方法

    注意:catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型,e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:

    getCause():返回抛出异常的原因。如果 cause 不存在或未知,则返回 null。

    getMeage():返回异常的消息信息。

    printStackTrace():对象的堆栈跟踪输出至错误输出流,作为字段 System.err 的值。

    有时为了简单会忽略掉catch语句后的代码,这样try-catch语句就成了一种摆设,一旦程序在运行过程中出现了异常,就会忽略处理异常,而错误发生的原因很难查找。

    Java常见异常

    在Java中提供了一些异常用来描述经常发生的错误,对于这些异常,有的需要程序员进行捕获处理或声明抛出,有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:

    1.RuntimeException子类:

    1、 java.lang.ArrayIndexOutOfBoundsException

    数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。

    2、java.lang.ArithmeticException

    算术条件异常。譬如:整数除零等。

    3、java.lang.NullPointerException

    空指针异常。当应用试图在要求使用对象的地方使用了null时,抛出该异常。譬如:调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等

    4、java.lang.ClassNotFoundException

    找不到类异常。当应用试图根据字符串形式的类名构造类,而在遍历CLASSPAH之后找不到对应名称的class文件时,抛出该异常。

    5、java.lang.NegativeArraySizeException  数组长度为负异常

    6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常

    7、java.lang.SecurityException 安全性异常

    8、java.lang.IllegalArgumentException 非法参数异常

    2.IOException

    IOException:操作输入流和输出流时可能出现的异常。

    EOFException   文件已结束异常

    FileNotFoundException   文件未找到异常

    3.其他

    ClassCastException    类型转换异常类

    ArrayStoreException  数组中包含不兼容的值抛出的异常

    SQLException   操作数据库异常类

    NoSuchFieldException   字段未找到异常

    NoSuchMethodException   方法未找到抛出的异常

    NumberFormatException    字符串转换为数字抛出的异常

    StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常

    IllegalAccessException  不允许访问某类异常

    InstantiationException  当应用程序试图使用Class类中的newInstance()方法创建一个类的实例,而指定的类对象无法被实例化时,抛出该异常

    展开全文
  • 【Java 内部类和异常类(详细版)】

    千次阅读 多人点赞 2021-04-08 17:24:17
    内部类和异常类1 内部类2 匿名类2.1 和子类有关的匿名类2.2 和接口有关的匿名类3 异常类3.1 try-catch语句3.2 自定义异常类4 断言 1 内部类 Java支持在一个类中声明另一个类,这样的类称作内部类,而包含内部类的类...

    1 内部类

    Java支持在一个类中声明另一个类,这样的类称作内部类,而包含内部类的类成为内部类的外嵌类。

    内部类的类体中不可以声明类变量和类方法。外嵌类的类体中可以用内部类声明对象,作为外嵌类的成员。

    内部类的使用规则:
    (1)声明内部类如同在类中声明方法或变量一样,一个类把内部类看作是自己的成员。
    (2)外嵌类的类体中可以用内部类声明的对象,作为外嵌类的成员。
    (3)外嵌类的成员变量在内部类中仍然有效,内部类中的方法也可以调用外嵌类中的方法。
    (4)内部类的类体中不可以声明类变量和方法。
    (5)外嵌类和内部类在编译时,生成两个.class文件。

    例如:某种类型的农场饲养了一种特殊种类的牛,但不希望其他农场饲养这种特殊种类的牛,那么这种类型的农场就可以将创建这种特殊种牛的类作为自己的内部类。
    下面的例子1(Example1.1.java)中有一个RedCowForm(红牛农场)类,该类中有一个名字为RedCow (红牛)的内部类。

    RedCowForm.java

    public class RedCowForm {
        static String formName;
        RedCow cow;  //内部类声明对象
    
        RedCowForm() {
        }
    
        RedCowForm(String s) {
            cow = new RedCow(150, 112, 5000);
            formName = s;
        }
    
        public void showCowMess() {
            cow.speak();
        }
    
        class RedCow {  //内部类的声明
            String cowName = "红牛";
            int height, weight, price;
    
            RedCow(int h, int w, int p) {
                height = h;
                weight = w;
                price = p;
            }
    
            void speak() {
                System.out.println("偶是" + cowName + ",身高:" + height + "cm 体重:" + weight + "kg,生活在" + formName);
            }
        }    //内部类结束
    }
    

    Example1.1.java

    public class Example1_1 {
        public static void main(String[] args) {
            RedCowForm form = new RedCowForm("红牛农场");
            form.showCowMess();
            form.cow.speak();
        }
    }
    

    需要特别注意的是,Java编译器生成的内部类的字节码文件的名字和通常的类不同,内部类对应的字节码文件的名字格式是“外嵌类名$ 内部类名”,例如,例子1中内部类的字节码文件是RedCowForm$RedCow.class。因此,当需要把字节码文件复制给其他开发人员时,不要忘记了内部类的字节码文件。
    内部类可以被修饰为static 内部类,例如,例子1中的内部类声明可以是static classRedCow。类是一种数据类型,那么static内部类就是外嵌类中的一-种静 态数据类型,这样一来,程序就可以在其他类中使用static内部类来创建对象了。但需要注意的是,static 内部类不能操作外嵌类中的实例成员变量。

    假如将例子1中的内部类RedCow更改成static内部类,就可以在例子1的Example1_ 1
    主类的main方法中增加如下的代码。

    RedCowForm.RedCow redCow = new RedCowForm.RedCow(180,119,6000);
            redCow.speak();
    

    注意:非内部类不可以是static类

    2 匿名类

    2.1 和子类有关的匿名类

    创建子类对象时,除了使用父类的构造方法外还有类体,此类体被认为是一个子类去掉类声明后的类体,称作匿名类。

    假设Bank是类,那么下列代码就是用Bank的一个子类(匿名类)创建对象:

    new Bank() {
    	匿名类的类体
    };
    

    和子类有关的匿名类:
    (1)匿名类是一个子类,由于无名可用,所以不可能用匿名类声明对象,但却可以直接用匿名类创建一个对象。
    (2)匿名类可以继承父类的方法也可以重写父类的方法。
    (3)使用匿名类时,必然是在某个类中直接用匿名类创建对象,以此,匿名类一定是内部类。
    (4)匿名类可以访问外嵌类中的成员变量和方法,匿名类的类体中不可以声明static成员变量和static方法。
    (5)由于匿名类是一个子类,但没有类名,所以在用匿名类创建对象时,要直接使用父类的构造方法。

    例子2:该类共有4个类: (Example2_1. java)、ShowBoard类、
    OutputAlphabet类型、 OutputEnglish. java 。该匿名类的对象负责输出希腊字母表。

    OutputAlphabet.java

    abstract class OutputAlphabet {
        public abstract void output();
    }
    

    OutputAlphabet .java

    public class OutputEnglish extends OutputAlphabet { //输出英文字母子类
        public void output(){
            for (char c='a';c<='z';c++){
                System.out.printf("%3c",c);
            }
        }
    }
    

    ShowBoard .java

    public class ShowBoard {
        void showMess(OutputAlphabet show) { //参数show是OutputAlphabet类型的对象
            show.output();
        }
    }
    

    Example2_1.java

    public class Example2_1 {
        public static void main(String[] args) {
            ShowBoard board = new ShowBoard();
            board.showMess(new OutputEnglish());//向参数传递OutputAlphabet的子类OutputEnglish的对象
    
            board.showMess(new OutputAlphabet() {   //向参数传递OutputAlphabet的匿名子类的对象
                @Override
                public void output() {
                    for (char c = 'α'; c <= 'ω'; c++)  //输出希腊字母
                        System.out.printf("%3c", c);
                }
            });//分号在这里
        }
    }
    

    在这里插入图片描述

    2.2 和接口有关的匿名类

    和接口有关的匿名类
    假设Computable是一个接口,那么,Java允许直接用接口名和一个类体创建一个匿名对象,此类体被认为是实现了Computable接口的类去掉类声明后的类体,称作匿名类。

    下列代码就是用实现了Computable接口的类(匿名类)创建对象:

    new Computable(){
    	实现接口的匿名类的类体
    };
    

    下面例子演示了和接口有关的匿名类的用法:

    interface SpeakHello {
        void speak();
    }
    
    class HelloMachine {
        public void turnOn(SpeakHello hello) {
            hello.speak();
        }
    }
    
    public class Example7_3 {
        public static void main(String[] args) {
            HelloMachine machine = new HelloMachine();
            machine.turnOn(new SpeakHello() {
                @Override
                public void speak() {
                    System.out.println("hello,you are welcome!");
                }
            });
            machine.turnOn(new SpeakHello() {
                @Override
                public void speak() {
                    System.out.println("你好,欢迎光临!");
                }
            });
        }
    }
    

    在这里插入图片描述

    3 异常类

    所谓异常就是程序运行时可能出现一些错误,比如试图打开一个根本不存在的文件等,异常处理将会改变程序的控制流程,让程序有机会对错误作出处理。程序运行出现异常时,Java运行环境就用异常类Exception的相应子类创建一个异常对象,并等待处理。异常对象可以调用如下方法得到或输出有关异常的信息:

    异常对象可以调用如下方法得到或输出有关异常的信息:

    public String getMessage();
    public void printStackTrace();
    public String toString();
    

    3.1 try-catch语句

    Java使用try-catch语句来处理异常,将可能出现的异常操作放在try-catch语句的try部分,将发生异常后的处理放在catch部分。
    try-catch语句的格式如下:

    try{
    	包含可能发生异常的语句
    }
    catch(ExceptionSubClass1 e){
    	...
    }
    catch(ExceptionSubClass2 e){
    	...
    }
    

    下面一个例子给出了try-catch语句的用法:

    public class Example3_1 {
        public static void main(String[] args) {
            int n = 0, m = 0, t = 1000;
    
            try {
                m = Integer.parseInt("8888");
                n = Integer.parseInt("ab89"); //发生异常,转向catch
                t = 7777;  //t没有机会被赋值
            } catch (NumberFormatException e) {
                System.out.println("发生异常:" + e.getMessage());
            }
            System.out.println("n=" + n + ",m=" + m + ",t=" + t);
    
            try {
                System.out.println("故意抛出I/O异常!");
                throw new java.io.IOException("我是故意的");
                //System.out.println("这个输出语句肯定没有机会执行,所以必须注释掉,否则编译出错");
            } catch (java.io.IOException e) {
                System.out.println("发生异常:" + e.getMessage());
            }
        }
    }
    

    在这里插入图片描述

    带finally子语句的try~catch语句,语法格式如下:

    try{ }
    catch(ExceptionSubClass e){ }
    finally{}
    

    其执行机制是在执行try~catch语句后,执行finally 子语句,也就是说,无论在try部分是否发生过异常,finally 子语句都会被执行

    3.2 自定义异常类

    (1)异常的声明
    ➢一个方法不处理它产生的异常,而是沿着调用层次向上传递,由调用它的方法来处理这些异常,叫声明异常.
    ➢声明异常的方法:
    在产生异常的方法名后面加上要抛出(throws)的异常的列表:
    如: void compute(int x) throwsAri thmeticException
    {//这里有异常发生,但是并没有处理…}

    (2)我们也可以扩展Exception类定义自己的异常类,然后规定哪些方法产生这样的异常。一个方法在声明时可以使用throws关键字声明要产生的若干个异常,并在该方法的方法体中具体给出产生异常的操
    作,即用相应的异常类创建对象,并使用throw关键字抛出该异常对象,导致该方法结束执行。

    (3)通常情况下,计算两个整数之和的方法不应当有任何异常放出,但是,对某些特殊应程序,可能不允许同号的整数做求和运算,比如当一个整数代表收入,一个整数代表支出时,这两个整数就不能是同号。

    例子 (Example3_2. java)中,Bank类中有一个income(int in, int out)方法,对象调用该方法时,必须向参数in传递正整数、向参数out传递负数,并且int+out必须大于等于0,否则该方法就抛出异常( BankException. java )。因此,Bank类在声明income(int in, int out)方法时,使用throws关键字声明要产生的异常。
    BankException.java

    public class BankException extends Exception {
        String message;
    
        public BankException(int m, int n) {
            message = "入账资金" + m + "是负数或支出" + n + "是正数,不符合系统要求.";
        }
    
        public String warnMess() {
            return message;
        }
    }
    

    Bank.java

    public class Bank {
        private int money;
    
        public void income(int in, int out) throws BankException {
            if (in <= 0 || out >= 0 || in + out <= 0) {
                throw new BankException(in, out); //方法抛出异常,导致方法结束
            }
            int netIncome = in + out;
            System.out.printf("本次计算出的纯收入是:%d元\n", netIncome);
            money = money + netIncome;
        }
    
        public int getMoney() {
            return money;
        }
    }
    

    Example3_2.java

    public class Example3_2 {
        public static void main(String[] args) {
            Bank bank = new Bank();
            try {
                bank.income(200, -100);
                bank.income(300, -100);
                bank.income(400, -100);
                System.out.printf("银行目前有%d元\n", bank.getMoney());
                bank.income(200, 100);
                bank.income(99999, -100);
            } catch (BankException e) {
                System.out.println("计算收益的过程出现如下问题:");
                System.out.println(e.warnMess());
            }
            System.out.printf("银行目前有%d元\n", bank.getMoney());
        }
    }
    

    在这里插入图片描述

    4 断言

    ➢断言语句用于调试代码阶段。在调试代码阶段让断言语句发挥作用,这样就可以发现一些致命的错误,当程序正式运行时就可以关闭断言语句,但仍把断言语句保留在源代码中,如果以后应用程又需要调试,可以重新启用断言语句。
    ➢使用关键字assert声明一条断言语句,断言语句有以下两种格式:
    assert booleanExpression;
    assert booleanExpression:messagelException;

    ❷启用与关闭断言语句
    当使用Java解释器直接运行应用程序时,默认地关闭断言语句,在调试程序时可以使用-ea启用断言语句,例如:
    java -ea mainClass

    例子4中,使用一个数组放着某学生5门课程的成绩,程序准备计算学生的成绩的总和。在调试程序时使用了断言语句,如果发现成绩有负数,程序立刻结束执行。程序调试开启断言语句运行效果如图4.1,关闭断言语句运行效果如图4.2。

    import java.util.Scanner;
    public class Example4 {
      public static void main (String args[ ]) {
           int [] score={-120,98,89,120,99};
           int sum=0;
           for(int number:score) {
              assert number>0:"负数不能是成绩";
              sum=sum+number;
           } 
           System.out.println("总成绩:"+sum);    
       }
    }
    

    图4.1
    在这里插入图片描述
    图4.2
    在这里插入图片描述

    5 综合案例

    下面的例子5中模拟向货船上装载集装箱,如果货船超重,那么货船认为这是一个异常将拒绝装载集装箱,但无论是否发生异常,货船都需要正点启航

    DangerException.java

    public class DangerException extends Exception {
        final String message = "超重";
        public String warnMess() {
            return message;
        }
    }
    

    CargoBoat.java

    public class CargoBoat {
        int realContent;  //装载的重量
        int maxContent;   //最大装载量
        public void setMaxContent(int c) {
            maxContent = c;
        }
        public void loading(int m) throws DangerException {
            realContent += m;
            if(realContent>maxContent) {
                throw new DangerException();
            }
            System.out.println("目前装载了"+realContent+"吨货物");
        }
    }
    

    Example5.java

    public class Example5 {
        public static void main(String[] args) {
            CargoBoat ship = new CargoBoat();
            ship.setMaxContent(1000);
            int m =600;
            try{
                ship.loading(m);
                m = 400;
                ship.loading(m);
                m = 367;
                ship.loading(m);
                m = 555;
                ship.loading(m);
            }
            catch(DangerException e) {
                System.out.println(e.warnMess());
                System.out.println("无法再装载重量是"+m+"吨的集装箱");
            }
            finally {
                System.out.printf("货船将正点启航");
            }
        }
    }
    

    在这里插入图片描述

    展开全文
  • JAVA异常分类和自定义异常定义

    万次阅读 2019-06-10 11:16:59
    异常概念: 1、如果某个方法不能按照正常的途径完成任务,就可以通过另一种路径退出方法。在这种情况下 会抛出一个封装了错误信息的对象。此时,这个方法会立刻退出同时不返回任何值。另外,调用 这个方法的其他...

    异常概念:

    1、如果某个方法不能按照正常的途径完成任务,就可以通过另一种路径退出方法。在这种情况下 会抛出一个封装了错误信息的对象。此时,这个方法会立刻退出同时不返回任何值。另外,调用 这个方法的其他代码也无法继续执行,异常处理机制会将代码执行交给异常处理器。

    2、Throwable 是 Java 语言中所有错误或异常的超类。下一层分为 Error 和 Exception

    Error

    1. Error 类是指 java 运行时系统的内部错误和资源耗尽错误。应用程序不会抛出该类对象。如果 出现了这样的错误,除了告知用户,剩下的就是尽力使程序安全的终止。

    Exception(RuntimeException、CheckedException)

    2. Exception 又 有 两 个 分 支 , 一 个 是 运 行 时 异 常 RuntimeException , 一 个 是 CheckedException。

    RuntimeException 如 : NullPointerException 、 ClassCastException ; 一 个 是 检 查 异 常 CheckedException,如 I/O 错误导致的 IOException、SQLException。 RuntimeException 是 那些可能在 Java 虚拟机正常运行期间抛出的异常的超类。 如果出现 RuntimeException,那么一 定是程序员的错误

    检查异常 CheckedException:一般是外部错误,这种异常都发生在编译阶段,Java 编译器会强 制程序去捕获此类异常,即会出现要求你把这段可能出现异常的程序进行 try catch,该类异常一 般包括几个方面:

    1》 试图在文件尾部读取数据

    2》 试图打开一个错误格式的 URL

    3》 试图根据给定的字符串查找 class 对象,而这个字符串表示的类并不存在

    3、Throw 和 throws 的区别:

    位置不同

    1》 throws 用在函数上,后面跟的是异常类,可以跟多个;而 throw 用在函数内,后面跟的 是异常对象。

    功能不同:

    2》throws 用来声明异常,让调用者只知道该功能可能出现的问题,可以给出预先的处理方 式;throw 抛出具体的问题对象,执行到 throw,功能就已经结束了,跳转到调用者,并 将具体的问题对象抛给调用者。也就是说 throw 语句独立存在时,下面不要定义其他语 句,因为执行不到。

    3》throws 表示出现异常的一种可能性,并不一定会发生这些异常;throw 则是抛出了异常, 执行 throw 则一定抛出了某种异常对象。 两者都是消极处理异常的方式,只是抛出或者可能抛出异常,但是不会由函数去处理异 常,真正的处理异常由函数的上层调用处理。

    看图理解:

    4、上面介绍了异常的一些概念,下面介绍如何自定义异常,并且异常如何统一格式响应出去

    自定义异常以及统一异常格式响应出去很简单,分为以下几步:
    
    (1)首先自定义一个异常类(2)再写一个全局异常捕获类(3)再封装一个通用响应对象,完成以上3步就ok了
    
    具体实现方法往下看:

    1》自定义异常首先要先自己新建一个异常类继承运行时异常RuntimeException ,然后再定义一个异常码和消息的枚举类配合使用,代码如下:

    自定义异常类:
    /**
     * 自定义异常类格式
     * @date 2019-06-10 10:09
     */
    
    public class TestException extends RuntimeException{
    
        private String code;
    
        public TestException(String code) {
            this.code = code;
        }
    
        public TestException(String code, Object message) {
            super(message.toString());
            this.code = code;
        }
    
        public String getCode() {
            return this.code;
        }
    
    
    }
    
    
    异常枚举类:
    public enum ActivityException {
    
    
        PARAMETER_ERROR("10100", "系统异常,入参错误"),
    
        GET_ACTIVITY_LIST("10000", "系统异常,查询活动列表异常"),
    
        private String code;
        private String message;
    
        ActivityException(String code, String message) {
            this.code = code;
            this.message = message;
        }
    
        public String getCode() {
            return code;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public String getMessage() {
            return message;
        }
    
        public void setMessage(String message) {
            this.message = message;
        }
    
    }
    

    2》自定义异常好了之后使用的时候就可以new 一个自定义的异常抛出去了比如:throw new TestException("枚举code","枚举message");但是只有这些还不够,上面仅仅是把自己想要响应的异常定义出来了,那怎么统一格式响应给前端呢?那就需要全局异常捕获,捕获到自定义的异常然后封装成自己想要的格式,响应格式可以按自己需求封装异常code、message、path、time等

    全局异常捕获类:
    
    /**
     * 全局异常捕获类(作用是异常信息统一格式输出)
     * @date 2019-06-10 10:25
     */
    @RestControllerAdvice//切面注解不能少
    public class TestResponseBodyAdvice {
        private static final Logger log = LoggerFactory.getLogger(TestResponseBodyAdvice.class);
    
        public TestResponseBodyAdvice() {
        }
    
        /**
         * 全局异常Exception捕获类
         * @param e
         * @return
         */
        @ExceptionHandler({Exception.class})
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
        public Response uniteExceptionHandler(Exception e) {
            log.error("系统异常", e);
            return Response.builderFail("999", "error");
        }
    
        /**
         * 全局自定义异常TestException捕获类
         * @param e
         * @return
         */
        @ExceptionHandler({TestException.class})
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)//响应状态码500
        public Response businessExceptionHandler(TestException e) {
            log.error(e.getCode(), e.getMessage());
            log.error("系统异常", e);
            return Response.builderFail(e.getCode(), e.getMessage());
        }
    
    
        /**
         *  Dto字段属性校验全局异常类
         * 用法:
         *  @ApiModelProperty(value = "规则模板名称")
         *  @NotNull
         *  @Length(max = 50, message = "名称不得超过50" ,groups = {InsertGroup.class, UpdateGroup.class})
         *  private String templateName;
         *  controller中参数加@Valid注解即可
         */
        @ExceptionHandler({MethodArgumentNotValidException.class})
        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
        public Response uniteExceptionHandler(org.springframework.web.bind.MethodArgumentNotValidException e) {
            log.error("系统异常", e);
            return Response.builderFail("999", e.getBindingResult().getAllErrors().get(0).getDefaultMessage());
        }
    
    }
    

    可能还需要封装一个统一响应对象

    @ApiModel("通用响应对象")
    @JsonSerialize(
            include = JsonSerialize.Inclusion.NON_NULL
    )
    public class Response<T> implements Serializable {
        private static final long serialVersionUID = -4505655308965878999L;
        private static final String successCode = "0";
        @ApiModelProperty("返回的业务对象")
        private T data;
        @ApiModelProperty(
                value = "错误代码,0--成功,其他失败",
                example = "0"
        )
        private String code = "0";
        @ApiModelProperty(
                value = "返回信息描述",
                example = "success"
        )
        private Object msg = "success";
    
        private Response() {
        }
    
        private Response success(T data) {
            this.data = data;
            return this;
        }
    
        private Response fail(String code, Object msg) {
            this.code = code;
            this.msg = msg;
            return this;
        }
    
        public static Response builderSuccess(Object o) {
            return (new Response()).success(o);
        }
    
        public static Response builderFail(String code, Object msg) {
            return (new Response()).fail(code, msg);
        }
    
        public T getData() {
            return this.data;
        }
    
        public String getCode() {
            return this.code;
        }
    
        public Object getMsg() {
            return this.msg;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        public void setCode(String code) {
            this.code = code;
        }
    
        public void setMsg(Object msg) {
            this.msg = msg;
        }
    
        @Override
        public boolean equals(Object o) {
            if (o == this) {
                return true;
            } else if (!(o instanceof Response)) {
                return false;
            } else {
                Response<?> other = (Response)o;
                if (!other.canEqual(this)) {
                    return false;
                } else {
                    label47: {
                        Object this$data = this.getData();
                        Object other$data = other.getData();
                        if (this$data == null) {
                            if (other$data == null) {
                                break label47;
                            }
                        } else if (this$data.equals(other$data)) {
                            break label47;
                        }
    
                        return false;
                    }
    
                    Object this$code = this.getCode();
                    Object other$code = other.getCode();
                    if (this$code == null) {
                        if (other$code != null) {
                            return false;
                        }
                    } else if (!this$code.equals(other$code)) {
                        return false;
                    }
    
                    Object this$msg = this.getMsg();
                    Object other$msg = other.getMsg();
                    if (this$msg == null) {
                        if (other$msg != null) {
                            return false;
                        }
                    } else if (!this$msg.equals(other$msg)) {
                        return false;
                    }
    
                    return true;
                }
            }
        }
    
        protected boolean canEqual(Object other) {
            return other instanceof Response;
        }
    
    //    @Override
    //    public int hashCode() {
            int PRIME = true;
    //        int result = 1;
    //        Object $data = this.getData();
    //        int result = result * 59 + ($data == null ? 43 : $data.hashCode());
    //        Object $code = this.getCode();
    //        result = result * 59 + ($code == null ? 43 : $code.hashCode());
    //        Object $msg = this.getMsg();
    //        result = result * 59 + ($msg == null ? 43 : $msg.hashCode());
    //        return result;
    //    }
    
        @Override
        public String toString() {
            return "Response(data=" + this.getData() + ", code=" + this.getCode() + ", msg=" + this.getMsg() + ")";
        }
    }
    

    5、这样有自定义的异常类,还有全局统一异常捕获类,在运行出错的时候程序要抛出自定义异常,全局异常捕获会自动捕获自定义的异常然后取出异常里面的信息再封装成响应实体对象响应出去,以此达到统一异常响应

    展开全文
  • 49.Java-自定义异常类

    千次阅读 2021-03-15 15:52:25
    为什么需要自定义异常类:我们说了Java中的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己的异常情况来定义异常类.什么是自定义异常类:在开发中根据自己的...
  • JAVA——异常Throwable、抛出异常Throws、制造异常Throw、异常处理try-catch一、概念1、异常Throwable 一、概念 1、异常Throwable 分类 Error 内存不足,硬盘损坏等问题 Exception RunTimeException运行时异常 非...
  • 如果Java的内置类不能满足需求,用户还可以创建自己的异常类。2、异常分为两支,Error和Exception。Error类层次描述了Java运行时系统的内部错误和资源耗尽错误。这种情况很少出现,如果出现了这种情况,就只能通知...
  • 常见的异常类有哪些?

    万次阅读 2019-06-01 00:21:06
    常见的异常类有哪些? 异常非常多,Throwable 是异常的根类。 Throwable 包含子类 错误-Error 和 异常-Exception 。 Exception 又分为 一般异常和运行时异常 RuntimeException。 运行时异常不需要代码显式捕获...
  • C++ 标准异常类和自定义异常类

    千次阅读 2019-05-11 14:01:37
    //标准异常类 #include<iostream> //头文件 #include<stdExcept> using namespace std; /* 标准异常类体系如下: 缩进层次表示继承关系 exception #include <exception> runtime_error #...
  • Java中如何自定义一个异常类

    千次阅读 2020-07-16 17:38:47
    java中可以自定义异常类吗? SUN公司提供的JDK内置的异常类肯定是不够用的。在实际开发中,有很多业务,这些业务出现异常之后,JDK中都是没有的,和业务挂钩的。那么异常类我们可以自己定义吗? 答案是可以的。 java...
  • Java中如何自主定义一个异常类(Exception)并且使用

    万次阅读 多人点赞 2019-04-07 09:17:34
    今天学会了Java中如何自定义一个异常类,还明白了throw/throws,try和catch的用法。 前几天上机课的时候,老师让我们写过一个银行存取钱的系统,今天刚好碰上异常处理,就顺便学会了。 下面是没有加上异常处理的...
  • 日常开发中,当系统提供的异常类型不能满足开发的需求时,就需要自己创建一个新的异常类来拥有自己的异常。 自定义异常类继承自 Exception 类,可以直接继承,或者间接继承。
  • 异常分类:(Throwable:所有异常和错误的父类)● Error:JVM无法解决的严重问题(JVM系统内部错误、资源耗尽等。一般不编写针对性的代码进行处理)● Exception:编程错误或偶然的外在因素导致的一般性问题,可以...
  • 异常类有哪些?

    千次阅读 多人点赞 2018-02-05 09:56:23
    转载自:Java 常见异常种类 1、Error 2、Runtime Exception 运行时异常 3、Exception 4、throw 用户自定义异常 异常类分两大类型:Error...Exception类还包含运行异常类Runtime_Exception和非运行异常类Non_Runtime
  • 为什么需要自定义异常类: 我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩...
  • java 异常分类和处理机制

    万次阅读 多人点赞 2018-06-01 15:08:26
    一、背景介绍 程序在运行过程中发生错误或异常情况是不可避免的,如果每一个运行时错误都由...Java语言定义了很多异常类,将运行错误和异常的信息和处理方法封装在了异常类中,帮助程序员检查和控制异常。即J...
  • Java异常处理之异常类继承层次

    千次阅读 2020-02-10 14:39:37
    目录一、异常类继承层次(1)Throwable类(2)Error和Exception(3)受检查异常和运行时异常 一、异常类继承层次 异常封装成为类Exception,此外,还有Throwable和Error类,异常类继承层次如图19-1所示。 (1)...
  • Java中所有异常的根是Throwable。该有两个子类: Error和Exception。 1.Error Error也称为错误,通常是由JVM错误或者系统奔溃等引起的,无法通过程序来解决,所以在程序中不需要主动捕捉处理。 2....
  • Python异常捕获及自定义异常类

    千次阅读 2019-05-14 00:00:45
    Python异常捕获及自定义异常类 一、什么是异常? 异常是一个与业务逻辑无关的BUG,一个潜在错误或者网络错误事件等,如:尚未实现的函数,缩进错误,Python语法错误等.该事件可能会在程序执行过程中发生,影响程序的...
  • 异常分类和异常处理

    千次阅读 2018-08-07 09:35:17
    异常概述 在java中程序的运行往往会因为设计或者编写过程中引起一些错误的操作,这些错误信息主要包含两种类型 错误(Error):通常是JVM内部...Error和Exception都是从Throwable继承过来 异常分类(Excepti...
  • java自定义异常类

    万次阅读 多人点赞 2018-08-05 20:44:16
    简单介绍一下java中自定义异常类的使用 背景:这里我简单模拟登陆操作,检测到密码不正确则抛出异常 自定义异常类的使用步骤如下: 1、自定义异常类继承Exception类 /** * 自定义异常类 */ public class ...
  • 1.继承Execption异常还是继承RuntimeExecption的区别 想分辨这两种的区别,首先要介绍可检查异常和不可检查异常,何为可检查何不不可检查?可以参考博客Throwable、Exception、Error分析 可检查的异常(checked ...
  • Java——自定义异常类

    千次阅读 2018-05-23 19:32:57
    为什么要自定义异常类?当我们在输入成绩,输入工资,取款的时候,往往都有一个范围,而这个范围不是JVM能够识别的,因此在输入的时候就容易出错,因此在这些时候JDK中的异常无法满足我们的需求,我们只能自己定义...
  • java中Throwable类是所有异常类的父类

    万次阅读 2019-12-03 18:16:41
    Error异常和Exception异常都继承于throwable异常类。 throwable异常类下面分为两个子类:error异常(又名系统异常),和Exception异常(编码,环境,操作异常) Error异常是系统异常(都是非检查异常),主要包括...
  • Java异常类处理

    千次阅读 多人点赞 2020-08-15 15:42:03
    一、Java中异常类的体系结构   1.程序出现异常时正常现象【就跟人会生病一样】   2.Java中异常类Throwable【类】是顶级异常类   3.Throwable【类】有两个子类:     (1)Error【错误】     (2)...
  • 常见的运行时异常分类

    千次阅读 2018-01-07 11:50:30
    常见的异常列出四五种,是基本要求。更多的。。。。需要注意积累了 常见的几种如下: NullPointerException - 空指针引用异常 ClassCastException - 类型强制转换异常。 IllegalArgumentException - 传递非法...
  • 7-2 设计一个Tiangle异常类 (20分)

    千次阅读 2020-12-18 15:37:05
    7-2 设计一个Tiangle异常类 (20分) 创建一个IllegalTriangleException类,处理三角形的三边,任意两边之和小于等于第三边,则显示三条边不符合要求。 然后设计一个有三条边的Triangle的类。如果三条边不符合要求,则...
  • java 第七章 内部类与异常类

    千次阅读 多人点赞 2017-12-10 17:46:09
    1. java支持在一个中定义另一个,这样的称作内部。而包含内部被成为内部的外嵌。 2. 内部与外嵌的重要关系:(1)内部的外嵌的成员变量在内部中仍然有效,内部中的方法也可以调用外...
  • 异常-自定义异常&异常类的抛出

    千次阅读 2019-03-11 23:30:11
    异常类的抛出自定义异常理论异常函数 :调用异常函数 自定义异常理论 例如负数角标这种异常在java中并没有定义过,这时候就要按照java异常的创建思想,面向对象,将负数角标进行自定义的描述。 这种自定义的问题描述...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,921,733
精华内容 768,693
关键字:

异常类

友情链接: test OPC.rar