当前位置:龙哥网 > 网络技术 > Java IO流—异常及捕获异常处理 try…catch…finally_java

Java IO流—异常及捕获异常处理 try…catch…finally_java

longge3个月前 (03-01)网络技术43
目录
  • 一、java IO流
    • 1、概念
    • 2、IO流的分类(按流向划分)
    • 3、IO流的分类(按操作单元划分)
    • 4、IO流的分类(流的角色划分)
  • 二、Java 异常
    • 1、概述
    • 2、常见的异常
    • 3、异常的分类
  • 三、异常处理方案
    • 1、try…catch…finally
  • 四、try…catch 处理方式
    • 1、一个异常的情况与多个异常的情况
  • 五、Throwable中的方法
    • 1、getMessage()
    • 2、toString()
    • 3、printStackTrace()
    • 4、printStackTrace(PrintStream s)
  • 六、throws
    • 1、概述
  • 七、throw
    • 1、概述
  • 八、throws和throw的区别
    • 九、try…catch…finally…
      • 1、格式
      • 2、注意
      • 3、代码
    • 十、final , finally 和 finalize的区别
      • 十一、异常注意事项

        一、Java IO流

        1、概念

        • 在Java中,把不同的输入源 / 输出源(如:键盘、文件、网络链接等)抽象的表述为“流”(stream)
        • 通过 ”流“ 的形式允许Java程序使用相同的方式访问不同的输入 / 输出源
        • Java 把所有传统的”流“放在了 java . io 包下

        2、IO流的分类(按流向划分)

        • 输入流:只能从中读取数据,不能写入
        • 输出流:只能写入数据,不能读取数据

        3、IO流的分类(按操作单元划分)

        • 字节流:操作单元是8位的字节,主要是 InputStream 和 OutputStream 作为基类
        • 字符流:操作单元是16位的字符,主要是 Reader 和 Writer 作为基类

        4、IO流的分类(流的角色划分)

        • 节点流:可以向一个特定的 IO 设备(如磁盘等)读 / 写数据的流,也称为:低级流
        • 处理流:用于对一个已存在的流进行连接和封装,通过封装后的流来实现数据的读/写功能,也称为高级流

        二、Java 异常

        1、概述

        • Java在运行程序过程中出现的错误

        Java IO流—异常及捕获异常处理 try…catch…finally_java

        2、常见的异常

        • 空指针异常类:NullPointerException
        • 类型强制转换异常:ClassCastException
        • 数组下标越界异常:ArrayIndexOutOfBoundsException
        • 算术异常类:ArithmeticExecption
        • 数组负下标异常:NegativeArrayException

        Java IO流—异常及捕获异常处理 try…catch…finally_java

        3、异常的分类

        Java IO流—异常及捕获异常处理 try…catch…finally_java

        Java IO流—异常及捕获异常处理 try…catch…finally_java

        三、异常处理方案

        1、try…catch…finally

        格式:

        try {
        	可能出现问题的代码;
        }catch(异常名 变量) {
        	针对问题的处理;
        }finally {
        	释放资源;
        }
        

        代码:

        package yichang01;
        public class ExceptionDemo {
            public static void main(String[] args){
                System.out.println("start");
                int[] arr = {1,2,3,4,5};
                try {
                    System.out.println(arr[5]);
                }catch (Exception e){
                    System.out.println("发生了异常:"+e.getMessage());
                    e.printStackTrace();//打印异常的栈
                }finally {//有没有异常都会执行 finally 里的代码
                    System.out.println("释放资源,必须执行的代码块");
                }
                //System.out.println(arr[5]);//数组下标越界
                System.out.println("end");
            }
        }
        

        Java IO流—异常及捕获异常处理 try…catch…finally_java

        变形格式:

        try {
         	可能出现问题的代码;
        }catch(异常名 变量) {
        	针对问题的处理;
        }
        
        package yichang01;
        public class ExceptionDemo {
            public static void main(String[] args) {
                System.out.println("start");
                int a = 10;
                int b = 0;
                try {
                    System.out.println(a / b);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                    e.printStackTrace();
                }
                System.out.println("end");
            }
        }
        

        注意:

        • try 里面的代码越少越好
        • catch 里面必须有内容,哪怕给出一个简单的提示

        四、try…catch 处理方式

        1、一个异常的情况与多个异常的情况

        package yichang01;
        public class ExceptionDemo {
            public static void main(String[] args) {
                //method1();//一个异常的情况
                //method2();//两个异常、分别处理的情况
                //method3();//两个异常、一块处理的情况
                method4();
            }
            private static void method4() {
                int a = 10;
                int b = 0;
                int[] arr = {1, 2, 3};
                try {
                    Object o = 123;
                    String s = (String) o; //ClassCastException
                    System.out.println(arr[3]); //IndexOutOfBoundException
                    System.out.println(a / b); //ArithmeticException
                    System.out.println("这里出现了一个异常,你不太清楚是谁,该怎么办呢?");
                } catch (ArithmeticException e) {
                    System.out.println("除数不能为0");
                } catch (ArrayIndexOutOfBoundsException e) {
                    System.out.println("你访问了不该的访问的索引");
                } catch (Exception e) {
                    System.out.println("出问题了");
                }
                System.out.println("over");
            }
            private static void method3() {
                int a = 10;
                int b = 0;
                int[] arr = {1, 2, 3, 4, 5};
                try {
                    System.out.println(a / b);
                    System.out.println(arr[5]);
                } catch (ArithmeticException e) {
                    System.out.println("除数不能为0");
                } catch (ArrayIndexOutOfBoundsException e) {
                    System.out.println("索引越界");
                }
                System.out.println("end");
            }
            private static void method2() {
                int a = 10;
                int b = 0;
                try {
                    System.out.println(a / b);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                    e.printStackTrace();
                }
                System.out.println("end1");
                int[] arr = {1, 2, 3, 4};
                try {
                    System.out.println(arr[4]);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                    e.printStackTrace();
                }
                System.out.println("end2");
            }
            private static void method1() {
                int a = 10;
                int b = 0;
                try {
                    System.out.println(a / b);
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                    e.printStackTrace();
                }
                System.out.println("end");
            }
        }
        

        五、Throwable中的方法

        1、getMessage()

        获取异常信息,返回字符串。

        2、toString()

        获取异常类名和异常信息,返回字符串。

        3、printStackTrace()

        获取异常类名和异常信息,以及异常出现在程序中的位置。返回值void。

        4、printStackTrace(PrintStream s)

        通常用该方法将异常内容保存在日志文件中,以便查阅。

        package yichang01;
        import java.text.ParseException;
        import java.text.SimpleDateFormat;
        import java.util.Date;
        public class ExceptionDemo {
            public static void main(String[] args) {
                String s = "2019-06-17";
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                try {
                    Date d = sdf.parse(s);
                    System.out.println(d);
                } catch (ParseException e) {
                    System.out.println(e.getMessage());
                    System.out.println(e.toString());
                    e.printStackTrace();
                }
                System.out.println("end");
            }
        }
        

        六、throws

        1、概述

        定义功能方法时,需要把出现的问题暴露出来,让调用者去处理

        Java IO流—异常及捕获异常处理 try…catch…finally_java

        package yichang02;
        import java.text.ParseException;
        import java.text.SimpleDateFormat;
        import java.util.Date;
        public class ExceptionDemo {
            public static void main(String[] args) throws ParseException {
                System.out.println("start");
                method1();
                System.out.println("end11");
                //method2();
                System.out.println("end22");
            }
            private static void method2() throws ArithmeticException {//运行期异常抛出
                int a = 10;
                int b = 0;
                System.out.println(a / b);
            }
            private static void method1() 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);
            }
        }
        

        七、throw

        1、概述

        在功能方法内部出现某种情况,程序不能继续运行,需要进行跳转时,用 throw 把异常对象抛出

        package yichang02;
        public class ExceptionDemo {
            public static void main(String[] args) {
                Student s = new Student();
                s.setage(-30);
            }
        }
        class Student {
            private int age;
            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                if (age > 1) {
                    this.age = age;
                } else {
                    try {
                        throw new Exception("年龄不能小于1");//throw:方法内部,一般出现了逻辑错误,手动抛出的自定义异常
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    this.age = 1;
                }
            }
        }
        

        八、throws和throw的区别

        throws

        • 用在方法声明后,跟的是异常类名
        • 可以跟多个异常类名,用逗号隔开
        • 表示抛出异常,由该方法的调用者来处理
        • throws 表示出现异常的一种可能性,并不一定会发生这些异常

        throw

        • 用在方法体内,跟的是异常对象名
        • 只能抛出一个异常对象名
        • 抛出异常,由方法体内的语句处理
        • throw 则是抛出了异常,执行 throw 则一定抛出了某种异常
        package yichang02;
        class ExceptionDemo {
            public static void main(String[] args) {
                //method1();
                try {
                    method2();
                } catch (Exception e) {
                    System.out.println(e.getMessage());
                    e.printStackTrace();
                }
            }
            private static void method2() throws Exception {
                int a = 10;
                int b = 0;
                if (b == 0) {
                    throw new Exception();
                } else {
                    System.out.println(a / b);
                }
            }
            private static void method1() {
                int a = 10;
                int b = 0;
                if (b == 0) {
                    throw new ArithmeticException();
                } else {
                    System.out.println(a / b);
                }
            }
        }
        

        九、try…catch…finally…

        1、格式

         try...catch...finally
         try...catch
         try...catch...catch...
         try...catch...catch...finally
         try...finally
        

        2、注意

        被finally控制的语句体一定会执行

        用于释放资源,在IO流操作和数据库操作中会见到

        3、代码

        package yichang02;
        import java.text.ParseException;
        import java.text.SimpleDateFormat;
        import java.util.Date;
        class ExceptionDemo {
            public static void main(String[] args) {
                String s = "2019-6-17 12:12:12";
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                Date d = null;
                try {
                    d = sdf.parse(s);
                } catch (ParseException e) {
                    e.printStackTrace();
                    System.exit(0);
                } finally {
                    System.out.println("这是必然执行的代码");
                }
                System.out.println(d);
            }
        }
        
        package yichang02;
        class ExceptionDemo {
            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;
                    return a;
                } catch (Exception e) {
                    System.out.println("catch");
                    a = 30;
                    return a;
                } finally {//释放资源,会执行的代码
                    System.out.println("finally");
                    a = 40;
                    return a;
                }
                // return a;
            }
        }
        

        十、final , finally 和 finalize的区别

        1、final:最终的意思,可以修饰类,成员变量,成员方法

        • 修饰类,类不能被继承
        • 修饰变量,变量是常量
        • 修饰方法,方法不能被重写

        2、finally:是异常处理的一部分,用于释放资源。

        • 一般来说,代码肯定会执行,特殊情况:在执行到finally之前jvm退出了

        3、finalize:是Object类的一个方法,用于垃圾回收

        十一、异常注意事项

        • 子类重写父类方法时,子类的方法必须抛出相同的异常或父类异常的子类。(父亲坏了,儿子不能比父亲更坏)
        • 如果父类抛出了多个异常,子类重写父类时,只能抛出相同的异常或者是他的子集,子类不能抛出父类没有的异常
        • 如果被重写的方法没有异常抛出,那么子类的方法绝对不可以抛出异常,如果子类方法内有异常发生,那么子类只能try,不能throws
        免责声明
        本站部分资源来源于互联网 如有侵权 请联系站长删除
        龙哥网是优质的互联网科技创业资源_行业项目分享_网络知识引流变现方法的平台为广大网友提供学习互联网相关知识_内容变现的方法。#转载请注明出处!