AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

[零基础学JAVA]Java SE面向对象部分-20.异常的捕获与处理

2017-11-19 1003
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：
异常的概念
image
指程序中断执行的一种指令流
public  class Demo01    
{    
         public  static  void main(String args[])    
        {    
                 int i = 0;    
                 int j = 10;    
                System.out.println( "程序代码执行之前~~~");    
                System.out.println(i/j);    
                System.out.println( "程序代码执行之后~~~");    
        }    
}
image
现在我们反过来哈，j/i
public  class Demo01    
{    
         public  static  void main(String args[])    
        {    
                 int i = 0;    
                 int j = 10;    
                System.out.println( "程序代码执行之前~~~");    
                System.out.println(j/i);    
                System.out.println( "程序代码执行之后~~~");    
        }    
}
image
异常一旦发生，则在异常发生处之后的所有代码都不再被执行了。
异常的分类
image
只要一发生了异常，则肯定会抛出一个异常类的实例化对象。 
面试问题：RuntimeException与 Exception的区别： 
  ·  RuntimeException表示异常可以由JVM进行处理 
  ·  Exception：表示用户可以自行处理 
  · 实际上两个异常并没有太多的区别，用户都是可以处理的。 
  ·  Error：不能由用户自行处理的异常。
image
捕获异常(1)
image
public  class Demo02    
{    
         public  static  void main(String args[])    
        {    
                 int i = 0;    
                 int j = 10;    
                System.out.println( "程序代码执行之前~~~");    
                 try    
                {    
                         //下面跟上可能发生错误的代码段    
                        System.out.println(j/i);    
                        System.out.println( "-------------------");    
                }    
                 catch (ArithmeticException ae)    
                {    
                         //进行异常处理    
                        System.out.println( "运算发生了异常~~~");    
                }    
                System.out.println( "程序代码执行之后~~~");    
        }    
}
image
加入异常处理之后，程序可以正常的执行完，也可以正常的捕获错误了，但是在try语句中，在发生异常的地方就进行跳转了，所以异常发生语句之后的代码不会被执行。
如果程序中有多个异常要处理呢？ 
注意：一个新的操作：将字符串的内容变为数字。
public  class Demo03    
{    
         public  static  void main(String args[])    
        {    
                String str =  "123";    
                 //将字符串变为数字    
                 int i = Integer.parseInt(str);    
                System.out.println(i*2);    
        }    
}
image
在此代码之中，要求字符串的内容必须是由数字组成的。
如果不全是数字，我们来看下效果
public  class Demo03    
{    
         public  static  void main(String args[])    
        {    
                String str =  "123a";    
                 //将字符串变为数字    
                 int i = Integer.parseInt(str);    
                System.out.println(i*2);    
        }    
}
image
要求： 
  要求可以在JAVA运行程序的后面加入运行时参数，参数为两个数相除的内容。
public  class Demo04    
{    
         public  static  void main(String args[])    
        {    
                 //从运行时处接收参数    
                 int i = Integer.parseInt(args[0]);    
                 int j = Integer.parseInt(args[1]);    
                System.out.println( "程序代码执行之前~~~");    
                 try    
                {    
                         //下面跟上可能发生错误的代码段    
                        System.out.println(i/j);    
                        System.out.println( "-------------------");    
                }    
                 catch (ArithmeticException ae)    
                {    
                         //进行异常处理    
                        System.out.println( "运算发生了异常~~~");    
                }    
                System.out.println( "程序代码执行之后~~~");    
        }    
}
image
在以上的程序之中可能存在那些问题呢？ 
  · 如果没有输入参数的时候，则会有错误： ArrayIndexOutOfBoundsException（数组下标越界）
image 
  · 如果输入的参数的内容不是数字，则会有错误： NumberFormatException（数字格式化异常）
image 
  · 如果输入的被除数为零，则会有错误： ArithmeticException（算术异常）
