Java学习个人备忘录之异常

概述

异常：是在运行时期发生的不正常情况。

在java中用类的形式对不正常情况进行了描述和封装对象。

描述不正常的情况的类，就称为异常类。

以前正常流程代码和问题处理代码相结合，
现在将正常流程代码和问题处理代码分离，提高阅读性。

其实异常就是java通过面向对象的思想将问题封装成了对象。

用异常类对其进行描述。
不同的问题用不同的类进行具体的描述。

问题很多，意味着描述的类也很多。
将其共性进行向上抽取，形成了异常体系。

最终问题(不正常情况)就分成了两大类
Throwable：无论是error，还是异常，问题发生就应该可以抛出，让调用者知道并处理。
//该体系的特点就在于Throwable及其所有的子类都具有可抛性。
可抛性到底指的是什么呢? 怎么体现可抛性呢?
其实是通过两个关键字来体现的。
throws throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性。
|--1。一般不可处理的。 一般用Error表示
特点:是由jvm抛出的严重性的问题。
这种问题发生一般不针对性处理.直接修改程序。
|--2。可以处理的，一般用Exception表示 。

该体系的特点：
子类的后缀名都是用其父类名作为后缀，阅读性很强。

class ExceptionDemo
{
    public static void main(String[] args)
    {
        int[] arr = new int[3];
        System.out.println(arr[3]);//编译通过，运行不通过  

        sleep(-5);
    }  

    public static void sleep(int time)
    {
        if (time<0)
        {
             //抛出 new FuTime();//就代码的时间为负的情况，这个对象中会包含着问题的名称，信息，位置等信息。
        }
        System.out.println("我睡..."+time);
    }
}
class FuTime
{
}

异常对象的抛出throw  

class Demo
{
    public int method(int[] arr，int index)
    {
        if (arr==null)
        {
            throw new NullPointerException("数组的引用不能为空!");
        }
        if (index>=arr.length)
        {
            throw new ArrayIndexOutOfBoundsException("数组的角标越界了 "+index);//这里就抛出了自定义的异常信息。
        }
        if (index<0)
        {
            throw new ArrayIndexOutOfBoundsException("数组的角标不能为负值 "+index);//这里就抛出了自定义的异常信息。
        }
        return arr[index];
    }
}  

class ExceptionDemo2
{
    public static void main(String[] args)
    {
        int[] arr = new int[3];  

        Demo d = new Demo();
        int num = d.method(arr，30);
        System.out.println("num="+num);
        System.out.println("over");
    }
}

自定义异常&异常类的抛出throws

对于角标是正数不存在，可以用角标越界表示。
对于角标为负数的情况，准备用负数角标异常来表示。

负数角标这种异常在java中并没有定义过。
那就按照java异常的创建思想，面向对象，将负数角标进行自定义描述，并封装成对象。

这种自定义的问题描述称为自定义异常.

class Demo
{
    public int method(int[] arr，int index)throws FuShuIndexException  //表示抛出了。
    {
        if (arr==null)
        {
            throw new NullPointerException("数组的引用不能为空!");
        }
        if (index>=arr.length)
        {
            throw new ArrayIndexOutOfBoundsException("数组的角标越界了 "+index);//这里就抛出了自定义的异常信息。
        }
        if (index<0)
        {
            throw new FuShuIndexException("数组的角标不能为负值 "+index);
        }
        return arr[index];
    }
}  

class ExceptionDemo3
{
    public static void main(String[] args)throws FuShuIndexException
    {
        int[] arr = new int[3];  

        Demo d = new Demo();
        int num = d.method(null，30);
        System.out.println("num="+num);
        System.out.println("over");
    }
}

注意：如果让一个类称为异常类，必须要继承异常体系，因为只有称为异常体系的子类才有资格具备可抛性，才可以被两个关键字所操作，throw，throws。

class FuShuIndexException extends Exception
{
    FuShuIndexException()
    {}
    FuShuIndexException(String msg)
    {
        super(msg);
    }
}

异常的分类：
1。编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系
这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
这样的问题都可以针对性的处理。

2。编译时不检测异常(运行时异常)：就是Exception中的RuntimeException和其子类。
这种问题的发生，无法让功能继续，运算无法进行，更多是因为调用者的原因导致的而或者引发了内部状态的改变导致的。
那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行修正。

所以自定义异常时，要么继承Exception，要么继承RuntimeException。

throws和throw的区别
1。throws使用在函数上。
throw使用在函数内。
2。throws抛出的是异常类，可以抛出多个，用逗号隔开。
throw抛出的是异常对象.

