精华内容
下载资源
问答
  • Java——异常机制

    2021-01-27 19:11:47
    什么是异常1.1 异常概述1.2 异常的分类1.2.1 检查异常1.2.2 运行时异常1.2.3 错误(ERROR)二. 异常体系结构2.1 概述2.2 Error2.3 Exception三. Java异常处理机制3.1 抛出异常3.2 捕获异常3.3 异常处理五个关键字...

    一. 什么是异常

    1.1 异常概述

    实际工作中,遇到的情况不可能是非常完美的。

    比如:你写个某个模块,用户输入不一定符合你的要求、
    	  你的程序要打开某个文件,这个文件可能不存在或者格式不对
    	  你要读取数据库的数据,数据可能是空的
    

    软件程序在运行过程中,非常可能遇到刚刚提到的这些异常问题,我们叫异常(Exception),这些异常情况,怎么让我们写的程序做出合理的处理。而不至于程序崩溃

    异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数

    异常发生在程序运行期间,它影响了正常的程序执行流程

    1.2 异常的分类

    1.2.1 检查性异常

    最具代表的检查性异常是用户错误或问题引起的异常,这是程序员无法预见的。

    例如要打开一个不存在文件时,一个异常就发生了,这些异常在编译时不能被简单地忽略
    

    1.2.2 运行时异常

    运行时异常是可能被程序员避免的异常。与检查性异常相反,运行时异常可以在编译时被忽略

    1.2.3 错误(ERROR)

    错误不是异常,而是脱离程序员控制的问题。错误在代码中通常被忽略。

    例如:当栈溢出时,一个错误就发生了,它们在编译也检查不到的
    

    二. 异常体系结构

    2.1 概述

    Java把异常当作对象来处理,并定于了一个基类java.lang.Throwable作为所有异常的超类

    在Java API中已经定义了许多异常类,这些异常类分为两大类,错误Error和异常Exception
    在这里插入图片描述

    2.2 Error

    Error类对象由Java虚拟机生成并抛出,大多数错误与代码编写者所执行的操作无关

    Java虚拟机运行错误(Virtual MachineError),当JVM不再继续执行操作所需的内存资源时,将出现OutOfMemoryError。这些异常发生时,Java虚拟机(JVM)一般会选择线程终止

    还有发生在虚拟机试图执行应用时,如类定义错误(NoClassDefFoundError)、链接错误(LinkageError)。这些错误是不可查的,因为它们在应用程序的控制和处理能力之外,而且绝大多数是程序运行时不允许出现的状况。

    2.3 Exception

    在Exception分支中有一个重要的子类RuntimeException(运行时异常)

    • ArrayIndexOutOfBoundsException(数组下标越界)
    • NullPointerException(空指针异常)
    • ArithmeticException(算术异常)
    • MissingResourceException(丢失资源)
    • ClassNotFoundException(找不到类)

    这些异常是不检查异常,程序中可以选择捕获处理,也可以不处理

    这些异常一般是由程序逻辑错误引起的,程序应该从逻辑角度尽可能避免这类异常的发生

    Error和Exception区别

    • Error通常是灾难性的致命错误,是程序无法控制和处理的,当出现这些异常时,Java虚拟机一般会选择终止线程
    • Exception通常情况下是可以被程序处理的,并且在程序中应该尽可能的去处理这些异常

    三. Java异常处理机制

    3.1 抛出异常

    package com.exception;
    
    public class Test {
        public static void main(String[] args) {
            int a = 1;
            int b = 0;
    
            //假设要捕获多个异常:要从小到大捕获!
    
            try {   //try监控区域
    
                System.out.println(a/b);
            }catch (Error e){ //catch(想要捕获的异常类型) 捕获异常
                System.out.println("Error");
            }catch (Exception e){
                System.out.println("Exception");
                e.printStackTrace();    //打印错误的栈信息
            }catch (Throwable e){
                System.out.println("Throwable");
            }finally {  //处理善后工作,finally不是必要的,一般用于IO,资源关闭操作
                System.out.println("finally");
            }
        }
    }
    
    

    3.2 捕获异常

    package com.exception;
    
    public class Test {
        public static void main(String[] args) {
            try {
                new Test().test(1,0);
            } catch (ArithmeticException e) {
                e.printStackTrace();
            }
        }
    
        //假设这个方法中,处理不了这个异常,方法上抛出异常
        public void test(int a ,int b) throws ArithmeticException{
            if (b == 0){   //throw throws
                throw new ArithmeticException();//主动的抛出异常,一般在方法体中使用
            }
            
        }
    }
    
    

    3.3 异常处理五个关键字

    try catch finally throw throws

    四. 自定义异常

    4.1 概述

    使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外,用户还可以自定义异常。用户自定义异常类,只需继承Exception类即可

    在程序中使用自定义异常类,大体可分为以下几个步骤:

    1. 创建自定义异常
    2. 在方法中通过throw关键字抛出异常对象
    3. 如果在当前抛出异常的方法中处理异常,可以使用try-catch语句捕获并处理;否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常,继续进行下一步操作
    4. 在出现异常方法的调用者中捕获并处理异常

    4.2 举例

    在这里插入图片描述

    五. 实际应用中的经验总结

    • 处理运行时异常时,采用逻辑去合理规避同时辅助try-catch处理
    • 在多重catch块后面,可以加一个catch(Exception)来处理可能会被遗漏的异常
    • 对于不确定的代码,也可以加上try-catch,处理潜在的异常
    • 尽量去处理异常,切记不要只是简单地调用printStackTrace()去打印输出
    • 具体如何处理异常,要根据不同的业务需求和异常类型去决定
    • 尽量添加finally语句块去释放占用资源
    展开全文
  • java异常异常处理

    2017-01-16 17:27:34
    异常父类 :Throwable 其下主要两大子类:...Exception其下子类主要包括非检查异常(RuntimeException)和检查异常,非检查异常主要包括空指针异常,数组下标越界异常,类型转换异常,算术异常。 举例算术异常: pa

    异常父类 :Throwable   其下主要两大子类:Error  ,Exception

    Error主要包括系统错误,如虚拟机错误,线程死锁等,Exception主要指 编码,环境,用户操作输入出现问题。

    Exception其下子类主要包括非检查异常(RuntimeException)和检查异常,非检查异常主要包括空指针异常,数组下标越界异常,类型转换异常,算术异常。

    举例算术异常:

    package yh;
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		int a=9,b=0;
    		System.out.println(a/b); 
    	}
    }

    编译如下:


    可见系统自动抛出异常


    检查异常不同于非检查异常,它需要用户自己捕获异常并处理异常。常用try...catch语句捕获异常。

    示例:

    package yh;
    
    import java.util.InputMismatchException;
    import java.util.Scanner;
    
    public class Test {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Scanner in = new Scanner(System.in);
    		int a,b;
    		try{
    			System.out.println("请输入第一个整数:");
    			a=in.nextInt();
    			System.out.println("请输入第二个非0整数:");
    			b=in.nextInt();
    			System.out.println("相除结果="+a/b);
    		}catch(InputMismatchException e){
    			System.out.println("请输入整数!");
    		}catch(ArithmeticException e){
    			System.out.println("分母不能为0!");
    		}finally{
    			System.out.println("总会执行!");
    		}
    		
    	}
    }
    


    展开全文
  • Java异常

    2017-11-14 22:40:00
    * 异常:程序出现了不正常的情况。 * * 举例:今天天气很好,班长出去旅游。骑着自行车,去山里面呼吸新鲜空气。 * 问题1:山路塌陷了,班长及时停住了,但是过不去了。严重的问题。 * 问题2:班长出门推自行车...
    package cn.itcast_01;
     
    /*
    * 异常:程序出现了不正常的情况。
    *
    * 举例:今天天气很好,班长出去旅游。骑着自行车,去山里面呼吸新鲜空气。
    * 问题1:山路塌陷了,班长及时停住了,但是过不去了。严重的问题。
    * 问题2:班长出门推自行车,发现气没了,把气吹起来。出发前就应该检查的问题。
    * 问题3:班长骑着车在山路上惬意的行驶着,山路两边是有小石子的,中间是平坦的水泥路。
    * 一直在平坦的水泥路上行驶是没有任何问题的,但是呢,他偏偏喜欢骑到小石子上,结果爆胎了。旅游的过程中出现的问题。
    * no zuo no die。
    *
    * 程序的异常:Throwable
    * 严重问题:Error 我们不处理。这种问题一般都是很严重的,比如说内存溢出。
    * 问题:Exception
    * 编译期问题:不是RuntimeException的异常 必须进行处理的,因为你不处理,编译就不能通过。
    * 运行期问题:RuntimeException 这种问题我们也不处理,因为是你的问题,而且这个问题出现肯定是我们的代码不够严谨,需要修正代码的。
    *
    * 如何程序出现了问题,我们没有做任何处理,最终jvm会做出默认的处理。
    * 把异常的名称,原因及出现的问题等信息输出在控制台。
    * 同时会结束程序。
    */
    public class ExceptionDemo {
    public static void main(String[] args) {
    //第一阶段
    int a = 10;
    // int b = 2;
    int b = 0;
    System.out.println(a / b);
     
    //第二阶段
    System.out.println("over");
    }
    }
    ==============================================================
    package cn.itcast_02;
     
    /*
    * A:一个异常
    * B:二个异常的处理
    * a:每一个写一个try...catch
    * b:写一个try,多个catch
    * try{
    * ...
    * }catch(异常类名 变量名) {
    * ...
    * }
    * catch(异常类名 变量名) {
    * ...
    * }
    * ...
    *
    * 注意事项:
    * 1:能明确的尽量明确,不要用大的来处理。
    * 2:平级关系的异常谁前谁后无所谓,如果出现了子父关系,父必须在后面。
    *
    * 注意:
    * 一旦try里面出了问题,就会在这里把问题给抛出去,然后和catch里面的问题进行匹配,
    * 一旦有匹配的,就执行catch里面的处理,然后结束了try...catch
    * 继续执行后面的语句。
    */
    public class ExceptionDemo2 {
    public static void main(String[] args) {
    // method1();
     
    // method2();
     
    // method3();
     
    method4();
    }
     
    public static void method4() {
    int a = 10;
    int b = 0;
    int[] arr = { 1, 2, 3 };
     
    // 爷爷在最后
    try {
    System.out.println(a / b);
    System.out.println(arr[3]);
    System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
    } catch (ArithmeticException e) {
    System.out.println("除数不能为0");
    } catch (ArrayIndexOutOfBoundsException e ) {
    System.out.println("你访问了不该的访问的索引");
    } catch (Exception e) {
    System.out.println("出问题了");
    }
     
    // 爷爷在前面是不可以的
    // try {
    // System.out.println(a / b);
    // System.out.println(arr[3]);
    // System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
    // } catch (Exception e) {
    // System.out.println("出问题了");
    // } catch (ArithmeticException e) {
    // System.out.println("除数不能为0");
    // } catch (ArrayIndexOutOfBoundsException e) {
    // System.out.println("你访问了不该的访问的索引");
    // }
     
    System.out.println("over");
    }
     
    // 两个异常的处理
    public static void method3() {
    int a = 10;
    int b = 0;
    int[] arr = { 1, 2, 3 };
     
    try {
    System.out.println(arr[3]);
    System.out.println(a / b);
    // System.out.println(arr[3]);
    } catch (ArithmeticException e) {
    System.out.println("除数不能为0");
    } catch (ArrayIndexOutOfBoundsException e) {
    System.out.println("你访问了不该的访问的索引");
    }
     
    System.out.println("over");
    }
     
    // 两个异常
    public static void method2() {
    int a = 10;
    int b = 0;
    try {
    System.out.println(a / b);
    } catch (ArithmeticException e) {
    System.out.println("除数不能为0");
    }
     
    int[] arr = { 1, 2, 3 };
    try {
    System.out.println(arr[3]);
    } catch (ArrayIndexOutOfBoundsException aec) {
    System.out.println("你访问了不该的访问的索引");
    }
     
    System.out.println("over");
    }
     
    // 一个异常
    public static void method1() {
    // 第一阶段
    int a = 10;
    // int b = 2;
    int b = 0;
     
    try {
    System.out.println(a / b);
    } catch (ArithmeticException ae) {
    System.out.println("除数不能为0");
    }
     
    // 第二阶段
    System.out.println("over");
    }
    }
     
    除数不能为0
    over
    只能访问第一个
    =========================================
    package cn.itcast_02;
     
    /*
    * JDK7出现了一个新的异常处理方案:
    * try{
    *
    * }catch(异常名1 | 异常名2 | ... 变量 ) {
    * ...
    * }
    *
    * 注意:这个方法虽然简洁,但是也不够好。
    * A:处理方式是一致的。(实际开发中,好多时候可能就是针对同类型的问题,给出同一个处理)
    * B:多个异常间必须是平级关系。
    */
    public class ExceptionDemo3 {
    public static void main(String[] args) {
    method();
    }
     
    public static void method() {
    int a = 10;
    int b = 0;
    int[] arr = { 1, 2, 3 };
     
    // try {
    // System.out.println(a / b);
    // System.out.println(arr[3]);
    // System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
    // } catch (ArithmeticException e) {
    // System.out.println("除数不能为0");
    // } catch (ArrayIndexOutOfBoundsException e) {
    // System.out.println("你访问了不该的访问的索引");
    // } catch (Exception e) {
    // System.out.println("出问题了");
    // }
     
    // JDK7的处理方案
    try {
    System.out.println(a / b);
    System.out.println(arr[3]);
    } catch (ArithmeticException | ArrayIndexOutOfBoundsException e) {
    System.out.println("出问题了");
    }
     
    System.out.println("over");
    }
     
    }
    =====================================================================
    package cn.itcast_03;
     
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
     
    /*
    * 编译时异常和运行时异常的区别
    * 编译期异常:Java程序必须显示处理,否则程序就会发生错误,无法通过编译
    * 运行期异常:无需显示处理,也可以和编译时异常一样处理
    */
    public class ExceptionDemo {
    public static void main(String[] args) {
    // int a = 10;
    // int b = 0;
    // if (b != 0) {
    // System.out.println(a / b);
    // }
     
    String s = "2014-11-20";
    // SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    // Date d = sdf.parse(s);
    try {
    Date d = sdf.parse(s);
    System.out.println(d);
    } catch (ParseException e) {
    // e.printStackTrace();
    System.out.println("解析日期出问题了");
    }
    }
    }
    =========================================
    package cn.itcast_04;
     
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
     
    /*
    * 在try里面发现问题后,jvm会帮我们生成一个异常对象,然后把这个对象抛出,和catch里面的类进行匹配。
    * 如果该对象是某个类型的,就会执行该catch里面的处理信息。
    *
    * 异常中要了解的几个方法:
    * public String getMessage():异常的消息字符串
    * public String toString():返回异常的简单信息描述
    * 此对象的类的 name(全路径名)
    * ": "(冒号和一个空格)
    * 调用此对象 getLocalizedMessage()方法的结果 (默认返回的是getMessage()的内容)
    * printStackTrace() 获取异常类名和异常信息,以及异常出现在程序中的位置。返回值void。把信息输出在控制台。
    */
    public class ExceptionDemo {
    public static void main(String[] args) {
    String s = "2014-11-20";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    try {
    Date d = sdf.parse(s); // 创建了一个ParseException对象,然后抛出去,和catch里面进行匹配
    System.out.println(d);
    } catch (ParseException e) { // ParseException e = new ParseException();
    // ParseException
    // e.printStackTrace();
     
    // getMessage()
    // System.out.println(e.getMessage());
    // Unparseable date: "2014-11-20"
     
    // toString()
    // System.out.println(e.toString());
    // java.text.ParseException: Unparseable date: "2014-11-20"
     
    e.printStackTrace();
    //跳转到某个指定的页面(index.html)
    java.text.ParseException: Unparseable date: "2016-09-7"
    at java.text.DateFormat.parse(DateFormat.java:366)
    at cn.itcast_01.ExceptionDemo3.main(ExcepjtionDemo3.java:14)
     
    }
     
    System.out.println("over");
    }
    }
    ========================================
    package cn.itcast_05;
     
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
     
    /*
    * 有些时候,我们是可以对异常进行处理的,但是又有些时候,我们根本就没有权限去处理某个异常。
    * 或者说,我处理不了,我就不处理了。
    * 为了解决出错问题,Java针对这种情况,就提供了另一种处理方案:抛出。
    *
    * 格式:
    * throws 异常类名
    * 注意:这个格式必须跟在方法的括号后面。
    *
    * 注意:
    * 尽量不要在main方法上抛出异常。
    * 但是我讲课为了方便我就这样做了。
    *
    * 小结:
    * 编译期异常抛出,将来调用者必须处理。
    * 运行期异常抛出,将来调用可以不用处理。
    */
    public class ExceptionDemo {
    public static void main(String[] args) {
    System.out.println("今天天气很好");
    try {
    method();
    } catch (ParseException e) {
    e.printStackTrace();
    }
    System.out.println("但是就是不该有雾霾");
     
    method2();
    }
     
    // 运行期异常的抛出
    public static void method2() throws ArithmeticException {
    int a = 10;
    int b = 0;
    System.out.println(a / b);
    }
     
    // 编译期异常的抛出
    // 在方法声明上抛出,是为了告诉调用者,你注意了,我有问题。
    public static void method() throws ParseException {
    String s = "2014-11-20";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date d = sdf.parse(s);
    System.out.println(d);
    }
    }
    ===========================================================================package cn.itcast_06;
     
    /*
    * throw:如果出现了异常情况,我们可以把该异常抛出,这个时候的抛出的应该是异常的对象。
    *
    * throws和throw的区别(面试题)
    throws
    用在方法声明后面,跟的是异常类名
    可以跟多个异常类名,用逗号隔开
    表示抛出异常,由该方法的调用者来处理
    throws表示出现异常的一种可能性,并不一定会发生这些异常
    throw
    用在方法体内,跟的是异常对象名
    只能抛出一个异常对象名
    表示抛出异常,由方法体内的语句处理
    throw则是抛出了异常,执行throw则一定抛出了某种异常
    */
    public class ExceptionDemo {
    public static void main(String[] args) {
    // method();
     
    try {
    method2();
    } catch (Exception e) {
    e.printStackTrace();
    }
    }
     
    public static void method() {
    int a = 10;
    int b = 0;
    if (b == 0) {
    throw new ArithmeticException();
    } else {
    System.out.println(a / b);
    }
    }
     
    public static void method2() {
    int a = 10;
    int b = 0;
    if (b == 0) {
    throw new ArithmeticException();
    } else {
    System.out.println(a / b);
    }
    }
    ==============================================================
    package cn.itcast_07;
     
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
     
    /*
    * finally:被finally控制的语句体一定会执行
    * 注意:如果在执行到finally之前jvm退出了,就不能执行了。
    *
    * A:格式
    * try...catch...finally...
    * B:用于释放资源,在IO流操作和数据库操作中会见到
    */
    public class FinallyDemo {
    public static void main(String[] args) {
    String s = "2014-11-20";
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
     
    Date d = null;
    try {
    // System.out.println(10 / 0);
    d = sdf.parse(s);
    } catch (ParseException e) {
    e.printStackTrace();
    System.exit(0); //退出
    } finally {
    System.out.println("这里的代码是可以执行的");
    }
     
    System.out.println(d);
    }
    }
    ==============================================================
    package cn.itcast_07;
     
    /*
    * 面试题:
    * 1:final,finally和finalize的区别
    * final:最终的意思,可以修饰类,成员变量,成员方法
    * 修饰类,类不能被继承
    * 修饰变量,变量是常量
    * 修饰方法,方法不能被重写
    * finally:是异常处理的一部分,用于释放资源。
    * 一般来说,代码肯定会执行,特殊情况:在执行到finally之前jvm退出了
    * finalize:是Object类的一个方法,用于垃圾回收
    *
    * 2:如果catch里面有return语句,请问finally里面的代码还会执行吗?
    * 如果会,请问是在return前,还是return后。
    * 会。前。
    *
    * 准确的说,应该是在中间。
    *
    * 3:try...catch...finally的格式变形
    * A:try...catch...finally
    * B:try...catch
    * C:try...catch...catch...
    * D:try...catch...catch...finally
    * E:try...finally
    * 这种做法的目前是为了释放资源。
    */
    public class FinallyDemo2 {
    public static void main(String[] args) {
    System.out.println(getInt());
    }
     
    public static int getInt() {
    int a = 10;
    try {
    System.out.println(a / 0);
    a = 20;
    } catch (ArithmeticException e) {
    a = 30;
    return a;
    /*
    * return a在程序执行到这一步的时候,这里不是return a而是return 30;这个返回路径就形成了。
    * 但是呢,它发现后面还有finally,所以继续执行finally的内容,a=40
    * 再次回到以前的返回路径,继续走return 30;
    */
    } finally {
    a = 40;
    return a;//如果这样结果就是
    }
     
    ======================================================================================
    package cn.itcast_07;
     
    /*
    * 面试题:
    * 1:final,finally和finalize的区别
    * final:最终的意思,可以修饰类,成员变量,成员方法
    * 修饰类,类不能被继承
    * 修饰变量,变量是常量
    * 修饰方法,方法不能被重写
    * finally:是异常处理的一部分,用于释放资源。
    * 一般来说,代码肯定会执行,特殊情况:在执行到finally之前jvm退出了
    * finalize:是Object类的一个方法,用于垃圾回收
    *
    * 2:如果catch里面有return语句,请问finally里面的代码还会执行吗?
    * 如果会,请问是在return前,还是return后。
    * 会。前。
    *
    * 准确的说,应该是在中间。
    *
    * 3:try...catch...finally的格式变形
    * A:try...catch...finally
    * B:try...catch
    * C:try...catch...catch...
    * D:try...catch...catch...finally
    * E:try...finally
    * 这种做法的目前是为了释放资源。
    */
    public class FinallyDemo2 {
    public static void main(String[] args) {
    System.out.println(getInt());
    }
     
    public static int getInt() {
    int a = 10;
    try {
    System.out.println(a / 0);
    a = 20;
    } catch (ArithmeticException e) {
    a = 30;
    return a;
    /*
    * return a在程序执行到这一步的时候,这里不是return a而是return 30;这个返回路径就形成了。
    * 但是呢,它发现后面还有finally,所以继续执行finally的内容,a=40
    * 再次回到以前的返回路径,继续走return 30;
    */
    } finally {
    a = 40;
    return a;//如果这样结果就是40了。
    }
    // return a;
    }
    }
    ===========================================================================package cn.itcast_08;
     
    /*
    * java不可能对所有的情况都考虑到,所以,在实际的开发中,我们可能需要自己定义异常。
    * 而我们自己随意的写一个类,是不能作为异常类来看的,要想你的类是一个异常类,就必须继承自Exception或者RuntimeException
    *
    * 两种方式:
    * A:继承Exception
    * B:继承RuntimeException
    */
    public class MyException extends Exception {
    public MyException() {
    }
     
    public MyException(String message) {
    super(message);
    }
    }
     
    // public class MyException extends RuntimeException {
    //
    // }
    ===========================================================================package cn.itcast_08;
     
    import java.util.Scanner;
     
    /*
    * 自定义异常测试类
    */
    public class StudentDemo {
    public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.println("请输入学生成绩:");
    int score = sc.nextInt();
     
    Teacher t = new Teacher();
    try {
    t.check(score);
    } catch (MyException e) {
    e.printStackTrace();
    }
    }
    }
     
    package cn.itcast_08;
     
    public class Teacher {
    public void check(int score) throws MyException {
    if (score > 100 || score < 0) {
    throw new MyException("分数必须在0-100之间");
    } else {
    System.out.println("分数没有问题");
    }
    }
     
    // 针对MyException继承自RuntimeException
    // public void check(int score) {
    // if (score > 100 || score < 0) {
    // throw new MyException();
    // } else {
    // System.out.println("分数没有问题");
    // }
    // }
    }
     
    package cn.itcast_08;
     
    /*
    * java不可能对所有的情况都考虑到,所以,在实际的开发中,我们可能需要自己定义异常。
    * 而我们自己随意的写一个类,是不能作为异常类来看的,要想你的类是一个异常类,就必须继承自Exception或者RuntimeException
    *
    * 两种方式:
    * A:继承Exception
    * B:继承RuntimeException
    */
    public class MyException extends Exception {
    public MyException() {
    }
     
    public MyException(String message) {
    super(message);
    }
    }
     
    // public class MyException extends RuntimeException {
    //
    // }
    ===========================================================================package cn.itcast_09;
     
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
     
    /*
    * 异常注意事项:
    * A:子类重写父类方法时,子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
    * B:如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
    * C:如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
    */
    public class ExceptionDemo {
     
    }
     
    class Fu {
    public void show() throws Exception {
    }
     
    public void method() {
    }
    }
     
    class Zi extends Fu {
    @Override
    public void show() throws ArithmeticException {
     
    }
     
    @Override
    public void method() {
    // String s = "2014-11-20";
    // SimpleDateFormat sdf = new SimpleDateFormat();
    // Date d = sdf.parse(s);
    // System.out.println(d);
    }
    }
     

    转载于:https://www.cnblogs.com/yejibigdata/p/7835174.html

    展开全文
  • java异常处理

    2013-05-04 14:00:00
    java中的异常分为:编译时检查异常(checked exception)和非检查异常(unchecked exception,又称作运行时异常)。 这两者有什么区别呢?,举例说明:  编译时检查异常:最经常遇到的就是IO异常和SQL...

    java中的异常分为:编译时检查性异常(checked exception)和非检查性异常(unchecked exception,又称作运行时异常)。

     

    这两者有什么区别呢?,举例说明:

      编译时检查行异常:最经常遇到的就是IO异常和SQL异常,对于检查性异常,程序必须进行处理,否则编译器会指出错误。这里就需要我们进行异常catch,并进行相应的处理。

      运行时异常:就是RuntimeException,比如:被零除等系统错误、数组下标超范围、空指针异常等,这些有系统进行检测,程序可以不进行处理,交由系统进行缺省处理,当然,必要时,可以对其进行处理。

     

    RuntimeException异常在java.lang包下:

    下面是由java虚拟机提供的运行时异常

    AnnotationTypeMismatchException, 
    ArithmeticException, 
    ArrayStoreException, 
    BufferOverflowException, 
    BufferUnderflowException, 
    CannotRedoException, 
    CannotUndoException, 
    ClassCastException, 
    CMMException, 
    ConcurrentModificationException, 
    DOMException, 
    EmptyStackException, 
    EnumConstantNotPresentException, 
    EventException, 
    IllegalArgumentException, 
    IllegalMonitorStateException, 
    IllegalPathStateException, 
    IllegalStateException, 
    ImagingOpException, 
    IncompleteAnnotationException, 
    IndexOutOfBoundsException, 
    JMRuntimeException, 
    LSException, 
    MalformedParameterizedTypeException, 
    MirroredTypeException, 
    MirroredTypesException, 
    MissingResourceException, 
    NegativeArraySizeException, 
    NoSuchElementException, 
    NoSuchMechanismException, 
    NullPointerException, 
    ProfileDataException, 
    ProviderException, 
    RasterFormatException, 
    RejectedExecutionException, 
    SecurityException, 
    SystemException, 
    TypeConstraintException, 
    TypeNotPresentException, 
    UndeclaredThrowableException, 
    UnknownAnnotationValueException, 
    UnknownElementException, 
    UnknownTypeException, 
    UnmodifiableSetException, 
    UnsupportedOperationException, 
    WebServiceException 

    我们平时常见的异常主要有五大异常:

    ClassCastException(类转换异常)

    IndexOutBoundsException(数组越界异常)

    NullPointException(空指针异常)

    ArrayStoreException(数据存储异常,操作数据类型不一致)

    BufferOverflowException(IO操作异常)

     

    转载于:https://www.cnblogs.com/kasery/archive/2013/05/04/3059425.html

    展开全文
  • java异常处理

    2018-11-12 17:31:56
    异常:程序出现了不正常的情况  举例:  今天天气很好,班长出去旅游。骑着偷来的摩拜。去火炉山接近大自然,吸收新鲜空气。  问题1:火炉山塌陷了,班长及时踩住了刹车,但是去不了火炉山了。严重问题  问题2:班长...
  • Java异常的处理

    2018-05-15 17:19:35
    当程序出现一些问题的,可以是严重问题,可以是一种异常,将这些通常为ThrowableThrowable 类是 Java 语言中所有错误或异常的超类 Throwable 1.error 2.exception举例: 张三去山上旅行 1)张三骑车去旅行,山路...
  • java复习-异常

    2021-01-01 11:39:17
    java复习–异常 Error:错误,由JVM生成并抛出,如虚拟机错误,程序不做处理(少见)。 1 Exception:所有异常类的父类(可以处理的错误)。 2 RuntimeException 未检查(unchecked)异常 经常出的错误 不能由编译器...
  • Java面试题-异常

    2020-06-05 10:45:39
    什么是检查异常,不受检查异常,运行时异常?并分别举例说明。 Finally块一定会执行吗? 正常情况下,当在try块或catch块中遇到return语句时,finally语句在方法返回之前还是之后被执行? Try、catch、finally...
  • Java异常处理相关

    2019-04-11 20:57:22
    举例:某个星期日,天气晴朗,万里无云。我就打算去自驾游。(凤凰牌) 1. 我在山上骑着车,突然山崩了,道路崩塌了。(我无能为力,天灾人祸) 2. 我打开锁时,发现轮胎没气了。(我可以充气,而且应该在事前检查一下) 3....
  • 但是后来随着学习与工作的深入,发现异常本身真是个好东西,有了异常机制,我们节省了大量的代码去检查错误,降低了错误的复杂度。一个健壮的程序必须包含异常处理部分。 异常情形是指阻止当前方法或作用域继续执行...
  • 34 举例:今天天气很好,班长出去旅游。骑着自行车,去山里面呼吸新鲜空气。5 Error:6 问题1:山路塌陷了,班长及时停住了,但是过不去了。严重的问题。(Error,编译处理不了的)7 Exception:8 问题2:班长出门推...
  • JSP代码中通常有以下几类异常: 检查异常:检查异常就是一个典型的用户错误或者一个程序员无法预见的错误。举例来说,如果一个文件将要被打开,但是无法找到这个文件,则一个异常被抛出。这些异常不能再编译期被...
  • 1.重写(Override) 重写是子类对父类当中允许...例如:父类的一个方法申明了一个检查异常 IOException,但是在重写这个方法的时候不能抛出 Exception 异常,因为 Exception 是 IOException 的父类,只能抛出 IOExce
  • Java IO流(1)之异常

    2018-04-20 22:39:57
    异常 (1)程序出现的不正常的情况。/* * 举例:今天天气很好,班长出去旅游。骑着自行车,去山里面呼吸新鲜空气。 * 问题1:山路塌陷了,班长及时停住了,但是过不去了。严重的问题。 * 问题2:班长出门推...
  • ------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ------- 一、异常   程序出现了不正常的情况。   举例:今天天气很好,班长出去旅游。骑着自行车,去山里面呼吸新鲜空气。 问题1:山路...
  • * 异常:程序出现了不正常的情况。 * * 举例:今天天气很好, 班长出去旅游,骑着自行车,去山里面呼吸新鲜空气 * 问题1:山路塌陷了,班长即使停住了,但是过不去了。严重的问题 * 问题2:班长出门推自行车,...
  • 异常

    2018-05-17 22:28:05
    异常的处理当程序出现一些问题的,可以是严重问题,可以是一种异常,将这些通常为Throwable Throwable 类是 Java 语言中所有错误或异常的超类 Throwable error exception 举例: 张三去山上旅行 1)张三骑车去旅行...
  • 异常 在Java中根据错误严重程度的不同,可以将其分为错误和异常。错误是程序无法处理的,所有错误继承自Error类;异常是程序可以捕获和处理的,所有异常继承自Exception类。...非检查异常举例 Arit
  • 自定义异常详解

    2018-04-25 14:14:18
    Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。所有异常都必须是 Throwable 的子类。如果希望写一个检查异常类,则需要继承 Exception 类。如果你想写一个运行时异常类,那么需要继承 ...
  • 疯狂JAVA讲义

    2014-10-17 13:35:01
    8.1.1 编译时不检查类型的异常 292 8.1.2 手动实现编译时检查类型 293 8.1.3 使用泛型 294 8.2 深入泛型 294 8.2.1 定义泛型接口、类 295 8.2.2 从泛型类派生子类 296 8.2.3 并不存在泛型类 298 8.3 类型...
  • POJO 类属性没有初值是提醒使用者在需要使用时,必须自己显式地进行赋值,任何NPE(NullPointerException,空指针异常) 问题,或者入库检查,都由使用者来保证。 2、举例说明 正例: (1)所有的sql使用的默认...
  • java面试题典 java 面试题 经典

    热门讨论 2010-06-18 13:42:36
    39. JAVA语言如何进行异常处理,关键字:throws,throw,try,catch,finally分别代表什么意义?在try块中可以抛出异常吗? 14 40. 一个".java"源文件中是否可以包括多个类(不是内部类)?有什么限制? 可以。必须只有...
  • Java中Exception 和 Error 的区别 文章目录Java中Exception 和 Error 的区别经典回答:Exception 和 Error 举例备注:1.... 为什么RuntimeException及其子类是非检查异常,RuntimeException 不也是继承自Excep...
  • 3.异常与调试工具

    2011-08-01 12:06:00
    Error和RuntimeException称为未检查异常,其他为已检查异常。 根ThrowableError 系统内部错误,需要尽量避免Exception(1)RuntimeException 能够避免的错误,如果有错编译器还是能够通过编译,并且能够被捕获。 ...
  • JAVA中的IO流

    2019-08-25 17:20:03
    举例:今天天气很好,班长出去旅游。骑着自行车,去山里面呼吸新鲜空气。 问题1:山路塌陷了,班长及时停住了,但是过不去了。严重的问题。 问题2:班长出门推自行车,发现气没了,把气吹起来。出发前就应该...
  • java 面试题 总结

    2009-09-16 08:45:34
    java编译器要求方法必须声明抛出可能发生的非运行时异常,但是并不要求必须声明抛出未被捕获的运行时异常。 6、说出Servlet的生命周期,并说出Servlet和CGI的区别。 Servlet被服务器实例化后,容器运行其init方法,...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    50.JAVA语言如何进行异常处理,关键字:thorws,throw,try,catch,finally 51.Object类(或者其子类)的finalize()方法在什么情况下被调用? 52.一个“.java”原文件中是否可以包括多个类(不是内部类)? 53.掌握...
  • 有时候,我们调用第三方或者心跳检查时需要进行失败的重试机制,现在我就举例: private static final int retryLimit = 5; while (true) try { //调用其他的接口 break; } catch (Exception e) {//根据...

空空如也

空空如也

1 2 3 4
收藏数 61
精华内容 24
关键字:

java检查异常举例

java 订阅