image 
则此程序代码只有一个catch肯定是不够的，需要处理多个异常。
public  class Demo05    
{    
         public  static  void main(String args[])    
        {    
                 //从运行时处接收参数    
                 int i = 0;    
                 int j = 0;    
                System.out.println( "程序代码执行之前~~~");    
                 try    
                {    
                        i=Integer.parseInt(args[0]);    
                        j=Integer.parseInt(args[1]);    
                         //下面跟上可能发生错误的代码段    
                        System.out.println(i/j);    
                        System.out.println( "-------------------");    
                }    
                 catch(ArithmeticException ae)    
                {    
                         //进行异常处理    
                        System.out.println(ae);    
                        System.out.println( "1.运算发生了异常~~~");    
                }    
                 catch(NumberFormatException ne)    
                {    
                        System.out.println(ne);    
                        System.out.println( "2.输入的内容不是数字~~~");    
                }    
                 catch(ArrayIndexOutOfBoundsException ae)    
                {    
                        System.out.println(ae);    
                        System.out.println( "3.输入的参数个数不正确~~~");    
                }    
                System.out.println( "程序代码执行之后~~~");    
        }    
}
image
以上的程序只要是有异常发生了，则会自动找到对应的catch语句，分别进行处理，但是一个程序可能会存在各种问题，那么有可能全部的catch都写出来吗？
image ArithmeticException是Exception的子类哈~ image
public  class Demo06    
{    
         public  static  void main(String args[])    
        {    
                 //从运行时处接收参数    
                 int i = 0;    
                 int j = 0;    
                System.out.println( "程序代码执行之前~~~");    
                 try    
                {    
                        i=Integer.parseInt(args[0]);    
                        j=Integer.parseInt(args[1]);    
                         //下面跟上可能发生错误的代码段    
                        System.out.println(i/j);    
                        System.out.println( "-------------------");    
                }    
                 catch(ArithmeticException ae)    
                {    
                         //进行异常处理    
                        System.out.println(ae);    
                        System.out.println( "1.运算发生了异常~~~");    
                }    
                 catch(NumberFormatException ne)    
                {    
                        System.out.println(ne);    
                        System.out.println( "2.输入的内容不是数字~~~");    
                }    
                 catch(ArrayIndexOutOfBoundsException ae)    
                {    
                        System.out.println(ae);    
                        System.out.println( "3.输入的参数个数不正确~~~");    
                }    
                 catch(Exception e)    
                {    
                        System.out.println( "异常处理");    
                }    
                System.out.println( "程序代码执行之后~~~");    
        }    
}
image
以上代码需要注意： 
  在异常处理中，对于catch语句要求处理更粗的异常要放在处理更细的异常之后。
