你好,游客 登录 注册 搜索
背景:
阅读新闻

Java异常使用心得

[日期:2017-06-28] 来源:Linux社区  作者:kyyee [字体: ]

异常处理是 Java 设计最引以为傲的一个地方。Java 的设计者们提供了处理编译及运行时异常的机制,这极大的增强了程序的健壮性。这里不得不提 Java 的设计哲学:没有完善异常处理的代码根本没有机会被执行。

Java 异常的体系结构

Throwable

java.lang.Throwable
—|——Error:错误,程序中不进行处理
——|——Exception:异常,要求在编写程序时,就要考虑到对这些异常的处理
———|——编译时异常:在编译期间会出现的异常(执行 javac.exe 命令时,出现异常)
———|——运行时异常:在运行期间出现的异常(执行 java.exe 命令时,出现异常)

Error

/**
 * @author kyyee
 *
 */
public class TestError {
    public static void main(String[] args) {
        // java.lang.StackOverflowError
        main(args);
        // java.lang.OutOfMemoryError: Java heap space
        // byte[] b = new byte[1024 * 1024 * 1024];
        System.out.println(b);
    }
}

代码 main(args); 会出现 StackOverflowError (栈空间溢出错误)。
代码 byte[] b = new byte[1024*1024*1024]; 会出现 OutOfMemoryError (堆空间溢出错误)。

Exception

异常通常被分为两种:检查型异常(CheckedException)、运行时异常(RuntimeException)。

注意:检查型异常与编译时异常同义。

1.常见的运行时异常:

  1. 数组下标越界异常:java.lang.ArrayIndexOutOfBoundsException: -10
  2. 算数除 0 异常:java.lang.ArithmeticException: / by zero
  3. 类型转换异常:java.lang.ClassCastException: java.util.Date cannot be cast to java.lang.String
  4. 空指针异常:java.lang.NullPointerException
  5. 传递非法参数异常:java.lang.IllegalArgumentException
  6. 数字格式错误异常:java.lang.NumberFormatException

2.检查型异常:

  • 所有的非运行时异常都是检查型异常

如何处理异常

Java 提供了基于抓抛模型的异常处理办法

1.”抛“:当我们执行代码时,一旦出现异常,就会在异常的代码处生成一个对应的异常类型的对象,并将此对象抛出

  • 一旦抛出此异常类的对象,那么异常之后的代码立即停止执行
  • 此异常类的对象抛给方法的调用者
  • Java 有两种抛出异常的方式(自动抛出/手动抛出)

2.”抓“:抓住抛出来的异常类的对象。如何抓?即为异常处理的方式

  • Java 提供了两种方式来处理异常类的对象

Java 处理异常类的两种方式

方式一

将可能出现异常的代码块用 try-catch-finally 结构包起来,在 catch 中提供相应的处理办法,而 finally 中是一定会被执行的代码。

        try{
            // 可能出现异常的代码
            ...
        } catch(Exception1 e1){
            // 处理的方式1
            ...
        } catch(Exception2 e2){
            // 处理的方式2
            ...
        } finally {
            // 一定会执行的代码
            ...
        }

捕获IO异常