异常捕捉trycatch

异常处理的捕捉形式：
这是可以对异常进行针对性处理的方式.

具体格式是：

try
{
    需要被检测异常的代码。
}
catch(异常类 变量) //该变量用于接收发生的异常对象。
{
    处理异常的代码。
}
finally
{
    一定会被执行的代码
}

class Demo
{
    public int method(int[] arr，int index)throws FuShuIndexException，NullPointerException  //表示抛出了。
    {
        if (arr==null)
        {
            throw new NullPointerException("没有任何数组实体");
        }
        if (index<0)
        {
            throw new FuShuIndexException("数组的角标不能为负值 "+index);
        }
        return arr[index];
    }
}  

class ExceptionDemo4
{
    public static void main(String[] args)throws FuShuIndexException
    {
        int[] arr = new int[3];
        Demo d = new Demo();
        try
        {
            int num = d.method(null，-30);
            System.out.println("num="+num);
        }
        catch (NullPointerException e)
        {
            System.out.println(e.toString());
        }
        catch (FuShuIndexException e)
        {
            System.out.println("message:"+e.getMessage()); //数组的角标不能为负值
            System.out.println("string:"+e.toString());  //FuShuIndexException：数组的角标不能为负值  

            e.printStackTrace();//jvm默认的异常处理机制就是调用异常对象的这个方法。 

            //System.out.println("负数角标异常!!!!");
        }
        System.out.println("over");
    }
}  

class FuShuIndexException extends Exception
{
    FuShuIndexException()
    {}
    FuShuIndexException(String msg)
    {
        super(msg);
    }
}

异常处理的原则：
1。函数内容如果抛出需要检测的异常，那么函数上必须要声明。
否则必须在函数内用trycatch捕捉，否则编译失败。
2。如果调用了声明异常的函数，要么trycatch要么throws，否则编译失败。
3。什么时候catch，什么时候throws呢?
功能内部可以解决，用catch。
解决不了，用throws告诉调用者，由调用者解决。
4。一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性的处理。
内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch个.

finally代码块

class Demo
{
    public int show(int index)
    {
        if (index<0)
        {
            throw new ArrayIndexOutOfBoundsException("角标越界了!!");
        }
        int[] arr = new int[3];
        return arr[index];
    }
}  

class ExceptionDemo5
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        try
        {
            int num = d.show(-3);
            System.out.println("num="+num);
        }
        catch (ArrayIndexOutOfBoundsException e)
        {
            System.out.println(e.toString());  //开发的时候不要写输出语句。
        }
        finally //通常用于关闭(释放)资源
        {
            System.out.println("finally");
        }
    }
}

例如：
连接数据库
查询。Exception
关闭连接

try catch finally 代码块组合特点：

1。try catch finally

2。try catch(多个) 当没有必要资源需要释放时，可以不用定义finally。

3。try finally //必须用throws声明

void show()throws Exception
{
    try
    {
        throw new Exception();
    }
    finally
    {
    }
}

异常的注意事项：
1。子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。

解释：

class A extends Exception
{
}
class B extends A
{
}
class C extends Exception
{
}  

Exception
    |--A
        |--B
    |--C  

class Fu
{
    void show()throws A
    {}
}
class Zi extends Fu
{
    void show()throws A或B  //这里抛出的必须是父类的异常或父类异常的子类，所以不能抛出C
    {}
}

2。如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
解释：如果父类抛出A B C D ，那么子类要么抛出 A B，要么抛出 C D ，要么抛出 A B C ，也可以全抛出，总之就是不能抛出像A B C D E这样的。简单说：子类覆盖父类只能抛出父类的异常或者子类或者子集。
注意：如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。

时间： 2024-08-05 03:30:00

Java学习个人备忘录之异常的相关文章

Java学习个人备忘录之面向对象概念

对象,其实就是该类事物实实在在存在的个体. 类与对象之间的关系?类:一类事物的描述.对象:该类事物的实例.在java中通过new来创建的.举例来说,类就是汽车说明书,类只能在理论上造一辆汽车,并且这个说明书非常明确的写了汽车有哪些部件.可以干什么等等信息,我们可以通过这个说明书(类)得知这辆车全方位的信息:对象就是按照这个说明书造出来的一辆汽车实体,是真实存在的,可以开走的. 下面我们用类描述一辆小汽车: 分析:1,属性轮胎数.颜色.2,行为运行. 定义类其实就是在定义类中的成员成员:成员变量就