我们验证下效果哈~
public  class Demo07    
{    
         public  static  void main(String args[])    
        {    
                 //从运行时处接收参数    
                 int i = 0;    
                 int j = 0;    
                System.out.println( "程序代码执行之前~~~");    
                 try    
                {    
                        i=Integer.parseInt(args[0]);    
                        j=Integer.parseInt(args[1]);    
                         //下面跟上可能发生错误的代码段    
                        System.out.println(i/j);    
                        System.out.println( "-------------------");    
                }    
                 catch(Exception e)    
                {    
                        System.out.println( "异常处理");    
                }    
                 catch(ArithmeticException ae)    
                {    
                         //进行异常处理    
                        System.out.println(ae);    
                        System.out.println( "1.运算发生了异常~~~");    
                }    
                 catch(NumberFormatException ne)    
                {    
                        System.out.println(ne);    
                        System.out.println( "2.输入的内容不是数字~~~");    
                }    
                 catch(ArrayIndexOutOfBoundsException ae)    
                {    
                        System.out.println(ae);    
                        System.out.println( "3.输入的参数个数不正确~~~");    
                }    
                System.out.println( "程序代码执行之后~~~");    
        }    
}
image
public  class Demo08    
{    
         public  static  void main(String args[])    
        {    
                 //从运行时处接收参数    
                 int i = 0;    
                 int j = 0;    
                System.out.println( "程序代码执行之前~~~");    
                 try    
                {    
                        i=Integer.parseInt(args[0]);    
                        j=Integer.parseInt(args[1]);    
                         //下面跟上可能发生错误的代码段    
                        System.out.println(i/j);    
                        System.out.println( "-------------------");    
                }    
                 //只要是程序运行时产生的异常肯定可以使用Exception进行接收    
                 catch(Exception e)    
                {    
                        System.out.println( "异常处理");    
                }    
                System.out.println( "程序代码执行之后~~~");    
        }    
}
image
捕获异常（2）
image 
不管是否发生了异常，都要执行finally代码。
image
image
class Math{    
         public  int div( int i, int j){    
                 return i/j;    
        }    
}    
public  class Demo10{    
         public  static  void main(String args[]){    
                System.out.println( new Math().div(1,1));         
        }    
}
这个代码现在没问题哈~
image 
class Math{    
         //表示此方法必须被处理异常，必须在调用处处理    
         public  int div( int i, int j)  throws Exception{    
                 return i/j;    
        }    
}    
public  class Demo10{    
         public  static  void main(String args[]){    
                System.out.println( new Math().div(1,1));         
        }    
}
image
我们必须要对此代码进行catch捕获
class Math{    
         //表示此方法必须被处理异常，必须在调用处处理    
         public  int div( int i, int j)  throws Exception{    
                 return i/j;    
        }    
}    
public  class Demo10{    
         public  static  void main(String args[]){    
                 try{    
                        System.out.println( new Math().div(1,1));    
                } catch(Exception e){    
                        System.out.println(e);    
                }    
        }    
}
image
正常执行输出哈
class Math{    
         //表示此方法必须被处理异常，必须在调用处处理    
         public  int div( int i, int j)  throws Exception{    
                 return i/j;    
        }    
}    
public  class Demo10{    
         public  static  void main(String args[]){    
                 try{    
                        System.out.println( new Math().div(1,0));    
                } catch(Exception e){    
                        System.out.println(e);    
                }    
        }    
}
出现异常时成功捕获异常
image
同样道理，既然可以在方法上声明，则肯定也可以在main方法处声明。
class Math{    
         //表示此方法必须被处理异常，必须在调用处处理    
         public  int div( int i, int j)  throws Exception{    
                 return i/j;    
        }    
}    
public  class Demo11{    
         //此处的错误交给JVM进行处理了    
         public  static  void main(String args[])  throws Exception{    
                System.out.println( new Math().div(1,0));    
        }    
}
image
image
image
public  class Demo12{    
         public  static  void main(String args[]){    
                 throw  new Exception( "自己抛出的异常~~~");    
        }    
}
image
提示要进行try...catch的处理哈~
public  class Demo12{    
         public  static  void main(String args[]){    
                 try{    
                         throw  new Exception( "自己抛出的异常~~~");    
                } catch(Exception e){    
                        System.out.println(e);    
                }    
        }    
}
这就是throw关键字的作用哈~~~
image
实际上在开发中：finally、throw、throws都是一起联合使用的。
要求： 
  定义一个除法操作，要求进入方法之前必须有开始进行除法操作的提示，操作完之后要求有除法操作完成的提示。
class Math{    
         public  int div( int i, int j){    
                System.out.println( "开始除法操作~~~");    
                 int temp=0;    
                temp=i/j;    
                System.out.println( "开始除法操作~~~");    
                 return temp;    
        }    
}    
public  class Demo13{    
         public  static  void main(String args[]){    
                System.out.println( new Math().div(1,1));    
        }    
}
image
class Math{    
         public  int div( int i, int j){    
                System.out.println( "开始除法操作~~~");    
                 int temp=0;    
                temp=i/j;    
                System.out.println( "开始除法操作~~~");    
                 return temp;    
        }    
}    
public  class Demo13{    
         public  static  void main(String args[]){    
                System.out.println( new Math().div(1,0));    
        }    
}
这个就出现异常了哈，结束语句也就不出来了
image
我们要将异常交给调用处处理哈~~~
class Math{    
         //所有的异常肯定交给调用处处理    
         public  int div( int i, int j)  throws Exception{    
                System.out.println( "开始除法操作~~~");    
                 int temp=0;    
                temp=i/j;    
                System.out.println( "结束除法操作~~~");    
                 return temp;    
        }    
}    
public  class Demo13{    
         public  static  void main(String args[]){    
                 try{    
                        System.out.println( new Math().div(1,0));    
                } catch(Exception e){    
                        System.out.println(e);    
                }    
        }    
}
image
 
