java异常处理机制
一、什么是java的异常？
异常是导致程序中断运行的一种指令流，软件和硬件错误都可能导致异常的产生，用户输入错误，所需要的文件找不到，运行时磁盘空间不够，内存不够，算术运算错误（数的溢出、被零除），数组下标越界……
模仿一个异常:
package com.destiny;
public class Exception {
public static void main(String[] args {
System.out.println("********开始计算****************";
int i = 10;
int j = 0;
int m = i/j;//出现异常
//程序中断，以下部份没有执行
System.out.println("10除以0的结果是:"+m;
System.out.println("********完成计算****************";
}
}
结果:
********开始计算****************
Exception in thread "main" https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException: / by zero
at com.destiny.Exception.main(Exception.java:8
二、异常处理方式
异常出现后，如果没有进行合理的处理，则会让应用程序中断运行。
Try{
放置可能会出现异常的语句
}catch(异常类异常类的对象{
处理异常的语句
}catch(异常类异常类的对象{
可以有多个，是因为try中的语句可能会抛出多个不同的异常，括号中的异常类有很多，不同的类就代表不同的异常，如果异常出现了，而catch所指定的异常类不属于产生的异常，那么该异常将不会被捕捉到。
}finally{
可选的语句块，不管是否出现了异常，该语句块的语句都要执行，比如关闭数据库的连接等
}
例子:
package com.destiny;
public class Exception00 {
public static void main(String[] args {
System.out.println("********开始计算****************";
int m=0;
int i = 10;
int j = 0;
m = i/j;
} catch (ArithmeticException e {
System.out.println("异常被捕捉";
e.printStackTrace(;
}finally{
System.out.println("finally中的语句被执行";
}
}
}
结果:
********开始计算****************
https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException: / by zero
异常被捕捉
at com.destiny.Exception00.main(Exception00.java:10
finally中的语句被执行
注意:
以上代码如果catch块声明成 catch (NumberFormatException e ，则异常将不会被捕捉，也不会被处理，但finally块中的代码也会被执行。
package com.destiny;
public class Exception00 {
public static void main(String[] args {
System.out.println("********开始计算****************";
int m=0;
try {
int i = 10;
int j = 0;
} catch (NumberFormatException e {
System.out.println("异常被捕捉";
e.printStackTrace(;
}finally{
System.out.println("finally中的语句被执行";
}
}
}
结果:
********开始计算****************
finally中的语句被执行
Exception in thread "main" https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException: / by zero
at com.destiny.Exception00.main(Exception00.java:10
三、异常处理机制
在整个的java异常处理中，实际上也是按照面向对象的方式进行处理的，一旦产生异常，则首先会产生一个异常类的实例化对象。
我们可以在try语句中对此异常进行捕捉。
产生的异常对象与catch中的各个异常类型进行匹配，如果匹配成功，则执行catch 块中的语句。
如果有finally语句，则最后执行finally中的语句。
例子：
public class Test {
public static void main(String[] args
{
int temp;
try {
int i=13;
temp = i/j;
System.out.println("i/j="+temp;
} catch (RuntimeException e {
e.printStackTrace(;
}
System.out.println("---------异常处理结束---------";
System.out.println("--------程序最后的语句---------";
}
}
结果:
https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException: / by zero
at Test.main(Test.java:8
---------异常处理结束---------
--------程序最后的语句---------
--------------------------------------------------------------------------------------------------------------------------------
public class Test {
public static void main(String[] args
{
int temp;
try {
int i=13;
int j=0;
temp = i/j;
System.out.println("i/j="+temp;
} catch (RuntimeException e {
e.printStackTrace(;
}finally{
System.out.println("---------异常处理结束---------";
}
System.out.println("--------程序最后的语句---------";
}
}
结果:
https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException: / by zero
at Test.main(Test.java:8
---------异常处理结束---------
--------程序最后的语句---------
四、java语言中错误和异常类
图解:
Throwable类是所有java语言中所有错误或异常的超类，所有异常类型都是Throwable的子类. Exception类是用户程序可能捕捉的异常类的超类，也是用来创建用户自定义异常类型的超类。Error用于指示合理的应用程序不应该试图捕获的严重问题，它一般是由于硬件问题产生的。
Exception又可分为两类：
RuntimeException:运行时异常，它表示程序正常运行的话就不会产生的异常。这种异常不用在程序中把他们列出来，运行时有问题，会自动被JVM抛出。比如空指针异常，数组越界。
非运行时异常：例如，FileNotFoundException异常，java编译器要求在程序中必须进行处理，抛出这类异常除外。
例子:
以下为非运行时异常的例子，此种异常在写代码的时候，IDE就会提示要求必须进行捕捉。import java.io.*;
import java.io.FileNotFoundException;
import java.util.*;
public class ForOne {
public static void main(String[] args {
File file = new File("d:/temp/gundam.txt";
try {
FileInputStream fis = new FileInputStream(file;
} catch (FileNotFoundException e {
e.printStackTrace(;
}
}
}
结果:
java.io.FileNotFoundException: d:\temp\gundam.txt (系统找不到指定的文件。
at java.io.FileInputStream.open(Native Method
at java.io.FileInputStream. ( FileInputStream.java:106
at ForOne.main(ForOne.java:9
运行时的异常在编译时是发现不了的，必须由程序员自己来判断。
提示：所有需处理的异常，我们都可以用Exception类来进行捕捉。
五、通过方法抛出异常
如果我们不打算处理方法中的异常，可以用此语句把产生的异常抛出，交给调用该方法的方法去处理
此种方式可以把方法中的语句可能产生的异常进行抛出，可以抛给方法的调用者。如果在方法声明处使用了throws声明异常，则该方法中产生的异常并不必再捕捉。
方法名称（参数列表） throws 异常类型列表
import java.io.*;
import java.util.*;
public class ForOne {
public static void main(String[] args throws FileNotFoundException{
//在main上使用throws将会把异常抛出给jvm，这种方式是不允许的，jvm也不知道该如何处理这种异常
File file = new File("d:/temp/gundam.txt";
FileInputStream fis = new FileInputStream(file;
}
}
修改后:
import java.io.*;
import java.util.*;
public class ForOne {
public static void main(String[] args{
try {
justice(;
} catch (FileNotFoundException e {
e.printStackTrace(;
}
}
static void justice( throws FileNotFoundException{
File file = new File("d:/temp/gundam.txt";
FileInputStream fis = new FileInputStream(file;
}
}
例子:
package com.destiny;
public class Exception {
public static void main(String[] args {
int r = cal(10,0;
}
static int cal(int i,int j {
int m=0;
m = i/j;
return m;
}
}
和开始一样异常没有被捕捉,结果:
Exception in thread "main" https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException: / by zero at com.destiny.Exception.cal(Exception.java:9
at com.destiny.Exception.main(Exception.java:5
将异常抛给调用它的方法:
package com.destiny;
public class Exception01 {
public static void main(String[] args {
int r = cal(10,0;
}
static int cal(int i,int j throws Exception{//向方法的调用者抛出异常int m=0;
m = i/j;
return m;
}
}
cal下面会有报错，抛出去后谁调用这个方法谁就要处理这个异常package com.destiny;
public class Exception01 {
public static void main(String[] args {
try {//捕捉cal方法抛出的异常
int r = cal(10,0;
} catch (Exception e {
System.out.println("异常被捕捉";
e.printStackTrace(;
}
}
static int cal(int i,int j throws Exception{//向方法的调用者抛出异常
int m=0;
m = i/j;
System.out.println("异常已出现";//看看异常是否会被捕捉
return m;
}
}
结果：
异常被捕捉
https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException: / by zero
at com.destiny.Exception01.cal(Exception01.java:14
at com.destiny.Exception01.main(Exception01.java:6
r没有赋值，即return没执行，但程序也没有中断
使用这种方法捕捉到程序产生异常后，则后面的代码不再执行
六、通过语句抛出异常
throw ThrowableObject;
ThrowableObject必须是Throwable或者其子类的对象。
自定义的异常也就是用户自己定义的异常，一般用来向调用发送一些信息。
该语句用在方法体内的，用来抛出一个异常，程序在遇到此语句时将会中止，后面的语句执行不到，然后在上层调用该方法的方法中进行捕捉。此种方式往往用于抛出用户自定义的异常。
import java.io.*;
public class ForTwo {
public static void main(String[] args{
justice(;
}
static void justice({
System.out.println("方法开始执行!";
try {
throw new Exception("此异常为用户自定义的异常!"; } catch (Exception e {
e.printStackTrace(;
}
System.out.println("方法结束!";
}
}
结果:
方法开始执行!
https://www.doczj.com/doc/e61487888.html,ng.Exception: 此异常为用户自定义的异常!
at ForTwo.justice(ForTwo.java:9
at ForTwo.main(ForTwo.java:4
方法结束!
package com.destiny;
public class MyException extends Exception {
public String getMessage(//重写方法
{
return"哎呀，你是怎么传的参数!";
}
}
-------------------------------------------------------------------------------------------------------- package com.destiny;
public class Exception01 {
public static void main(String[] args {
try {//捕捉cal方法抛出的异常
int r = cal(10,0;
} catch (Exception e {
System.out.println(e.getMessage(;
}
}
static int cal(int i,int j throws Exception{//向方法的调用者抛出异常
int m=0;
if(j==0{
throw new MyException(;
}
m = i/j;
System.out.println("异常已出现";//看看异常是否会被捕捉
return m;
}
}
结果：
哎呀，你是怎么传的参数!
得到一个异常对象是，它将会沿着方法的调用栈逐层回溯，寻找处理这一异常的代码。找到能够处理这种类型异常的方法后，运行时系统把当前异常交给这个方法处理；如果找不到可以捕获异常的方法，则运行时系统将终止，相应的Java程序也将退出。捕获异常是通过try-catch-finally语句实现的。语法为：try{ ... }catch(ExceptionName1 e){ ... }catch(ExceptionName2 e){ ... } ... }finally{ ... } 2)声明抛弃异常：当Java 程序运行时系统得到一个异常对象时，如果一个方法并不知道如何处理所出现的异常，则可在方法声明时，声明抛弃异常。声明抛弃异常是在一个方法声明中的throws子句中指明的。如：public int read() throws IOException{ ... } 其中throws IOException就是声明抛弃异常，throws后可以跟多个异常类型。 1. https://www.doczj.com/doc/e61487888.html,ng.nullpointerexception 这个异常大家肯定都经常遇到，异常的解释是"程序遇上了空指针"，简单地说就是调用了未经初始化的对象或者是不存在的对象，这个错误经常出现在创建图片，调用数组这些操作中，比如图片未经初始化，或者图片创建时的路径错误等等。对数组操作中出现空指针，很多情况下是一些刚开始学习编程的朋友常犯的错误，即把数组的初始化和数组元素的初始化混淆起来了。数组的初始化是对数组分配需要的空间，而初始化后的数组，其中的元素并没有实例化，依然是空的，所以还需要对每个元素都进行初始化（如果要调用的话） 2. https://www.doczj.com/doc/e61487888.html,ng.classnotfoundexception 这个异常是很多原本在jb等开发环境中开发的程序员，把jb下的程序包放在wtk下编译经常出现的问题，异常的解释是"指定的类不存在"，这里主要考虑一下类的名称和路径是否正确即可，如果是在jb下做的程序包，一般都是默认加上package的，所以转到wtk下后要注意把package的路径加上。 3. https://www.doczj.com/doc/e61487888.html,ng.arithmeticexception 这个异常的 好好检查一下自己程序中涉及到数学运算的地方，公式是不是有不妥了。 4. 是超出了数组的范围，一般来说，显示（即直接用常数当下标）调用不太容易出这样的错，但隐式（即用变量表示下标）调用就经常出错了，还有一种情况，是程序中定义的数组的长度是通过某些特定方法决定的，不是事先声明的，这个时候，最好先查看一下数组的length，以免出现这个异常。 5. https://www.doczj.com/doc/e61487888.html,ng.illegalargumentexception 这个异常的解释是"方法的参数错误"，很多j2me的类库中的方法在一些情况下都会引发这样的错误，比如音量调节方法中的音量参数如果写成负数就会出现这个异常，再比如g.setcolor(int red,int green,int blue)这个方法中的三个值，如果有超过255的也会出现这个异常，因此一旦发现这个异常，我们要做的，就是赶紧去检查一下方法调用中的参数传递是不是出现了错误。 6. https://www.doczj.com/doc/e61487888.html,ng.illegalaccessexception 这个异常的解释是"没有访问权限"，当应用程序要调用一个类，但当前的方法即没有对该类的访问权限便会出现这个异常。对程序中用了package的情况下要注意这个异常。其他还有很多异常，我就不一一列举了，我要说明的是，一个合格的程序员，需要对程序中常见的问题有相当的了解和相应的解决办法，否则仅仅停留在写程序而不会改程序的话，会极大影响到自己的开发的。关于异常的全部说明，在api里都可以查阅。算术异常类：ArithmeticExecption 空指针异常类：NullPointerException 类型强制转换异常：ClassCastException 数组负下标异常：NegativeArrayException 数组下标越界异常：ArrayIndexOutOfBoundsException 违背安全原则异常：SecturityException 文件已结束异常：EOFException 文件未找到异常：FileNotFoundException 字符串转换为数字异常：NumberFormatException 操作数据库异常：SQLException 输入输出异常：IOException 方法未找到异常：NoSuchMethodException https://www.doczj.com/doc/e61487888.html,ng.AbstractMethodError 抽象方法错误。当应用试图调用抽象方法时抛出。https://www.doczj.com/doc/e61487888.html,ng.AssertionError 断言错。用来指示一个断言失败的情况。https://www.doczj.com/doc/e61487888.html,ng.ClassCircularityError 类循环依赖错误。在初始化一个类时， 个文件中读取Java类，而检测到该文件的内容不符合类的有效格式时抛出。https://www.doczj.com/doc/e61487888.html,ng.Error 错误。是所有错误的基类，用于标识严重的程序运行问题。这些问题通常描述一些不应被应用程序捕获的反常情况。https://www.doczj.com/doc/e61487888.html,ng.ExceptionInInitializerError 初始化程序错误。当执行一个类的静态初始化程序的过程中，发生了异
#include "stdafx.h" #include #include #include // 内存泄露检测机制 #define _CRTDBG_MAP_ALLOC #ifdef _DEBUG #define new new(_NORMAL_BLOCK, __FILE__, __LINE__ #endif // 自定义异常类 class MyExcepction { public: // 构造函数,参数为错误代码 MyExcepction(int errorId { // 输出构造函数被调用信息 std::cout << "MyExcepction is called" << std::endl; m_errorId = errorId; } // 拷贝构造函数 MyExcepction( MyExcepction& myExp { // 输出拷贝构造函数被调用信息 std::cout << "copy construct is called" << std::endl; this->m_errorId = myExp.m_errorId; }
~MyExcepction( { // 输出析构函数被调用信息 std::cout << "~MyExcepction is called" << std::endl; } // 获取错误码 int getErrorId( { return m_errorId; } private: // 错误码 int m_errorId; }; int main(int argc, char* argv[] { // 内存泄露检测机制 _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ; // 可以改变错误码,以便抛出不同的异常进行测试 int throwErrorCode = 110; std::cout << " input test code :" << std::endl; std::cin >> throwErrorCode; try { if ( throwErrorCode == 110 { MyExcepction myStru(110;
品质异常处理流程 （公开文件，共4页） 一、目的： 规范品质异常处理流程，提高品质异常处理的时效性，确保来料质量及生产的正常运转，同时满足顾客的质量要求。 二、范围： 适用于本公司来料、制程、出货品质异常的处理。 三、定义： 3.1 来料品质异常： a、不符合相关检验标准要求，且不良率超过质量目标时； b、合格物料制程中发现重点物料不合格时； c、有经过改善且有效果确认，但又重复发生品质异常时。 3.2 制程品质异常： a、使用不合格的原料或材料； b、同一缺陷连续发生； c、不遵守作业标准或不遵守工艺要求； d、机械发生故障或精度磨损； e、其他情形影响到产品质量时。 3.3 出货品质异常： a、客户投诉或抱怨； 四、职责 4.1 来料品质异常： 品质：a.负责填写《品质异常联络单》“异常描述”部分； b.负责将《来料检验报告》、《品质异常联络单》发送于采购，抄送工程、生产； c负责品质异常改善结果确认。 采购：负责将《来料检验报告》、《品质异常联络单》发送给供应商并及时与供应商联系跟踪供应商及时回复“原因分析”“纠正与预防措施”并将结果回复品质部. 4.2 制程品质异常： 品质部: a,负责品质异常之最终判定； b,负责确认品质异常责任部门； c,负责主导品质异常案例的处理过程； d,负责对责任单位的改善结果进行追踪确认
异常责任单位： a负责品质异常的原因分析，提出临时措施及长期改善对策并执行。 生产部： a负责品质异常的改善和预防措施的实施及验证改善措施的有效性； 其它相关单位： a在需要时进行异常改善的配合 4.3 出货品质异常： 品质部： a负责将品质异常通知各部门及确定责任部门； b负责异常改善后的跟踪确认； c负责处理客户抱怨 异常责任单位： a负责品质异常的原因分析，提出临时措施及长期改善对策并执行。 生产部： a负责品质异常的改善和预防措施的实施及验证改善措施的有效性； 营业部： a负责将客户抱怨反馈给相关部门。 其它相关单位： a在需要时进行异常改善的配合 五、工作程序： 5.1 进料品质异常： 5.1.1 依相关检验标准判定不合格，针对不合格物料标示“不合格”，并立即移至不良品区域。 5.1.2 异常成立4小时内开立《品质异常联络单》通知采购。 5.1.3 采购接《品质异常联络单》后4小时内转责任供应商。 5.1.4 供应商需于1个工作日内针对异常物料提出临时对策，如对异常内容有疑问，需在4 小时与品质相关人员确认清楚。 5.1.5 供应商必须在《品质异常联络单》要求的期限前（如无明确要求，默认为《品质异常联络单》发出后2个工作日内）回复完整的改善方案。 5.1.6 品质部对供应商回复内容进行确认，针对改善措施不合格部分予以退件，要求供应商重新回复。改善措施合格，则报告予以归档，跟踪后续进料品质状况，依5.1.7执行。 5.1.7 针对供应商改善后产品加严检验，连续追踪3批无异常予以结案，转正常检验；连续追踪3批中途发现不良现象仍存在，则重复5.1.2-5.1.7。 5.1.8 如供应商改善措施回复后连续2个月无进料，则强制结案，后续进料依正常检验执行。 5.1.9
App9_1.java：输出一个数组的所有元素，捕获数组下标越界异常和除娄为0异常。public class App9_1{ public static void main(String args[]){ int i; int[] a={1,2,3,4}; for(i=0;i<5;i++) System.out.println(" a["+i+"]="+a[i]); System.out.println("5/0"+(5/0)); } } App9_2.java：使用try-catch-finall语句对程序中的异常进行捕获与处理。 public class App9_2{ public static void main(String args[]){ int i; int a[]={1,2,3,4}; for (i=0;i<5;i++){ try{ System.out.print("a["+i+"]/"+i+"="+(a[i]/i)); } catch(ArrayIndexOutOfBoundsException e){ System.out.print("捕获到了数组下标越界异常"); } catch(ArithmeticException e){ System.out.print("异常类名称是："+e); //显示异常信息 } catch(Exception e){ System.out.println("捕获"+e.getMessage()+"异常！"); //显示异常信息 } finally{ System.out.println(" finally i="+i); } } System.out.println("继续！！"); } } App9_3.java：使用throw语句在方法中抛出异常。 public class App9_3{ public static void main(String args[]){ int a=5,b=0; try{ if (b==0) throw new ArithmeticException(); //抛出异常，不是必须的 else System.out.println(a+"/"+b+"="+a/b); //若不抛出异常，则运行此行
异常处理是程序设计中一个非常重要的方面，也是程序设计的一大难点，从C开始，你也许已经知道如何用if...else...来控制异常了，也许是自发的，然而这种控制异常痛苦，同一个异常或者错误如果多个地方出现，那么你每个地方都要做相同处理，感觉相当的麻烦！Java 语言在设计的当初就考虑到这些问题，提出异常处理的框架的方案，所有的异常都可以用一个类型来表示，不同类型的异常对应不同的子类异常（这里的异常包括错误概念），定义异常处理的规范，在1.4版本以后增加了异常链机制，从而便于跟踪异常！这是Java语言设计者的高明之处，也是Java语言中的一个难点，下面是我对Java异常知识的一个总结，也算是资源回收一下。 一、Java异常的基础知识 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。比如说，你的代码少了一个分号，那么运行出来结果是提示是错误https://www.doczj.com/doc/e61487888.html,ng.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException的异常。 有些异常需要做处理，有些则不需要捕获处理，后面会详细讲到。 天有不测风云，人有旦夕祸福，Java的程序代码也如此。在编程过程中，首先应当尽可能去避免错误和异常发生，对于不可避免、不可预测的情况则在考虑异常发生时如何处理。Java中的异常用对象来表示。Java对异常的处理是按异常分类处理的，不同异常有不同的分类，每种异常都对应一个类型（class），每个异常都对应一个异常（类的）对象。 异常类从哪里来？有两个来源，一是Java语言本身定义的一些基本异常类型，二是用户通过继承Exception类或者其子类自己定义的异常。Exception 类及其子类是Throwable的一种形式，它指出了合理的应用程序想要捕获的条件。 异常的对象从哪里来呢？有两个来源，一是Java运行时环境自动抛出系统生成的异常，而不管你是否愿意捕获和处理，它总要被抛出！比如除数为0的异常。二是程序员自己抛出的异常，这个异常可以是程序员自己定义的，也可以是Java语言中定义的，用throw 关键字抛出异常，这种异常常用来向调用者汇报异常的一些信息。 异常是针对方法来说的，抛出、声明抛出、捕获和处理异常都是在方法中进行的。 Java异常处理通过5个关键字try、catch、throw、throws、finally进行管理。基本过程是用try语句块包住要监视的语句，如果在try语句块内出现异常，则异常会被抛出，你的代码在catch语句块中可以捕获到这个异常并做处理；还有以部分系统生成的异常在Java运行时自动抛出。你也可以通过throws关键字在方法上声明该方法要抛出异常，然后在方法内部通过throw抛出异常对象。finally语句块会在方法执行return之前执行，一般结构如下： try{ 程序代码 }catch(异常类型1 异常的变量名1){ 程序代码 }catch(异常类型2 异常的变量名2){ 程序代码 }finally{ 程序代码 } catch语句可以有多个，用来匹配多个异常，匹配上多个中一个后，执行catch语句块时候仅仅执行匹配上的异常。catch的类型是Java语言中定义的或者程序员自己定义的，表示代
Java语言中的异常处理机制 导语：为了加强程序的健壮性、流畅性、稳定性，就需要考虑有可能发生的异常，并进行相应的处理。下面就由为大家介绍一下Java语言中的异常处理机制，欢迎大家阅读! 1概述 在应用程序运行的过程中，经常会出现这样一些现象：用户不按照要求输入、需要进行处理的文件丢失、分母为零、数组下标超出预定范围、网络中断等，我们把这种现象称为异常。由于异常情况总是难免的，所以一个好的应用程序不仅要满足用户的基本需求，还要具备处理有可能出现的异常情况的能力，即程序必须具备较强的容错能力，把这种对异常进行处理的机制称为异常处理。对异常处理有两种常见方法：计算机系统遇到错误，给出出错信息并结束正在运行的程序;由程序员在程序中加入异常处理的功能。早期的程序设计语言没有提供专门进行异常处理的功能，程序员在编写程序的过程中，进行处理异常的代码往往和正常的代码混杂在一起，导致程序的可维护性和可读性下降。Java语言采取了异常处理机制，其方式为“抛出-捕获”，一个异常一旦产生，Java语言采取相应的机制来处理它，避免出现死循环、死机以及其他更大的危害，尽可能预防错误代码带来的不可预期的后果，整个程序的安全性得到了极大的提高。 2Java语言中的异常概述 Java语言提供了功能强大的异常处理机制，将所有处理异常的代码集中放置，以保证正常功能代码和处理异常的代码分开。在Java
程序设计语言中，采用了大量的异常类来进行处理，这些异常类可分为两大类：https://www.doczj.com/doc/e61487888.html,ng.Exception和https://www.doczj.com/doc/e61487888.html,ng.Error。Exception 类解决由程序本身及环境所产生的异常。而Error类则处理较少发生的内部系统错误。Exception类异常可以捕获并进行相应处理，而Error类异常，则是由用户按照系统提示关闭程序。常见的异常类如下表所示： 在以上常见的Java异常类中，每个异常类反映一类异常错误，其中包含了异常错误信息和处理方法。当程序运行过程中，出现一种异常现象，产生一个相应的异常类对象，再由相应的异常类进行处理，从而避免对系统产生更大的危害，以保证程序的正常运行。 3常见的异常处理方法 常见的异常处理方法有两种：一种处理异常是在产生异常的方法中，使用try…catch…finally结构;还有一种是进行异常的移交，使用关键字throws和throw交给上层方法去处理异常。 在该案例中，对三种异常进行了捕获，分别是数组下标越界、输入数据格式不正确和Exception异常，当触发某种异常，则对相应的异常异常进行处理。Exception异常类是所有异常的基类，当出现catch块没有进行捕获的异常，则采用Exception异常类进行异常处理。 异常的移交： 实例分析：初始化参数x使用了-2，将触发NegativeArraySizeException异常，但在Sum方法中不对该异常进
供应商来料异常管理流程 1. 目的： 规范来料产品的异常处理流程控制，提高来料合格率。 2. 范围： 本规范适用于所有外购零部件及外包加工件。 3. 职责与权限： 3.1生技部：负责检测治具的制作。 3.2质量中心：负责来料异常的提出、分析、处理。 3.3生产部：负责来料异常协助处理。 3.4研发部：负责来料异常的分析、处理。 3.5生管部：负责确认来料品上线使用时间。 3.6采购部：负责来料异常与供应商的纠通取得异常的处理。 4. 名词定义： 4.1不合格：未满足产品的质量要求。 4.2 A类：单位产品的极重要质量特性不符合规定，或者单位产品的质量特性极严重不符合规定。 4.3 B类：单位产品的重要质量特性不符合规定，或者单位产品的质量特性严重不符合规定。 4.4 C类：单位产品的一般质量特性不符合规定，或者单位产品的质量特性轻微不符合规定。 5、异常处理流程控制 5.1 IQC依据检验指导书、封样、评估报告等资料检验，发现来料品不满足质量要求。 5.2 IQC将自已判定为不合格的产品经工程师、部门主管核对确实为不合格品。 5.3 IQC 立即填写《供应商异常矫正单》进行处理。 5.4 质量中心主管主导组织针对异常讨论，参与人员：采购、PIE、质量中心经理、研发工程师、研发总监、厂部厂长及其相关人员。 6、异常分类： 6.1 外观不良：表面有划痕、水印、字体不清、表面气泡、砂眼、黑点、缺料、油污、毛刺、变形、色差、氧化及电镀层脱落、标识规格错误、无料号贴纸、无出厂检验报告等。 6.2性能不良：尺寸与图纸不符、适配过大，过小、色温，波长，亮度不符、电压，电流不符等。 7、异常处理方式 7.1将不良品返回供应商进行返工、返修、报废等。
异常处理练习题 一、选择题 1.java中用来抛出异常的关键字是 (C) A、try B、catch C、throw D、finally 2.关于异常，下列说法正确的是(A) A、异常是一种对象 B、一旦程序运行，异常将被创建 C、为了保证程序运行速度，要尽量避免异常控制 D、以上说法都丌对 3.（A）类是所有异常类的父类。 A、Throwable B、Error C、Exception D、AWTError 4.java语言中，下列哪一子句是异常处理的出口(C) A、try{…}子句 B、catch{…}子句 C、finally{…}子句 D、以上说法都丌对 5.下列程序的执行，说法错误的是 (C) public class MultiCatch { public static void main(String args[]) { try { int a=args.length; int b=42/a; int c[]={1}; c[42]=99; System.out.println(“b=”+b); } catch(ArithmeticException e) { System.out.println(“除0异常：”+e); } catch(ArrayIndexOutOfBoundsException e) { System.out.println(“数组超越边界异常：”+e); } } } A、程序将输出第15行的异常信息 B、程序第10行出错 C、程序将输出“b=42”
D、程序将输出第15和19行的异常信息 6.下列程序的执行，说法正确的是（D） class ExMulti { static void procedure() { try { int c[]={1}; c[42]=99; } catch(ArrayIndexOutOfBoundsException e) { System.out.println(“数组超越界限异常：”+e); } } public static void main(String args[]) { try { procedure(); int a=args.length; int b=42/a; System.out.println(“b=”+b); } catch(ArithmeticException e) { System.out.println(“除0异常：”+e); } } } A、程序只输出第12行的异常信息 B、程序只输出第26行的异常信息 C、程序将不输出异常信息 D、程序将输出第12行和第26行的异常信息 7.下面程序抛出了一个“异常”并捕捉它。请在横线处填入适当内容完成程序。class TrowsDemo { static void procedure() throws IllegalAccessExcepton { System.out.println(“inside procedure”); throw__new_____IllegalAccessException(“demo”);
异常的基本概念 异常是导致程序终止运行的一种指令流，如果不对异常进行正确的处理，则可能导致程序的中断执行，造成不必要的损失。 在没有异常处理的语言中如果要回避异常，就必须使用大量的判断语句，配合所想到的错误状况来捕捉程序中所有可能发生的错误。 Java异常处理机制具有易于使用、可自行定义异常类、处理抛出的异常同时又不会降低程序运行的速度等优点。因而在java程序设计时应充分地利用java的异常处理机制，以增进程序的稳定性及效率。 当程序中加入了异常处理代码，所以当有异常发生后，整个程序并不会因为异常的产生而中断执行。而是在catch中处理完毕之后，程序正常的结束。 在整个java异常的结构中，实际上有两个最常用的类，分别为Exception和Error 这两个类全都是Throwable的子类。 Exception:一般表示的是程序中出现的问题，可以直接使用try……catch处理。 Error：一般值JVM错误，程序中无法处理。 Java异常处理机制。 在整个java的异常处理中，实际上也是按照面向对象的方式进行处理，处理的步骤如下： 1）一旦产生异常，则首先会产生一个异常类的实例化对象。 2）在try语句中对此异常对象进行捕捉。 3）产生的异常对象与catch语句中的各个异常类型进行匹配，如果匹配成功则执行catch语句中的代码。 异常处理 在定义一个方法时可以使用throws关键字声明，表示此方法不处理异常，而交给方法的调用处进行处理，在方法调用处不管是否有问题，都要使用try……catch块进行异常的捕获与处理。 如果在主方法中使用throws关键字，则程序出现问题后肯定交由jvm处理，将导致程序中断。 与throws关键字不同的是，throw关键字人为的抛出一个异常，抛出时直接抛出异常类的实例化对象即可。 Exception在程序中必须使用try……catch进行处理。RuntimeException可以不使用try……catch进行处理，但是如果有异常产生，则异常将由JVM进行处理。（建议RuntimeException的子类也使用try……catch进行处理，否则产生的异常交给jvm处理会导致程序中断。） 继承关系： Exception》RuntimeException》lllegalArgumentException》NumberFormatException; 异常类必须继承于Exception 建议：继承Exception一般要添加全部父类型一样的构造器！ class NameOrPwdException extends Exception { public NameOrPwdException() {
第13章异常课堂练习（2理论+2习题课+2上机） 【教学目标】 ?了解异常和异常处理的概貌（第13.2节）。 ?探究使用异常处理的优点（第13.3节）。 ?区别异常的类型：Error (致命的) 和Exception (非致命的), 以及必检和免检异常（第13.4节）。 ?在方法头中声明异常（第13.5.1节）。 ?在方法中抛出异常（第13.5.2节）。 ?编写try-catch 块处理异常（第13.5.3节）。 ?解释异常是如何传播的（第13.5.3节）。 ?在try-catch块中使用finally子句（第13.6节）。 ?只为非预期错误使用异常（第13.7节）。 ?在catch 块中重新抛出异常（第13.8节）。 ?创建链式异常（第13.9节）。 ?定义自定制的异常类（第13.10节）。 【教学重点】 ?了解异常的处理机制 ?异常的解决方法 ?Exception类的作用及其使用方法 ?必检异常、免检异常的特点 【基本知识点】 1、常见异常演示 （1）算数异常：https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException 在算术运算中，0作为除数时，系统将产生该异常，示例： public static void main(String[] args) { int x=10; int y=0; int m=x/y; } Exception in thread "main" https://www.doczj.com/doc/e61487888.html,ng.ArithmeticException: / by zero at exception.NotChecketException.main(NotChecketException.java:7)（2）数组越界异常：https://www.doczj.com/doc/e61487888.html,ng.ArrayInd exOutOfBoundsException 在数组下标越界时，将产生该异常，示例：
品质异常处理流程 1.目的 为了使品质异常发生时，处理过程有据可依，使重大品质异常在规定的时间内得到有效改善，防止相同的问题重复发生，降低品质成本，确保产品质量符合要求。 2. 适用范围 适用于公司制程控制。 3. 名词释义 品质异常：因制程中出现了品质问题而导致的异常，也称制程异常。 停机：生产线生产出的产品不符合规定要求时或生产线不具备开机条件而已开机时，作停机处理，并下发《品质异常反馈单》。 4. 职责 检验科负责品质异常的反馈与跟进。 责任部门负责对品质异常进行分析、改善与预防及不良品的处理。 5. 作业流程 品质异常问题分类
异常问题处理流程 5.2.1当出现以上异常情况时，QC迅速对已发现的问题品作好标识并隔离。 5.2.2问题反馈 5.2.2.1发现人员或QC立即向上级或责任部门报告。 5.2.2.2根据本流程的要求填写《品质异常反馈单》并传递到责任部门。 5.2.2.3一般情况发《品质异常反馈单》即可，若某一问题多次发生，或问题较严 重，可能会导致批量不合格或客户重大投诉时。检验科发出《纠正和预防措施处理单》，要求责任部门改善。 5.2.3异常问题处理 5.2.3.1当缺陷不影响产品的性能(上表不需停机的问题)，仅外观不良、非关键尺 寸超差时或问题未最终确认时，在得到检验科长级或厂长同意后，不需要停机，可进一步确认或执行在线分选。 5.2.3.2当生产线出现异常时(上表中需停机的问题)，相关人员参照本流程的要 求，暂停有问题的机器或工位的操作。 5.2.4停机的时机 5.2.4.1 出现上表中需要停机时，QC直接下达停机指令，即上述表中所致A类问 题，员工/主操/领班应主动停机。 5.2.4.2 出现需要停机时，QC直接下达停机指令，相关部门不执行的，QC领班跟 进处理。即上升为B类问题。 5.2.4.3 出现需要停机时，QC及 QC领班先后要求停机，相关部门仍不执行的， 及时反馈到检验科长，由检验科长跟进处理，即上述的C类问题。 5.2.5纠正行动
提交方式： 把文件名改为学号姓名，提交文档和源码(只需提交最顶层包文件夹） 实验六异常处理 一、实验目的 1.学会利用Try-catch-finally语句来捕获和处理异常； 2.掌握自定义异常类的方法。 二、实验要求 1.通过编程理解系统异常处理的机制和创建自定义异常的方法。 2.掌握基础类。 三、实验内容 （一）异常处理机制 1. 编写使用try…catch 语句处理异常的程序文件Demo4_1.java，
编译并运行程序，并把运行结果复制在下面 。 注意：如果在catch 语句中声明的异常类是Exception，catch 语句也能正确地捕获，这是因为Exception是ArithmeticException的父类。如果不能确定会发生哪种情况的异常，那么最好指定catch的参数为Exception，即说明异常的类型为Exception。 2、源文件是Demo3_2.java。要捕捉的异常是除数为零和数组下标越界。通过修改a和c[]下标值体验程序。 【思考】 ①先运行上面程序，观察运行结果。 ②按下条件分别修改数据，编译后运行，观察输出结果，分析在try…catch块里那些语句没有被执行，为什么? 块外那些语句可被执行到，为什么? 修改a=0，保持c[2]=200； 保持a=10，修改c[3]=200， 修改a=0，修改c[3]=200； ③再添加一个catch{Exception e}{ },位置在最前面，观察编译信息，说明什么？ 3、编写Demo3_3.java 程序，计算两数相除并输出结果。使用两个catch子句，分别捕捉除数为0的异常和参数输入有误异常。源代码如下：
如何使用异常处理机制 《PHP核心技术与最佳实践》第1章面向对象思想的核心概念，本章将就面向对象一些概念展开讨论，其中重点讨论PHP特色的面向对象的风格和语法，并通过相互借鉴和对比，使读者认识PHP自身的特点，尤其是和其他语言中不同的地方。本节为大家介绍如何使用异常处理机制。 1.6.1 如何使用异常处理机制（1） 异常的思想最早可以追溯到20世纪60年代，其在C++、Java中发扬光大，PHP则部分借鉴了这两种语言的异常处理机制。 PHP里的异常，是程序运行中不符合预期的情况及与正常流程不同的状况。一种不正常的情况，就是按照正常逻辑不该出错，但仍然出错的情况，这属于逻辑和业务流程的一种中断，而不是语法错误。PHP里的错误则属于自身问题，是一种非法语法或者环境问题导致的、让编译器无法通过检查甚至无法运行的情况。 在各种语言里，异常（exception）和错误（error）的概念是不一样的。在PHP里，遇到任何自身错误都会触发一个错误，而不是抛出异常（对于一些情况，会同时抛出异常和错误）。PHP一旦遇到非正常代码，通常都会触发错误，而不是抛出异常。在这个意义上，如果想使用异常处理不可预料的问题，是办不到的。比如，想在文件不存在且数据库连接打不开时触发异常，是不可行的。这在PHP里把它作为错误抛出，而不会作为异常自动捕获。 以经典的除零问题为例，如代码清单1-16所示。 代码清单1-16 exception.php 1.// exception.php 2.getMessage(); 9.$a=-1; 10.}
A版 汇签： 制定：审核：批准：修订记录：
1.目的 为了规范产线发生异常时，能及时、准确地反映并能通过相关人员确认、分析、及时解决，确保生产正常进行。 2.适用范围 适用于客户与工厂合作产品之生产线发生的异常现象。 3. 职责 3.1 工厂品质：提出异常问题，确认是否属实。 3.2 工厂工程：负责产线异常分析，找出问题原因，提出改善对策。 3.3 工厂：跟进改善结果及效果确认；对来料进行管控。 3.4 工厂品质：提供异常的最终处理方案，并对改善方案评估/验证；供应商 改善报告回复及监控。 3.5 客户项目、结构、工程：负责结构、软/硬件异常问题的解决。 3.6 客户采购：负责来料异常商务方面的处理。 3.7 客户计划：负责异常发生时总体计划的协调和异常发生产生的工时和物 料的签合。 3.8 质量总监：让步接收最终审批。 4. 异常处理流程 4.1工厂仓库按客户计划要求根据及套料单领取物料安排生产！ 4.2产线在生产中发现产品与样板不符、功能缺失、装配出来的成品达不到标 准要求或来料无法使用等现象时，及时上报、工厂品质&工程等相关人员确
认。 4.2 工厂品质确认异常可接受，通知产线继续生产；如确认异常成立则交工厂 工程分析同时开出《生产异常报告》。 4.3 经工厂工程分析，给出初步分析结果，结果分为工艺问题、设计问题、来料问题。 4.4 由工厂工程分析为工艺问题，由工程辅导产线纠正生产工艺，工厂品质 监督确认，产线恢复正常生产。 4.5 经工厂工程初步分析异常属于设计问题，在能力范围内能解决的自行处 理，但需将解决办法知会客户，若无法解决的则书面知会客户品质、项目、结构、计划。由客户计划主导协调客户项目结构分析在30分钟内给出临时处理解决办法，经工厂品质确认合格恢复生产；对于后期的改善对策，由客户品质主导负责协调项目、结构工程等一起实施有效的解决对策并进行验证，得到工厂品质确认方可进行生产安排！ 4.6由工厂工程及品质确认异常是来料问题，第一时间以邮件通知客户计划、 品质、采购，并要求客户品质在30分钟内对物料问题给予回复处理意见(临时解决办法)，工厂给予相应配合和支持！同时客户品质联系供应商到工厂工厂及时解决，并要求供应商给出不良原因分析及改善报告回复，客户品质对其进行验证，同时要求供应商挑选符合品质标准的物料经品质确认后方可恢复生产。 4.6.1若供应商没在规定时间（原则上要求供应商4小时内）到工厂处理，先 由采购或品质与供应商沟通，如果供应商同意接收工厂工厂挑选并承担其挑选费用和不良物料，产线予以上线生产！
Java异常处理作业 孙月巧 1、参考下面的程序，试修改程序，捕获相关异常，使得程序能正常运行。【提示：用错误数据测试，即可得到异常类名，运行时主方法参数输入abc 测试】 package November; import java.util.Scanner; public class StringIndexOutOf{ public static void main(String args[]){ System.out.println("请输入一个字符串："); try{ Scanner reader=new Scanner(System.in); String str = reader.nextLine(); System.out.println("第四个字符为 " + str.charAt(3)); int aa = Integer.parseInt(str); System.out.println("平方为 " + aa * aa); } catch(StringIndexOutOfBoundsException e){ System.out.println("您输入的数值下标越界"); } catch(NumberFormatException nfe){ System.out.println("您输入的不是数字"); } } } 2、从命令行得到5个整数，放入一整型数组，然后打印输出，要求：如果输入数据不为整数，要捕获Integer.parseInt()产生的异常，显示“请输入整数”，捕获输入参数不足5个的异常(数组越界)，显示“请输入至少5个整数”。 package November; public class Test2 { public static void main(String[] args) { System.out.println("请输入五个整数："); try {
1. 目的 规定当制程出现异常时的处理流程及各相关部门的责任， 使异常能够得到及时解决，确保生产正常 运行。 2. 适用范围 适用于制程出现异常时的处理。 3. 定义： 无。 4. 职责 4. 1各生产车间：当生产过程中制程出现异常时发出《不合格品报告单》通知 IPQC 4. 2品质部IPQC :对制程异常现象进行确认，并通知 QE 或PE 来现场进行原因分析和处理 4. 3品质部QE :对制程异常进行原因分析并确认责任部门，并对责任部门制订的改善对策进行验 证 4. 4工程部PE :对功能及结构性制程异常进行原因分析并确认责任部门 4. 5责任部门：负责制定异常的临时对策和永久对策并实施。 5. 作业程序 5. 1制程异常发出的时机： 5. 1. 1当同一不良现象重复出现且不良率超出备损率时； 5. 2制程异常的发出、确认及通知： 5. 2. 1由车间生产线根据不良现象和事实填写《不合格品报告单》，填写内容包括：订单号、 产品型 号、生产数量、不良数量、不良率、提出部门、提出时间、订单交期、不良现象描述。 经车间主管（经理）审核后给车间IPQC 确认； 5. 2. 2 IPQC 在收到车间发出的《不合格品单》后，对异常现象、不良数量、不良率进行确认， 并将确 认结果填写在“IPQC 确认”栏。如果确认结果与车间填写的内容不相符时，可退回 车间重新填写。 5. 2. 3 IPQC 确认后以电话形式通知以下人员到发生异常的现场进行原因分析： 5. 森一泰电子科技有限公司 作业指导书 制程异常处理作业指导书 2. 3. 1如果是外观异常，电话通知制程 QE 工程师到现场进行原因分析； 2. 3. 2如果是功能和结构性异常，电话通知 QE 工程师和工程部PE 工程师到现场进行 原因分析； 2. 3. 3如果电话联络不到相关产品的 QE 工程师或PE 工程师时应通知其直接上司做出 相应安排。 5. 5.
第6章异常处理机制 一、选择题 1．下列关于异常的说法正确的是（B）。 A．异常是编译时的错误 B．异常是运行时出现的错误 C．异常就是程序错误，程序错误就是异常 D．以上都不对 2．下列哪个类是异常类的父类（根类）（A）。 A．Exception B．ArithmeticException C．NullPointerException D．ArrayIndexOutofBoundException 3．有关下列异常处理机制叙述正确的是（C）。 try{ 可能产生异常的语句块; }catch(exceptiontype1 e){ 处理异常e的语句块; }catch(exceptiontype2 e){ 处理异常e的语句块; } …… finally{ 最终处理语句块; } A．try子句可能有多个，catch子句可能有多个，finally子句必须有。 B．多个catch参数中的异常类可以有父子关系，但父类异常的catch子句应该在子类异常的catch子句前面。 C．如果try子句没有抛出任何异常，则跳过catch子句，转移到finally子句继续执行。 D．当try子句监视的语句块抛出异常时，运行时系统会根据catch子句的顺序，从第一个开始，逐个查找能够捕获该异常的catch子句并执行catch子句内的语句块以完成对异常的处理，然后继续执行后面的catch子句，最后转移到finally子句，执行该子句中的语句块。4．有关throw和throws的说法中不正确的是（C）。 A．throw的作用是抛出异常，后面加的是异常类的对象。 B．throws的作用是向外抛出异常即声明要产生的若干异常，后面加的是异常类的类名。 C．throws只能声明要产生的自定义异常，也就是后面只能加自定义异常类。 D．以上都不对。 5．下列程序运行结果是（C）。 public class E { public static void main(String argv[]){ E m = new E(); System.out.println(m.amethod()); } public int amethod(){
异常处理流程及注意事项 1.发现不良； （1）确认所采用标准的完整性和有效性； （2）熟练掌握检验所涉及之相关标准或其他文件； （3）严格按抽样标准取样，注意均匀，来料检验须注意来料的不同时间，批号，生产班次等； （4）了解以往的品质状况及其品质履历； （5）掌握品管之检验技巧； 2.标示，区分，隔离； （1）标示，隔离须涉及到具体的不良品和可疑批次，不合格标示要完整且必要时要口头或书面知会先相关人员，以避免他人 混淆误用为原则； （2）不合格标示，隔离须注明不合格原因，检验员，检验日期，进料检验另须注明检验单号，并知会相关人员； 3.初步分析判断，并知会相关单位及现场领导； （1）确定不良等级，异常比率，影响度和影响面，必要时须及时知会相关单位之人员； （2）针对制程或成品类异常，要及时研拟临时对策； （3）进料之异常可能涉及组装或功能之不良，需通过试组装来确定其严重性和影响度，必要时可请工程部帮忙确认； 4.异常提报； （1）异常提报时要注意时效性和准确性，异常单的填写需准确完
整，成品异常要确认追溯批号，PO#与数量； （2）须标示和提供不良品； （3）会签的填写和勾选须正确完整； 5.跟催各相关单位签单状况，根据会签结果处理异常； （1）品管必须跟催会签状况，有迟迟未签之单位必须及时跟催，如多次跟催无效，可请领导协助，以避免异常处理的时效； （2）有签核S物料时，按S物料作业流程处理，并将处理结果维护到异常单中； （3）当物料急上线，且部门领导有同意采用，而高级主管又不在厂内，无法立即签核S单时，可询问品质经理，先输S物料， 以便后续作业； （4）当会签单位处理意见不一致时，需反映部门领导，并确认最终处理结果； 6.确认处理结果； （1）全检或重工后的，需重新确认品质状况，成品类有拆箱之异常，需填写成品不合格处置报表； （2）S物料须对其品质进行跟踪，有异常要及时提报； 7.追踪改善措施； （1）注意改善措施回文必须由责任单位之领导签核，并且要在7个工作日内完成改善措施回文； 8.确认改善结果； （1）评估改善措施之有效性，必要时须修改相关品质系统文件或