// 编译时异常
    @Test
    public void test6() {
        FileInputStream fis = null;
        try {
            fis = new FileInputStream(new File("hello.txt"));
            int len;
            byte[] b = new byte[10];
            while ((len = fis.read(b)) != -1) {
                System.out.println(b);
                System.out.println(len);
            }
        } catch (FileNotFoundException e) { // 子类异常在父类异常上被捕获
        } catch (IOException e) {
        } finally {
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

注意:

  1. try{} 代码块内声明的变量类似于局部变量,出了 try{} 语句,就不能被使用
  2. finally 是可选的
  3. catch 语句内部是对异常对象的处理=>e.getMessage(); =>e.printStackTrace();
  4. 可以有多个 catch 语句,try 中抛出的异常类对象从上往下去匹配 catch 中的异常类的类型,一旦满足就执行 catch 中的代码。执行完跳出其后的多余 catch 语句
  5. 如果异常处理了,那么其后的代码继续执行
  6. 若 catch{} 多个异常类型是“并列”关系,孰上孰下都可以。若 catch{} 多个异常类型是“包含”关系,须将子类放在父类的上面进行处理,否则编译错误
  7. finally 中存放的是一定会被执行的代码,不管 try 中、catch 中是否仍有异常未被处理,以及是否有 return 语句
  8. try-catch 是可以嵌套的

对于运行时异常来说,可以不显示的进行处理。对于编译时异常来说,必须要显式的进行处理。

方式二

在方法的声明处,显式的抛出该异常对象的类型,关键字:throws。
当在此方法内部出现异常的时候,会抛出一个异常类的对象,抛给方法的调用者,异常类的对象可以逐层向上抛,直至 main 方法。
当然在向上抛的过程中,可以在方法调用者中通过 try-catch-finally 来处理抛出的异常。

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

/**
 * Created by kyyee on 2017/6/8.
 */
public class TestException {
    public static void main(String[] args) {
        TestException t = new TestException();
        try {
            t.TestInput();
        } catch (IOException e) {
            System.out.println(e.getMessage());
            e.printStackTrace();
        }
    }

    private void TestInput() throws IOException {
        FileInputStream fis = new FileInputStream(new File("hello.txt"));
        int b;
        while ((b = fis.read()) != -1) {
            System.out.println((char) b);
        }
        fis.close();
    }
}

如何自定义一个异常类

自定义的异常类继承现有的异常类,提供一个序列号,提供几个重载的构造器。

public class MyException extends RuntimeException {
    private static final long serialVersionUID = 2989193327207396613L;

    public MyException() {
        super();
    }

    public MyException(String message, Throwable cause) {
        super(message, cause);
    }

    public MyException(String message) {
        super(message);
    }

    public MyException(Throwable cause) {
        super(cause);
    }
}

如何手动抛出一个异常类

抛出的异常类型,若是RuntimeException,可以不用显式的处理,若是一个Exception,必须要显式的处理。换句话说,RuntimeException不用向外抛(throws)或不用抓(try-catch-finally);而Exception要么向外抛(throws),要么在某一级抓(try-catch-finally)。

public class TestCricle {
    /**
     * @param args
     */
    public static void main(String[] args) {
        Cricle cricle = new Cricle(3.14);
        Cricle cricle2 = new Cricle(4.24);
        System.out.println(cricle.compareTo(cricle2));
        System.out.println(cricle.compareTo(2));
    }
}

final class Cricle {
    private double radius = 0D;

    public Cricle() {
        super();
    }

    public Cricle(double radius) {
        super();
        this.radius = radius;
    }

    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    @Override
    public String toString() {
        return "Cricle [radius=" + radius + "]";
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        long temp;
        temp = Double.doubleToLongBits(radius);
        result = prime * result + (int) (temp ^ (temp >>> 32));
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Cricle other = (Cricle) obj;
        if (Double.doubleToLongBits(radius) != Double
                .doubleToLongBits(other.radius))
            return false;
        return true;
    }

    public int compareTo(Object obj) {
        if (this == obj) {
            return 0;
        } else if (obj instanceof Cricle) {
            Cricle c = (Cricle) obj;
            if (c.radius < this.radius) {
                return -1;
            } else if (c.radius == this.radius) {
                return 0;
            } else {
                return 1;
            }
        } else {
            throw new MyException("传入类型与Circle类型不匹配");
        }
    }
}

重写方法含有 throw Exception

重写方法不能抛出父类中没有的检查型异常
重写方法不能抛出父类抛出异常的父异常,如父类中的方法抛出FileNotFoundException,则该重写方法不能抛出IOException

public class TestOverride {
    public static void main(String[] args) {
        A a = new B();
        try {
            a.method1();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        B b = new B();
        try {
            b.method1();
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

class A {
    public void method1() throws IOException {
        System.out.println("我是父类");
    }
}

class B extends A {
    /*
     * (non-Javadoc)
     * 
     * @see com.nantian.exception.A#method1()
     */
    @Override
    public void method1() throws FileNotFoundException {
        System.out.println("我是子类");
    }
}

结语

java的异常处理:抓抛模型

  1. 抓:异常的处理,有两种方式(1.try-catch-finally,2.throws)
  2. 抛:一旦执行过程中出现异常,会抛出一个异常类的对象(自动抛出 vs 手动抛出 throw new 异常类对象),既可以是系统现有的异常类,也可以是自己创建的异常类

总结: Java 异常处理有 5 个关键字:try , catch , finally , throws , throw。自定义异常继承自 Exception,如果不处理异常,则编译不通过,也就是说继承自 Exception 的异常是检查型异常;自定义异常继承自RuntimeException,可以不处理异常,可编译通过,也就是说继承自 RuntimeException 的异常是运行时异常。

本文永久更新链接地址http://www.linuxidc.com/Linux/2017-06/145267.htm

linux
相关资讯       Java异常 
本文评论   查看全部评论 (0)
表情: 表情 姓名: 字数

       

评论声明
  • 尊重网上道德,遵守中华人民共和国的各项有关法律法规
  • 承担一切因您的行为而直接或间接导致的民事或刑事法律责任
  • 本站管理人员有权保留或删除其管辖留言中的任意内容
  • 本站有权在网站内转载或引用您的评论
  • 参与本评论即表明您已经阅读并接受上述条款