class Math{    
         //所有的异常肯定交给调用处处理    
         public  int div( int i, int j)  throws Exception{    
                System.out.println( "开始除法操作~~~");    
                 int temp=0;    
                 //所有的异常不能自己处理，必须交给被调用处处理    
                 try{    
                        temp=i/j;    
                } catch(Exception e){    
                         //需要把异常往上抛    
                         throw e;    
                } finally{    
                        System.out.println( "结束除法操作~~~");    
                }    
                 return temp;    
        }    
}    
public  class Demo13{    
         public  static  void main(String args[]){    
                 try{    
                        System.out.println( new Math().div(1,0));    
                } catch(Exception e){    
                        System.out.println(e);    
                }    
        }    
} 

image
自定义异常，如果学习SSH框架，很多的异常不是JDK本身提供的，需要自己定义的。 任何一个类只要继承了Exception类就表示是一个异常类了。
class MyException  extends Exception{    
         public MyException(String msg){    
                 super(msg);    
        }    
         public String toString(){    
                 return  super.getMessage();    
        }    
}    
public  class Demo14{    
         public  static  void main(String args[]){    
                 try{    
                         throw  new MyException( "自己定义的异常~~~");    
                } catch(Exception e){    
                        System.out.println(e);    
                }    
        }    
}
image
总结 
异常的捕获：try{}catch：try捕获异常，之后把异常类的实例化对象与catch中的类型相比较，如果合适，则进行异常的处理。 
Finlly关键字 
面试题： 
请说出：final和finally关键字的区别 
throw和throws关键字
##############################################################








本文转自redking51CTO博客，原文链接：http://blog.51cto.com/redking/130286 ，如需转载请自行联系原作者
文章标签：
Java
关键词：
Java面向对象
Java se
Java异常
Java捕获
Java se异常
技术小美
目录
相关文章
啦啦啦191
|
15天前
|
Java
Java基础语法与面向对象
重载（Overload）指同一类中方法名相同、参数列表不同，与返回值无关；重写（Override）指子类重新实现父类方法，方法名和参数列表必须相同，返回类型兼容。重载发生在同类，重写发生在继承关系中。
啦啦啦191
84 1
啦啦啦191
|
27天前
|
存储 Java 关系型数据库
Java 项目实战基于面向对象思想的汽车租赁系统开发实例 汽车租赁系统 Java 面向对象项目实战
本文介绍基于Java面向对象编程的汽车租赁系统技术方案与应用实例，涵盖系统功能需求分析、类设计、数据库设计及具体代码实现，帮助开发者掌握Java在实际项目中的应用。
啦啦啦191
44 0
34789737
|
27天前
|
安全 Java API
Java SE 与 Java EE 区别解析及应用场景对比
在Java编程世界中，Java SE（Java Standard Edition）和Java EE（Java Enterprise Edition）是两个重要的平台版本，它们各自有着独特的定位和应用场景。理解它们之间的差异，对于开发者选择合适的技术栈进行项目开发至关重要。
34789737
114 1
艾伦~耶格尔
|
2月前
|
安全 Java 编译器
Java面向对象
本文深入讲解了Java面向对象编程（OOP）的四大特性：封装、继承、多态与抽象，以及方法的设计与使用。通过示例展示了如何用类和对象组织代码，提升程序的可维护性与扩展性。
艾伦~耶格尔
125 0
潘安的酱油
|
3月前
|
存储 Java 测试技术
Java基础 - 面向对象
面向对象编程是Java的核心，包含封装、继承、多态三大特性。封装隐藏实现细节，提升代码可维护性与安全性；继承实现类间IS-A关系，支持代码复用；多态通过继承、重写与向上转型，实现运行时方法动态绑定，提升系统扩展性与灵活性。
潘安的酱油
74 0
程序员小假
|
4月前
|
Java 程序员 数据库连接
我们详细地讲解一下 Java 异常及要如何处理
我是小假 期待与你的下一次相遇 ~
程序员小假
82 1
34789737
|
4月前
|
设计模式 算法 Java
Java SE 与 Java EE 组件封装使用方法及实践指南
本指南详细介绍了Java SE与Java EE的核心技术使用方法及组件封装策略。涵盖集合框架、文件操作、Servlet、JPA、EJB和RESTful API的使用示例，提供通用工具类与基础组件封装建议，如集合工具类、文件工具类、基础Servlet、实体基类和服务基类等。同时，通过分层架构集成示例展示Servlet、EJB和JPA的协同工作，并总结组件封装的最佳实践，包括单一职责原则、接口抽象、依赖注入、事务管理和异常处理等。适合希望提升代码可维护性和扩展性的开发者参考。
34789737
133 0
运营研究坊
|
5月前
|
人工智能 Java 编译器
Java：面向对象
本文介绍了Java编程中的核心概念，包括包的命名规范与自动导入机制、构造方法的特点与使用、`this`和`super`关键字的作用、继承的基本规则、访问权限的设置、封装的意义、多态的实现原理以及`static`关键字的用法。通过详细解析每个知识点，并结合代码示例，帮助读者深入理解Java面向对象编程的核心思想与实践技巧。内容适合初学者及进阶开发者学习参考。
运营研究坊
118 0
aliyun7741822232-15995
|
7月前
|
缓存 安全 Java
java面试-基础语法与面向对象
本文介绍了 Java 编程中的几个核心概念。首先，详细区分了方法重载与重写的定义、发生阶段及规则；其次，分析了 `==` 与 `equals` 的区别，强调了基本类型和引用类型的比较方式；接着，对比了 `String`、`StringBuilder` 和 `StringBuffer` 的特性，包括线程安全性和性能差异；最后，讲解了 Java 异常机制，包括自定义异常的实现以及常见非检查异常的类型。这些内容对理解 Java 面向对象编程和实际开发问题解决具有重要意义。
aliyun7741822232-15995
119 15
游客kufrkwrbkmpsa
|
7月前
|
SQL druid Oracle
【YashanDB知识库】yasdb jdbc驱动集成druid连接池，业务(java)日志中有token IDENTIFIER start异常
客户Java日志中出现异常，影响Druid的merge SQL功能（将SQL字面量替换为绑定变量以统计性能），但不影响正常业务流程。原因是Druid在merge SQL时传入null作为dbType，导致无法解析递归查询中的`start`关键字。
游客kufrkwrbkmpsa
168 3