Java学习个人备忘录之接口

abstract class AbsDemo { abstract void show1(); abstract void show2(); } 当一个抽象类中的方法都是抽象的时候,这时可以将该抽象类用另一种形式定义和表示-----接口  interface 定义接口使用的关键字不是class,是interface. 对于接口当中常见的成员:而且这些成员都有固定的修饰符1. 全局常量:public static final2. 抽象方法:public abstract 由此得出结论,接口中的成员

Java学习个人备忘录之数组

数组 概念:同一种类型数据的集合,其实数组就是一个容器. 数组的好处:可以自动给数组中的元素从0开始编号,方便操作这些元素. 格式1:元素类型[] 数组名 = new 元素类型[元素个数]; 格式2:元素类型[] 数组名 = new 元素类型[]{元素1,元素2,元素3,....,元素N}; 内存的划分:1:寄存器2:本地方法区3:方法区4:栈内存 存储的都是局部变量 而且变量所属的作用域一旦结束,该变量就自动释放5: 堆内存存储的是数组和对象(其实数组就是对象) 凡是new 建立的都在堆中.特

Java学习个人备忘录之继承

继承的好处1. 提高了代码的复用性.2. 让类与类之间产生了关系,给第三个特征多态提供了前提. java中支持单继承,不直接支持多继承,但对C++中的多继承机制进行改良.java支持多层继承. C继承B,B继承A,就会出现继承体系. 当要使用一个继承体系时:1. 查看该体系中的顶层类,了解该体系的基本功能.2. 创建体系中的最子类对象,完成共能的使用. 什么时候定义继承呢?当类与类之间存在着所属关系的时候,就定义继承,xxx是yyy中的一种,  xxx extends yyy. class Pe

Java学习个人备忘录之内部类

内部类: 将一个类定义在另一个类的里面,对里面那个类就称为内部类. class Outer { private int num = 3; class Inner //它想访问Outer中的num, 如果在外面就需要创建一个对象,然后通过公开的接口访问,但是现在Outer内部, 就可以直接访问了.这样方便 { void show() { System.out.println("show run..." + num); } } //如果现在想访问Inner就需要这样 public void

Java学习个人备忘录之关键字final

final关键字final可以修饰类,方法,变量.final修饰的类不可以被继承final修饰的方法不可以被覆盖final修饰的变量是一个常量.只能被赋值一次.内部类只能访问被final修饰的局部变量. class Fu { void method() { //调用了底层系统的资源 } } class Zi extends Fu { void method() { System.out.println("haha"); } } 从上面可以看出继承是有弊端的,就是打破了封装性.这时我们就

java学习笔记16--异常

java学习笔记16--异常 异常 异常时导致程序中断运行的一种指令流,如果不对异常进行正确的处理,则可能导致程序的中断执行,造成不必要的损失, 所以在程序的设计中必须要考虑各种异常的发生,并正确的做好相应的处理,这样才能保证程序正常的执行. 异常类的继承结构 在整个java的异常结构中,实际上有以下两个最常用的类:Exception.Error,这两个类全都是Throwable的子类 Exception:一般表示的是程序中出现的问题,可以直接使用try...catch处理. Error:一般指

java学习中，异常和错误的简介、捕获异常、抛出异常、自定义异常（java 学习中的小记录）

java学习中,异常和错误的简介.捕获异常.抛出异常.自定义异常(java 学习中的小记录)作者:王可利(Star·星星) 异常:(API 的 java.lang 有一个异常,有很多很多) 在Java程序中也会程序出现不正常的情况,这个就叫异常.     Java是面向对象的语言,任何事物都可以用类来描述,同样的异常也是一种事物.Java中提供了很多的异常类.     多个异常堆积起来,就是一个异常体系.   Throwable:是异常类的父类,超类.Exception 异常.error错误.

Java基础知识二次学习--第四章 异常

第四章 异常处理 时间:2017年4月26日11:16:39~2017年4月26日11:28:58 章节:04章_01节 04章_02节 视频长度:20:46+01:16 内容:异常的概念 心得: Java异常是JAVA提供的用于处理程序中错误的一种机制 实在运行的过程中发生的一些异常事件(比如除0溢出,数组越界,要读取的文件不存在) 设计良好的程序应该在异常发生时提供处理这些错误的方法,使得程序不会因为异常的发生而阻断或产生不可预见的结果 JAVA程序的执行过程中 如果出现异常事件,可以生成异