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

    2020-07-18 18:10:42
    import java.util.Scanner; /* * 异常: * 不正常 * 在某些情况下,因为用户的一些原因,例如:配置问题、错误输入...或Java异常处理的过程? * (1)当程序运行到某一句时,发生了异常,那么程序会先停下来 * .
    import java.util.Scanner;
    
    /*
     * 异常:
     * 	不正常
     *  在某些情况下,因为用户的一些原因,例如:配置问题、错误输入的问题、用户磁盘空间满了等因素,导致程序无法正常运行。
     *  
     *  不是异常:(1)语法错误(2)逻辑错误
     * 
     * Java的程序如果出现异常,并且在代码中,没有做相应的处理,那么程序会“崩溃”,“挂了”
     * 
     * Java如何处理异常?或Java异常处理的过程?
     * (1)当程序运行到某一句时,发生了异常,那么程序会先停下来
     * (2)程序会在这句代码处,查看原因,生成一个合理“异常对象”,然后“抛”出
     * (3)JVM会检测在这句代码的外围,是否有try..catch结构,可以“捕获”它,
     * 如果可以捕获,那么程序再处理完异常后,继续下面的运行,不会崩溃;
     * 如果不能捕获,那么会把这个异常继续抛给“上级”,如果“上级”能处理,那么程序从“上级"处理完的代码后面继续运行;
     * 如果上级也不能处理,那么继续往上抛,一直到达JVM,那么就“崩溃”
     * 
     * 
     */
    public class TestException {
    	public static void main(String[] args) {
    //		System.out.println(a);//语法错误
    		
    		int sum = getSum(1,2);
    		System.out.println("sum = " + sum);
    		
    			try {
    				testInput();
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		
    		System.out.println("main的其他代码");
    	}
    	
    	public static void testInput(){
    		Scanner input = new Scanner(System.in);
    		try {
    			System.out.print("请输入一个整数:");
    			int num = input.nextInt();
    		} catch (ArrayIndexOutOfBoundsException e) {
    			System.out.println("输入有误");//这里 只是提醒,没有让他 重新输入
    		}
    		
    		System.out.println("其他的代码");
    	}
    	
    	
    	//求两个整数的和
    	public static int getSum(int a ,int b){
    		return a - b;
    	}
    }
    /*
     * 所有类的根父类是Object。
     * 枚举的公共父类是Enum,根父类仍然是Object
     * 异常的公共父类是Throwable,根父类仍然是Object
     * 
     * 1、异常的公共父类:java.lang.Throwable
     * (1)只有当对象是此类(或其子类之一)的实例时,才能通过 Java 虚拟机或者 Java throw 语句“抛”出。
     * (2)只有此类或其子类之一才可以是 catch 子句中的参数类型。 
     * 
     * 2、Throwable又分为两大派别:
     * (1)Error:错误
     * 		一般指严重错误,一般合理的应用程序不应该试图去捕获它。
     *		如果出现这个问题,要么需要升级程序,要么需要升级架构,要么需要升级硬件。
     *		例如:报了一个OutOfMemoryError
     *
     *		经典代表:VirtualMachineError(堆内存溢出OutOfMemoryError,栈内存溢出StackOverflowError)
     * (2)Exception:异常
     * 		一般异常,合理的应用程序应该试图去捕获它。
     * 
     * 3、Exception还可以分为两大类:
     * (1)运行时异常(RuntimeException或它子类):又称为非受检异常
     * 		编译时,编译器是不会提醒你做处理的,只有运行期间,才会发生。
     * 		运行时异常是不建议用try...catch,因为它发生频率太高,而且一般都是很不应该发生的问题。
     * 		例如:空指针异常,数组下标越界异常,类型转换异常等,这些异常完全可以避免掉。
     * 		但是如果实在没有考虑到,也可以通过try...catch处理。
     * 
     * (2)编译时异常,除了RuntimeException系列以外的,都是编译时异常。又称为受检异常。
     * 		编译时,编译器会强制要求程序员编写处理的代码,如果你不编写,那么就编译不通过。
     * 		例如:FileNotFoundException,IOException等
     */
    public class TestExceptionType {
    	public static void main(String[] args) {
    		
    	}
    }
    /*
     * 一、异常的处理方式:try...catch
     * 1、语法格式:
     * try{
     * 		可能发生异常的代码
     * }catch(异常类型1  异常对象名){//异常对象名绝大多数都是写e
     * 		处理这个异常的代码
     * }catch(异常类型2  异常对象名){//异常对象名绝大多数都是写e
     * 		处理这个异常的代码
     * }catch(异常类型3  异常对象名){//异常对象名绝大多数都是写e
     * 		处理这个异常的代码
     * }
     * 。。。。
     * 
     * 2、异常对象的常用方法
     * (1)e.printStackTrace();
     * 打印异常的详细信息,包括追踪跟踪信息,即这个异常对象一路经过了哪些方法
     * (2)e.getMessage();
     * 返回异常对象中简单的错误信息提示
     * 
     * 3、打印异常/错误信息
     * System.err.println(xx);打印错误信息
     * 
     * System.out.println(xx);打印正常信息
     * 
     * 4、多个catch分支,如何匹配和执行的?
     * 从上到下依次判断,一旦有一个满足,后面就不看了。
     * 
     * 建议:如果多个catch中的异常类型有大小包含关系,那么小的在上,大的在下,如果没有大小包含关系,顺序随意。
     * 
     * 5、如果catch,可以捕获try中发生的异常,那么程序,会从try...catch下面的代码继续运行 ,不会崩溃。
     * 	如果catch无法捕获try中发生的异常,那么就会导致当前方法结束,并把异常对象抛出调用者,
     * 如果调用者可以处理,那么从调用者处理代码的后面继续运行,否则继续往上抛,最终到达JVM,程序就崩溃了。
     */
    public class TestTryCatch {
    	//从命令行接收2个整数,求商
    	public static void main(String[] args) {
    		try {
    			int a = Integer.parseInt(args[0]);//第一个参数赋值给a变量
    			int b = Integer.parseInt(args[1]);//第二个参数赋值给b变量
    			int shang = a/b;
    			System.out.println(a +"/" + b + "=" + shang);
    		} catch (NumberFormatException e) {
    			e.printStackTrace();//标准的
    //			System.err.println(e.getMessage());
    //			System.out.println(e.getMessage());
    		} catch (ArrayIndexOutOfBoundsException e){
    			e.printStackTrace();
    		} catch (ArithmeticException e){
    			e.printStackTrace();
    		} catch (Exception e){
    			e.printStackTrace();
    		} 
    		
    		
    		System.out.println("其他的代码....");
    	}
    }
    /
    
     * 。。。。
     * finally{
     * 		不管try中是否发生异常,也不管catch是否可以捕获异常,这里代码都必须执行
     * }
     * 
     * 一般用于编写释放资源,断开连接等代码
     * 
     * 特殊情况:可以没有catch部分
     * try{
     * 		
     * }finally{
     * 		
     * }
     */
    public class TestTryCatchFinally {
    	public static void main(String[] args) {
    		try {
    			int a = 1;
    			int b = 0;
    			System.out.println(a/b);
    		} catch (ArrayIndexOutOfBoundsException e) {
    			e.printStackTrace();
    		} finally{
    			System.out.println("最终块");
    		}
    	}
    }
    /*
     * finally与return混用:
     * 
     * (1)不管try中是否发生异常,也不管catch是否可以捕获异常,也无论try或catch中是否有return。
     * 	finally中的代码都必须执行
     * (2)如果finally中有return,就从finally块的的return回去。
     * (3)如果finally中没有return,那么先把try或catch中该执行的执行完,
     * 在return结束当前方法之前,先走一下finally,然后回去结束当前方法
     */
    public class TestFinallyNoReturn {
    	public static void main(String[] args) {
    		String str = getNum(1);
    		System.out.println(str);
    	}
    	
    	public static String getNum(int a){
    		try{
    			System.out.println(a/0);
    			if(a > 0){
    				return "正数";
    			}else if(a < 0){
    				return "负数";
    			}else{
    				return "零";
    			}
    		}catch(Exception e){
    			System.out.println("exception");
    			return "异常";
    		}finally{
    			System.out.println("finally");
    		}
    	}
    }
    /*
     * finally与return混用:
     * 
     * (1)不管try中是否发生异常,也不管catch是否可以捕获异常,也无论try或catch中是否有return。
     * 	finally中的代码都必须执行
     * (2)如果finally中有return,就从finally块的的return回去。
     * (3)如果finally中没有return,那么先把try或catch中该执行的执行完(包括把返回值的结果放到要带回调用处的操作数栈的位置)
     * 在return结束当前方法之前,先走一下finally,然后回去结束当前方法.
     * 结论,如果finally中没有return,finally中的代码不影响返回值。
     */
    public class TestFinallyNoReturn2 {
    	public static void main(String[] args) {
    		int num = getNum(4);
    		System.out.println(num);//0
    	}
    	
    	public static int getNum(int a){
    		int result = 10;
    		try{
    			System.out.println(a/0);
    			if(a > 0){
    				result = 20;
    				return result;
    			}else if(a < 0){
    				result = -20;
    				return result;
    			}else{
    				return result;
    			}
    		}catch(Exception e){
    			System.out.println("exception");
    			result = 0;
    			return result;
    		}finally{
    			result = 30;
    			System.out.println("finally");
    //			return result;//如果有这句,结果就变成30
    		}
    	}
    }
    

     

    展开全文
  • java 异常

    2016-09-06 21:52:27
    提示 几种常见异常 ArithmeticException数学算数错误异常 ArrayIndexOutOfBoundsException数组...InputMismatchException用户输入异常 NullPointerException空指针异常 FileNotFoundException文件没有找到
    提示 几种常见异常
    ArithmeticException数学算数错误异常
    ArrayIndexOutOfBoundsException数组越界
    ClassCastException  类型转换异常
    InputMismatchException用户输入异常
    NullPointerException空指针异常
    FileNotFoundException文件没有找到
    IllageArgumentExceotion 非法的参数
    1 异常:既是一种意外,是程序没有按照正常或期望的方式进行。
    2 必须对检查型异常进行处理 SQLExceptions try -catchinally throws
    3 final可选 catch可选但是二者不能同时为空
    try:中的异常,系统(JVM虚拟机)自动检测是什么异常
    catch的异常,是子父类的关系。产生异常,从上到下匹配.一定先捕获子类异常,再捕获父类异常。
    catch最后一个异常,要用Exception进行拦截,拦截所有的异常
    不希望后续的代码有影响
    throws 异常之后的语句也不执行
    异常被捕获的那条语句会执行,但不会输出结果,因为这句话有错误。不会执行。
    String s;
    try{
    System.out.println("adfaf"+s.length);//会执行,但不会有结果,因为已经有错误
    }catch(){
    }
    try -finally try中有错误,没有人去理会这个错误,因为会抛出异常没有人去管理他,后续的代码不会执行
    将全部的代码放进try中,一条有错误整个后续程序都不会执行,很危险。只要有可能发生危险的地方用try-catch接受 或者像上抛出异常
    4 执行过程
    1)当Java程序执行try块,catch块的时候遇到了return 或throws语句,这两个语句都会导致该方法结束,
    (2)但是系统执行这两个语句并不会结束该方法,而是去寻找异常处理中是否包含finally块,
    (3)如果包含finally块,先去执行finally块----只有当finally块执行结束后系统才会再次跳回到try块和catch块里面的return或者throw,
    (4)如果finally块也使用了return 或throw等导致该方法结束的语句,finally块已经终止了该方法,系统不会再跳回try块、catch块里面的任何代码;
    所以我们尽量避免在包装类里面使用throw 或 return
    5 检查型 非检查型异常
    (1)  受检异常   ( 检查型异常)SQLExpection编译的时候就出现
    java编译器在编译阶段就会抛出的异常。要求程序员必须捕获或声明抛出的异常
           (2)运行时异常、上面的各种异常都是运行时异常; 运行的时候抛出异常
            (3)Error不可恢复的异常,由JVM虚拟机抛出的不可逆转的异常
    内存溢出 磁盘空间不足
    6 实际开发中一般不会自己定义异常,会影响开发效率
    自定义的异常要继承Exception类
    7 throws向上抛出异常
    8异常:自定义的异常必须显示抛出异常,否则程序虚拟机无法识别
    展开全文
  • Java 异常

    2016-07-29 09:31:48
    用户输入的数据也永远正确,选择打开的文件永远存在,我们的程序也没有任何Bug,但是现在情况下,这种情况不现实,我们的项目和代码经常会出现各种各样的异常,我们除了在写代码的时候注意规范之外,还需要理解Java...

    在理想情况下,我们写的程序不会有任何的异常,用户输入的数据也永远正确,选择打开的文件永远存在,我们的程序也没有任何Bug,但是现在情况下,这种情况不现实,我们的项目和代码经常会出现各种各样的异常,我们除了在写代码的时候注意规范之外,还需要理解Java的异常机制;

    用户在遇到异常的时候总是会感觉不爽,久而久之就不想使用我们的软件了,所以遇到异常我们要做到以下几点;

    1.向用户返回,他可以接受的错误提示;

    2.保存数据的完整性;

    3.允许用户以妥善方式退出程序;

    处理错误:

    即遇到错误之后我们处理的方法,比如遇到下标错误,空指针异常,物理错误(磁盘满),代码错误等,当出现这些错误的时候,我们应该怎么去解决啦?

    1.规范代码,规范代码,使我们的代码减少错误,比如判断非空,判断数组下标是否越界等;

    2.返回到一种安全状态,并能够让用户继续操作;

    3.允许用户保存完整的操作结果,并安全退出;

    要做到以上几点,很难,因为Java的异常机制,只是将异常处理的任务从产生错误的地方转到我们的能够处理这种错误的地方。从而知道我们发生了哪些错误和问题,好让我们再程序中进行改进,减少错误发生的概率;

    异常分类:


    来分析一下上图,我们可以看出所有的异常都是由Throwable继承而来,但在下一层立即分解为两个分支:Error和Exception;

    Error类层次结构描述了java运行时系统的内部错误和资源耗尽的错误,我们的程序不应该抛出这样的错误。因为出现了这种错误,我们除了告知用户,并安全退出之外再也无能为力,当然这种错误也很少出现;

    在设计Java程序时,我们需要关注的是Exception层次结构,而这个层次又有两个分支;一个分支派生于RuntimeException,另一个分支派生于IOException;由程序错误导致的异常属于RuntimeException,而由于I/O错误这类问题导致的异常则属于IOException;

    RuntimeException包含的常见异常:

    错误的类型转换;

    数组访问越界;

    访问控指针;

    不是派生于RuntimeException包括的常见异常:

    试图在文件尾部后面读取数据;

    试图打开一个不存在的文件;

    试图根据给定的字符串查找Class对象,而这个字符串表示的对象不存在;

    请记住一条准则那就是如果发生了RuntimeException异常,那么一定是程序员自己的问题了;

    Java将所有派生于IOException的异常称为已检查(checked)异常,而RuntimeExcepton和Error异常称为非检查时异常;

    声明已检查异常:

    如果遇到了无法处理的情况,那么java方法允许抛出一个异常,我们不仅要告诉编译器返回什么值,执行什么动作,也需要告诉编译器可能会发生的错误;

    方法在其首部声明可能会抛出的异常通过throws来进行抛出,当我们抛出的异常所发生的时候,讲不会执行异常后面的代码,而把我们的异常交给异常对象取执行,运行时系统就会开始搜索异常处理器,以便知道如何处理异常对象;那么什么时候该使用throws抛出啦,我们记住以下几点;

    1)调用一个抛出已检查异常的方法。例如I/O异常;

    2)程序出现错误,例如数组下标越界异常;

    3)java虚拟机和运行时库出现的内部错误;

    抛出:

    除了声明异常之外,我们还可以捕获异常。这样会使异常不被抛出到方法之外。也不需要throw规范。另外如果子类覆盖了父类的某个方法,那么父类的异常的通用性要大于子类,或者子类不需要抛出异常;把异常全部交给父类处理;

    对于一个已经存在的异常类,将其抛出非常容易,在这种情况下:

    1)找到一个合适的异常类。

    2)创建这个类的一个对象。

    3)将对象抛出。

    自定义异常类:

    在程序中我们可能会遇到标准异常类无法描述的问题。在这种情况下我们就需要创建自己的异常类了。我们需要做的只是定义一个派生于Exception的类,或者派生于

    Exception子类的类。我们定义的类,应当有两个构造器,一个是默认的,另外一个是带有详细描述信息的构造器。它会打印详细信息,这在调式中非常有用;

    [java] view plain copy
    1. public class IUnusual extends ArithmeticException{  
    2.   
    3.     public IUnusual() {  
    4.         super();  
    5.     }  
    6.   
    7.     public IUnusual(String s) {  
    8.         super(s);  
    9.     }  
    10.     public static void division(int x,int y) throws IUnusual{  
    11.         int fruit;  
    12.         if(y==0){  
    13.             throw new IUnusual("除数不能为0");  
    14.             }  
    15.         fruit=x/y;  
    16.     }  
    17.     public static void main(String[] args) {  
    18.         try {  
    19.             division(1,0);  
    20.         } catch (IUnusual i) {  
    21.             System.out.println(i.getMessage());  
    22.         }  
    23.     }  
    24. }  

    上面一段简单的自定义异常类,自我感觉用处不大,好像没什么意义。如果用java做web程序的话,像这些输入验证都是用js验证的;

    捕获:

    有些代码除了抛出异常之外,我们还需要捕获以下。捕获异常其实很简单try/catch/finally

    [java] view plain copy
    1. try{  
    2.       code  
    3.       more code  
    4.       more code  
    5. }catch(ExceptionType e){  
    6.       异常处理  
    7. }finally{  
    8.      总是执行这段代码;  
    9. }  
    如果try语句中出现异常了,那么程序将跳过try语句后面的代码。程序将去匹配catch里面的异常处理器,如果匹配到了就执行catch里面的代码,如果没有匹配到就去执行finally里面的代码,不管有没有出现异常finally里面的代码总是执行;一般我们用它来关闭数据库连接或者I/O的连接;

    [java] view plain copy
    1. try {  
    2.             division(1,1);  
    3.         } catch (IUnusual | NullPointerException i) {  
    4.             System.out.println(i.getMessage());  
    5.         }finally{  
    6.               
    7.         }  
    JDK1.7以后可以合并catch字句;捕获多个异常可以让我们的代码看起来更简单还会更高效;带资源的try 语句,如果我们的的try语句发生了异常,而执行finally关闭连接是时候也发生了异常,那么新异常会覆盖旧异常,而旧异常有可能是非常重要的,那么这个时候我们就可以用带try资源的块,他会自动的去关闭连接;

    [java] view plain copy
    1. try(FileInputStream file=new FileInputStream("d:"))  
    使用异常的技巧:

    1.异常处理不能代替简单的测试;

    2.不要过分的细化异常;

    3.利用异常层次结构;

    4.不要压制异常;

    5.在检测异常错误时,捕获要比抛出更好;

    6.不要羞于传递异常;

    5和6可以归纳为早抛出,晚捕获;

    展开全文
  • Java异常处理

    2020-04-17 00:45:10
    这一篇讲Java异常机制,在理想的情况下,用户输入的数据以及格式都是正确的,选择的文件也存在,在代码中没有bug的存在。有句话说的好:理想很丰满,现实很骨感。有些用户对应用系统并不是很了解导致输入错误,...

    一.概述

    上一篇讲了Java代理机制,这个技术对于应用程序开发并不是很有用,对于类库设计或者工具设计是非常有用的。链接:Java代理
    这一篇讲Java的异常机制,在理想的情况下,用户输入的数据以及格式都是正确的,选择的文件也存在,在代码中没有bug的存在。有句话说的好:理想很丰满,现实很骨感。有些用户对应用系统并不是很了解导致输入错误,比如在输入金额的时候只能输到元,但用户不知道他输入到了分,此时系统由于无法处理分的情况导致系统发生错误,甚至有些更加严重的bug导致系统崩溃,这都是有可能的。所以为了解决这一个问题,产生了Java异常处理。一旦发生错误,我可以做到:

    • 向用户通告错误
    • 保存错误的日志
    • 允许用户能正常使用其他的业务或以妥善的形式退出程序

    二.异常

    1.错误的种类

    (1)用户输入的错误:有些用户不遵守程序的正常操作,导致系统无法响应。
    (2)设备错误:比如打印机在打印的时候没有纸了。
    (3)物理限制:磁盘满了。
    (4)代码错误:比如我们平常的空指针异常。
    对于方法中的一个错误,通常是返回一个特设的错误码,由调用方法分析。但有的时候无法返回一个错误码,而是抛出了一个封装错误信息的异常对象。这个时候,这个方法会立即停止,异常处理机制开始。

    2.异常的分类

    异常分类
    Throwable:所有异常的父类。
    Error:Java运行时系统的内部错误和资源耗尽错误。一旦出现这种异常是无法补救的,只能告诉用户无法使用,安全的终止程序。
    Exception:这是应用程序需要关注的异常。
    RuntimeException:由程序错误导致的异常。

    • 错误的类型转换
    • 数组访问越界
    • 访问null指针

    IOException:程序本身没有错误,但由于像I/O错误这类问题导致的异常属于其他异常。

    • 试图在文件尾部后面读取数据
    • 试图打开一个不存在的文件
    • 试图根据给定的字符串查找Class对象,而这个字符串表示的类不存在

    注意:如果出现RuntimeException异常,就一定是你的问题!!!
    Java语言规范将继承Error类或RuntimeException类的所有异常称为非受查异常,除此之外都是受查异常。

    3.声明受查异常

    在不知道会不会发生异常的地方,就可以采取抛出一个异常。例如:不确定文件是否存在,可能存在IOException异常。

    public String getString()throws Exception;
    

    如果发生异常就抛出一个Exception异常对象,而不会返回一个String对象。throws关键字代表抛出一个异常对象。 那么在声明方法的时候该如何进行异常的声明??

    • 调用一个抛出受查异常的方法。
    • 程序运行过程中发现错误,并且利用throw语句抛出一个受查异常。
    • 程序出现错误。
    • Java虚拟机和运行时库出现的内部错误。

    前两种情况必须要告诉调用这个方法的程序员有可能抛出的异常。

    	// 声明一个异常方法
    	public void getString() throws Exception{}
    
    	// 多个异常的时候用逗号隔开
    	public void getString() throws IOException,Exception{}
    

    注意:

    • 如果子类中覆盖了超类的一个方法,子类方法中声明的受查异常不能比超类方法中声明的异常更通用
    • 如果超类方法没有抛出异常,那么子类也不能抛出任何异常。

    4.如何抛出异常

    • 找到一个合适的异常类
    • 创建这个类的对象
    • 将对象抛出
    	// 抛出异常
    	// 注意想要抛出异常必须要声明异常
    	// 抛出的异常不能超过父类的范围,比如父类抛出了Exception那么子类只能抛出Exception的子类
    	public void getString() throws Exception {
    		throw new Exception();
    	}
    

    5.创建异常

    如果没有更能描述想要描述的问题时,可以进行自定义异常类。

    // 自定义异常类
    // 注意命名的时候用Exception结尾
    // 习惯性定义两个构造方法
    public class DemoException extends Exception{
    	public ExceptionDemo() {
    	}
    
    	public ExceptionDemo(String message) {
    		super(message);
    	}
    }
    

    三.捕获异常

    1.捕获异常

    如果异常不进行捕获进行处理的话,最终会抛给虚拟机处理,但是虚拟机一旦抛出异常就会导致程序终止,所以要在最后调用方将异常捕获并处理。

    /**
    	 * 异常捕获
    	 * 规律:通常将知道如何处理的异常进行捕获并处理,将不知道的异常继续向调用这传递
    	 */
    	public void getString1(){
    
    		try {
    			// 放置存在异常的代码
    
    			// 如果存在异常则跳过剩余代码进入catch块
    
    		}catch (Exception e) {
    			// catch块进行捕获对应类型的异常信息
    			// 如果捕获不到对应类型的异常程序就会终止
    			// 当异常发生的时候进行的代码
    			// 这部分代码往往只是打印日志什么都不会做,但是要声明异常此方法可能会抛出某种异常信息
    		}
    		// 如果不存在异常继续往下执行代码
    	}
    

    2.捕获多个异常

    在捕获异常的catch块可以多个catch块连用,分别捕获不同类型的异常类并作出不同的处理。异常的所有信息都包含在异常对象中。

    	/**
    	 * 捕获多个异常
    	 * 注意:捕获多个异常的时候必须要类型要依次扩大,不能颠倒顺序
    	 */
    	public void getString2(){
    
    		try {
    			
    			// catch块的顺序是类型依次增大
    			// 不存在父子类关系的异常可以同时捕获
    		}catch (FileNotFoundException  | UnknownHostException e) {
    
    		}catch (IOException e) {
    
    		}
    
    	}
    

    3.再次抛出异常与异常链

    /**
    	 * 再次抛出异常
    	 */
    	public void getString3() throws Throwable {
    
    		try {
    			
    		}catch (IOException e) {
    			// 如果将此方法再次抛出异常时,推荐包装一层,这样可以让用户抛出子系统的高级异常,而不会丢失原始异常的细节
    			Throwable throwable = new SQLException("....");
    			throwable.initCause(e);
    			throw throwable;
    		}
    	}
    

    4.finally的使用

    当代码抛出异常的时候此方法后面的语句就不会在进行了,但是如果开启了某些资源,例如输入输入流等,在最后不使用的时候就应该关闭。这时候就要使用finally语句。

    /**
    	 * finally语句
    	 */
    	public void getString4() {
    
    		try {
    			// 正常代码
    		} catch (Exception e) {
    			// 发生异常时的代码
    		} finally {
    			// 不管代码是否发生异常都要执行的代码
    			// 不要在这里使用return语句这样有可能会修改原来方法的返回值
    		}
    
    		try {
    
    		}finally {
    			// 这种写法就是不捕获异常只是为了关闭资源文件异常抛出由调用方解决
    		}
    
    		// 强烈建议解耦合try/catch和try/finally语句,这样可以提高代码的清晰度
    		// 将问题代码和无问题代码要分清楚这样才能是代码更加清楚,发现错误的时候更能快速定位
    
    		// 外层就是为了捕获异常,而且能捕获finally中的错误
    		try {
    			// 内层语句只用作关闭资源
    			try {
    
    			}finally {
    
    			}
    		}catch (Exception e) {
    			// 如果在关闭资源时出现问题而没有捕获那么资源就会关闭失败这样会出现问题
    		}
    
    	}
    
    	/**
    	 * 带资源的try语句
    	 */
    	public void getString5(){
    
    		// 括号中编写打开资源的语句,这样在块退出的时候会自动调用inputStream.close()方法
    		// 如果在关闭资源的时候抛出异常,原来的异常会重新抛出,而close方法抛出的异常会"被抑制",这些异常将自动捕获
    		try(InputStream inputStream = new FileInputStream("")){
    
    		} catch (Exception e) {
    
    		}
    	}
    

    5.分析堆栈轨迹

    堆栈轨迹就是一个方法调用过程的列表。

    /**
     * 分析堆栈轨迹元素
     */
    public class StackTraceDemo {
    	public static int factorial(int n) {
    		System.out.println("factorial(" + n + "):");
    		Throwable t = new Throwable();
    		StackTraceElement[] frames = t.getStackTrace();
    		for (StackTraceElement frame : frames) {
    			// 打印调用方法的轨迹
    			System.out.println(frame);
    		}
    		int r;
    		if (n <= 1) {
    			r = 1;
    		}else {
    			r = n * factorial(n -1);
    		}
    		System.out.println("return " + r);
    		return r;
    	}
    
    	public static void main(String[] args) {
    		Scanner in = new Scanner(System.in);
    		System.out.println("Enter n: ");
    		int n = in.nextInt();
    		factorial(n);
    	}
    }
    

    四.使用异常机制的技巧

    1.异常处理不能代替简单的测试。

    2.不要过分的细化异常。

    3.利用异常层次结构。

    (1)不要只抛出RuntimeException异常。
    (2)不要只捕获Thowable异常。
    (3)考虑受查异常与非受查异常的区别。
    (4)将一种异常转换成另一种更加适合的异常时不要犹豫。

    4.不要压制异常。

    5.在检测错误时,“苛刻”要比放任更好。

    在用无效的参数调用一个方法的时候,抛出一个异常比返回一个null更好。

    6.不要羞于传递异常。

    在使用抛出异常的方法时,传递异常比捕获异常更好。让更好层次的方法通知用户发生了错误,或者放弃不成功的命令更加适宜。

    五.总结

    异常机制可以处理在有可能发生错误的地方更加安全,不至于程序停止导致整个应用无法使用的情况,一个好的代码不仅在编写的格式,逻辑性强意外,也要将异常流程考虑清楚。这样才可以使代码具有更加的健壮性,不易出现漏洞,即使用户不按照正常操作使用,也可以处理这些意外的情况发生。

    下一篇讲解断言和日志的基本使用。
    有些可能我理解的不够深刻,大家如果觉得我说的不够详细可以参考我的推荐书,详细的看一下。欢迎大家评论。第一时间我会回复大家。谢谢!

    展开全文
  • Java异常体系

    2019-08-22 12:17:29
    有的异常是不能避免的,如读取的文件不存在,或输入的数据格式不匹配都会导致异常的发生,异常机代表一种错误,又代表一种信息,遇到不是代码问题产生的不正常的现象,程序需要将这种异常的情况包装起来,告知用户,...
  • java 异常处理

    2015-01-05 14:50:00
    一、异常概述 异常处理是面向对象语言区别于面向过程语言的重要标志之一,... 1.1 用try-catch处理异常 try…catch是处理异常的两种方法之一,适合处理程序员可以控制和用户输入有误的情况,以起到程序开发顺利进行...
  • java常用异常

    2021-05-10 10:34:15
    对于我们程序可能会出现的一些异常,可能无法通过我们写的代码去避免(空指针,文件没有找到,ClassNotfoundException,用户输入的格式),异常如果出现,我们需要在程序中进行处理,如果不进行处理很可能会影响程序的...
  • java自定义异常

    2016-12-22 21:04:14
    做工程的是很多的异常我们必须要自己去定义,如果拿Java写好的异常去做那些工程什么空指针错误什么...用户没有学过编程不知道什么是空指针错误什么什么是类型转换错误,他们不知道。  所以Java在这方面就给我们程...
  • 如何正确使用Java异常处理机制 ... ...本文的目标是如何正确使用Java异常处理机制...在理想境界中,程序永远不会出现问题,用户输入的数据永远是正确的,逻辑没有任何问题 ,选择打开的文件也一定是存在的,内存永远是
  • java中的异常

    2021-02-28 19:13:58
    检查性异常:是由用户的不合理输入而引起的异常。(如果用户输入x/0那么程序就会异常) 运行是异常:由于程序猿的逻辑疏忽,在编译时异常无法被察觉,运行时才会出现异常。 错误:错误不是异常,而是脱离程序猿的...
  • 学习java的过程中,...这个时候就需要我们程序员来考虑到可能用户输入的各种情况来设计异常处理以便程序不会中途崩溃,导致工程项目的失败。  说实话,在这之前,似乎从来没有考虑过工程的健壮性,也就没有进行...
  • Java中的异常

    2020-06-08 16:08:27
    Java中的异常 ...但是,如果用户没有按照要求进行输入,如果被除数没有输入数字,而是输入了“abc”,则程序将会发生异常,运行结果如下: 输出告诉我们:在ExTest类的main函数中,出现了输入格式
  • java.lang.reflect.InvocationTargetException 并且同时带有空指针异常, 该错误来源于,实现用户自动登录功能时:登录界面,当输入用户名和密码后,没有勾选自动登录按钮,结果在UserServlet中实现方法时,只要有...
  • Java异常---巩固强化

    2020-04-26 17:39:55
    在理想世界里,用户输入输入数据的格式永远是正确的,选择打开的文件也一定存在,代码用于不会出现bug。但现实是,程序员经常会转角遇到爱… 假设在一个Java程序运行期间出现了一个错误。这个错误可能是由于文件包含...
  • Java进阶之路 异常

    2015-09-15 17:38:12
    用户输入的数据也永远正确,选择打开的文件永远存在,我们的程序也没有任何Bug,但是现在情况下,这种情况不现实,我们的项目和代码经常会出现各种各样的异常,我们除了在写代码的时候注意规范之外,还需要理解Java...
  • Java 笔记 15:异常

    2020-07-25 10:35:34
    Java 笔记 15异常try...catchfinallyThrowsThrow自定义异常 异常 异常: ...或Java异常处理的过程? (1)当程序运行到某一句时,发生了异常,那么程序会先停下来 (2)程序会在这句代码处,查看原因
  • 关于JAVA中的异常

    2020-03-28 21:49:23
    关于JAVA中的异常异常是什么有什么用怎么用1.异常图解2.异常的使用总结 异常是什么 在计算机程序运行的过程中,总是会出现各种各样的错误。 有一些错误是用户造成的,比如,希望用户输入一个int类型的年龄,但是...
  • 在程序运行期间,用户可能会输入错误格式的数据造成程序的崩溃,这时Java使用一种异常处理的错误捕获机制来处理。在测试期间需要进行大量的检测以验证程序操作的正确性,这时可以使用断言来有选择地启用检测。当程序...
  • java基础--异常

    2019-07-24 21:03:40
    java.util.InputMismatchException 输入类型不匹配异常 1: jvm会处理程序中未处理的异常 a:暂停程序 b:报错(异常内容【什么异常 原因描述】异常行数 ) 2: 不要让jvm去处理异常 3:解决异常的办法: 处理...
  • 81.Java异常概述

    2012-11-19 09:40:36
    即使写的程序没有错,也不要指望你的用户能按照你的意愿来执行程序,比如,你不要指望用户的网络是畅通的,你不要指望你需要的某个文件一定会在它应该存在的位置,你不要期待用户一定会在需要数字的地方输入数字而...
  • Java_关于异常的总结

    2019-09-15 14:06:00
    ”假如用户没有按照要求,输入的是“5”,那么就会出现异常情况。 出现异常的原因 1.java 内部错误发生异常Java 虚拟机产生的异常。 2.编写的程序代码中的错误所产生的异常,例如数组越界异常。这种异常称为未检査...
  • 理想世界中,用户输入的数据的格式永远都是正确的,选择文件都是存在的,代码永远不会出现bug,但在现实世界中,却往往充满了不良的数据和有问题的代码,而这些问题产生的结果我们称之为异常。 遇到异常我们应该怎么...
  • 用户输入错误 设备错误 物理限制 代码错误 当某个方法不能够采用正常的路径完成它的任务,就可以通过另外一个一个路径退出方法。这种情况下,方法并不返回任何值,而是抛出(throw)一个封装了错误信息的对象。要...
  • JavaSE_81_Java异常

    2014-04-23 01:48:31
    即使写的程序没有错,也不要指望你的用户能按照你的意愿来执行程序,比如,你不要指望用户的网络是畅通的,你不要指望你需要的某个文件一定会在它应该存在的位置,你不要期待用户一定会在需要数字的地方输入数字而...
  • 用户造成的:输入了不匹配的数据类型、程序想要读取文件时用户已经删除了 随机出现、不可避免:断网无法连接服务器、没有打印机、内存耗尽 Java语言内置了一套异常处理机制,总是用异常来处理错误 异常是一种class,...
  • JAVA异常捕捉机制 概念 在程序中,错误可能产生于程序员没有料想到的情况之外,或者是超过了程序员可以控制的范围的环境因素,例如用户的坏数据,试图打开一个根本不存在的文件等等。在JAVA中这种在程序运行时...
  • 下面就来给大家介绍一下Java异常处理。 ​  异常是如何产生的?  异常是程序中的一些错误,但并不是所有的错误都是异常,有些异常需要做处理,有些则不需要捕获处理。有些在Java程序中出现异常的原因通常包括三...

空空如也

空空如也

1 2 3 4 5 ... 15
收藏数 287
精华内容 114
关键字:

用户没有输入java异常

java 订阅