热门文章

最新文章

  • 1
    阿里出手！Java 开发者狂喜！开源 AI Agent 框架 JManus 来了，初次见面就心动～
  • 2
    构建基于Java的AI智能体：使用LangChain4j与Spring AI实现RAG应用
  • 3
    最详细Java正则表达式详解
  • 4
    2025 年最新 Java 实操学习路线，从入门到高级应用详细指南
  • 5
    Java并发编程：CountDownLatch实战解析
  • 6
    热门小程序源码合集：微信抖音小程序源码支持PHP/Java/uni-app完整项目实践指南
  • 7
    使用LangChain4j构建Java AI智能体：让大模型学会使用工具
  • 8
    Java AI智能体实战：使用LangChain4j构建能使用工具的AI助手
  • 9
    抖音微信爆款小游戏大全：免费休闲/竞技/益智/PHP+Java全筏开源开发
  • 10
    Java新特性：使用Stream API重构你的数据处理
  • 1
    2025 版 Java 零基础入门到精通实操指南
    775
  • 2
    java 入门学习视频_2025 最新 java 入门零基础学习视频教程
    153
  • 3
    顺丰同城抢单辅助脚本，顺丰骑士抢单辅助免封号，自动抢单神器【java版开源】
    467
  • 4
    现代化 java 分层开发实施策略与最佳实践指南
    149
  • 5
    我们详细地讲解一下 Java 异常及要如何处理
    82
  • 6
    MinIO Java SDK 7.1.4 升级到 8.5.17 需要注意什么
    320
  • 7
    微信不封号无限加人软件，微信一键自动加人软件，java实现批量化加人
    114
  • 8
    Java 与 C++ 区别深入剖析及应用实例详解
    361
  • 9
    Java 生态大模型应用开发全流程实战案例与技术路径终极对决
    599
  • 10
    Java 抽象类与接口在 Java17 + 开发中的现代应用实践解析
    93

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    阿里云云原生一体化数仓 — 数据治理新能力解读