面向对象(继承+抛出异常）-第20天

最新推荐文章于 2020-08-04 08:57:12 发布

王竹根

最新推荐文章于 2020-08-04 08:57:12 发布

阅读量632

点赞数 1

分类专栏： java学习笔记

本文链接：https://blog.csdn.net/dianziagen/article/details/48458819

版权

java学习笔记专栏收录该内容

22 篇文章 0 订阅

订阅专栏

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

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

   2. 其实异常就是java通过面向对象的思想将问题封装成了对象，用异常类对其进行描述。

   3. 不同的问题用不同的类进行具体的描述。比如角标越界、空指针异常等等。

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

不正常情况分成了两大类：

Throwable：无论是error，还是异常、问题，问题发生就应该可以抛出，让调用者知道并处理。

该体系的特点就在于Throwable及其所有的子类都具有可抛性。

可抛性到底指的是什么呢？怎么体现可抛性呢？

其实是通过两个关键字来体现的：throws throw，凡是可以被这两个关键字所操作的类和对象都具备可抛性。

1. 一般不可处理的：Error

       特点：是由jvm虚拟机抛出的严重性问题。

      这种问题发生，一般不针对性处理，直接修改程序。

2. 可以处理的：Exception

该体系的特点：

子类的后缀名都是用其父类名作为后缀，阅读性很强。

Throwable中的方法：

   1. getMessage()：获取异常信息，返回字符串。

   2. toString()：获取异常类名和异常信息，返回字符串。

   3. printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。

   4. printStackTrace(PrintStream s)：通常用该方法将异常内容保存在日志文件中，以便查阅。

示例：

public class PackageOne {
    public static void main(String[] args) {
        int[] arr = new int[3];
        DemoC.method(arr, 30);//格式简单：（Demo）父类类名.方法/子类类名（ ）；
    }
}

class DemoC {
    public static int method(int[] arr, int index) {
        if (arr == null) {
            //空指针异常null pointer exception
            throw new NullPointerException("数组的引用不能为空！");
        }
        if (index >= arr.length) {
            //array数组 index索引，标志，指示(这里代表的是数组的角标)out of bounds出界了。
            throw new ArrayIndexOutOfBoundsException("数组的角标越界：" + index);
        }
        return arr[index];
    }
}

4.10.2 自定义异常

    可以自定义出的问题称为自定义异常。

    对于角标为负数的情况，可以用负数角标异常来表示，负数角标这种异常在java中并没有定义过。

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

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

P.S.

如果让一个类成为异常类，必须要继承异常体系，（？？？异常体系相当于父类，即爸爸。）因为只有成为异常体系的子类才有资格具备可抛性，才可以被两个关键字所操作：throws、throw。

自定义类继承Exception或者其子类，通过构造函数定义异常信息。

示例：

Class DemoException extends Exception//继承了异常体系的基本特性

{

     DemoException(String message)//自定义的构造函数

    {

         super(message);

//super指向了父类的带有参数构造函数。为什么必需要说明super(),??因为这是子类调用父类。初始化过程要先做。

    }

}

通过throw将自定义异常抛出。

throws和throw的区别：

1. throws用于标识函数暴露出的异常类，并且可以抛出多个，用逗号分隔。throw用于抛出异常对象。（throws是复数形式，即可以抛下多个。Throw抛出的是对象，故用new）

2. thorws用在函数上，后面跟异常类名。throw用在函数内，后面跟异常对象。

定义功能方法时，需要把出现的问题暴露出来让调用者去处理，那么就通过throws在函数上标识。

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

示例：

public class PackageOne {
    public static void main(String[] args) throws FuShuIndexException {
        int[] arr = new int[3];
        DemoD.method(arr, -30);
    }
}

class FuShuIndexException extends Exception {

    FuShuIndexException() {
    }//自定义空参数的构造函数

    FuShuIndexException(String msg) {//有参数的构造函数
        super(msg);//调用父类exception的异常体系
    }
}

class DemoD {
    public static int method(int[] arr, int index) throws FuShuIndexException {
        if (index < 0) {//在功能方法内部，用throw
            //throw后面跟的是对象new FuShuIndexException(相当于new Person)
            //方法内部出现了负数角标，要运行程序，用throw抛出>>>
            throw new FuShuIndexException("数组的角标是负数啦！");
            //红色的内容代表打印的内容。类似与System.out.println(“  ”);
        }
        return arr[index];
    }
}

运行结果：

Exception in thread "main" FuShuIndexException: 数组的角标是负数啦！

异常的分类：

1. 编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系。

这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。

这样的问题都可以针对性的处理。

2. 编译时不检测异常（运行时异常）：就是Exception中的RuntimeException和其子类。

这种问题的发生，无法让功能继续，运算无法运行，更多是因为调用的原因导致的或者引发了内部状态的改变导致的。

那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行调整。

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

示例：

public class PackageOne {
    public static void main(String[] args) throws FuShuIndexException {
        int[] arr = new int[3];
        DemoD.method(arr, -30);
    }
}

class FuShuIndexException extends RuntimeException {

    FuShuIndexException() {
    }//自定义空参数的构造函数

    FuShuIndexException(String msg) {//有参数的构造函数
        super(msg);//调用父类exception的异常体系
    }
}

class DemoD {
    //RuntimeException没有必要用throws抛出，并不是必须要处理
    public static int method(int[] arr, int index) {
        if (index < 0) {//在功能方法内部，用throw
            //方法内部出现了负数角标，要运行程序，用throw抛出>>>
            throw new FuShuIndexException("数组的角标是负数啦！");
        }
        return arr[index];
    }
}

运行结果：

P.S.

RuntimeException是那些可能在Java虚拟机正常运行期间抛出的异常的超类。

可能在执行方法期间抛出但未被捕获的RuntimeException的任何子类都无需在throws子句中进行声明。

异常处理的捕捉形式：

可以对异常进行针对性处理的方式。

具体格式是：

  try{
        //需要被检测异常的代码。
    }

   catch(异常类 变量) //该变量用于接收发生的异常对象

    {
        //处理异常的代码。
    }

   finally{
        //一定会执行的代码；
    }

P.S.

finally代码块只有一种情况不会被执行，就是在之前执行了System.exit(0)。

处理过程：

try中检测到异常会将异常对象传递给catch，catch捕获到异常进行处理。

finally里通常用来关闭资源。比如：数据库资源，IO资源等。

需要注意：try是一个独立的代码块，在其中定义的变量只在该变量块中有效。

如果在try以外继续使用，需要在try外建立引用，在try中对其进行初始化。IO，Socket就会遇到。

示例：

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

        //当try语句中出现异常是时，不执行try的内容，而执行catch中的语句
        try {
            int num = DemoD.method(arr, -30);
            System.out.println("num:" + num);//不执行，打印角标的数字
        } catch (NullPointerException e) {
            e.printStackTrace();
        } catch (FuShuIndexException e) {
            System.out.println("message:" + e.getMessage());//这里指的是获取异常信息
            System.out.println("string:" + e);打印异常信息e
            e.printStackTrace();//命令行打印异常信息在程序中出错的位置及原因
            System.out.println("负数角标异常！！！");
        } catch (Exception e) {//处理异常体系的基本异常问题
            System.out.println(e);
        }

        System.out.println("over");
    }
}

class FuShuIndexException extends RuntimeException {
    //运行时异常类
    FuShuIndexException() {
    }//自定义空参数的构造函数

    FuShuIndexException(String msg) {//有参数的构造函数
        super(msg);//调用父类exception的异常体系
    }
}

class DemoD {
    public static int method(int[] arr, int index) throws NullPointerException, FuShuIndexException {
        if (arr == null) {
            //空指针异常null pointer exception
            throw new NullPointerException("数组的引用不能为空！");
        }
        if (index < 0) {//在功能方法内部，用throw
            //方法内部出现了负数角标，要运行程序，用throw抛出>>>
            throw new FuShuIndexException("数组的角标是负数啦！");
        }
        return arr[index];
    }
}

运行结果：

message:数组的角标是负数啦！
string:FuShuIndexException: 数组的角标是负数啦！
FuShuIndexException: 数组的角标是负数啦！
at DemoD.method(PackageOne.java:42)
at PackageOne.main(PackageOne.java:7)
负数角标异常！！！
over

异常处理的原则：

1. 函数内容如果抛出需要检测的异常，那么函数上必须要声明。

否则，必须在函数内用try/catch捕捉，否则编译失败。

2. 如果调用到了声明异常的函数，要么try/catch，要么throws，否则编译失败。

3. 什么时候catch，什么时候throws呢？

功能内容可以解决，用catch。

解决不了，用throws告诉调用者，由调用者解决。

4. 一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性处理。

内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

示例：

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

        //当try语句中出现异常是时，不执行try的内容，而执行catch中的语句
        try {
            int num = DemoE.show(-30);
            System.out.println("num:" + num);//不执行，打印角标的数字
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println(e);
            //退出jvm虚拟机。有System.exit(0);存在时，不会执行finally语句。
//            System.exit(0);
        } catch (Exception e) {//处理异常体系的基本异常问题
            System.out.println(e);
        } finally {
            System.out.println("finally");
        }

        System.out.println("over");
    }
}

class DemoE {
    public static int show(int index) throws ArrayIndexOutOfBoundsException//数组角标越界异常。这个问题解决不了，就用throws来告诉调用者。
    {
        if (index < 0) throw new ArrayIndexOutOfBoundsException("越界啦！");
        int[] arr = new int[3];//定义数组
        return arr[index];//返回数组角标index的值
    }
}

运行结果：

java.lang.ArrayIndexOutOfBoundsException: 越界啦！
finally
over

try catch finally 代码块组合特点：

1. try catch finally

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

3. try finally：异常无法直接catch处理，但是资源必须关闭。

示例：

void show() throws Exception{

    try{

         //开启资源

         throw new Exception();

     }finally{

         //关闭资源

     }

}

异常综合案例：

问题领域中涉及两个对象。

毕老师，电脑。比如电脑蓝屏，冒烟等。

public class PackageOne {
    public static void main(String[] args) {
        Teacher t = new Teacher("毕老师", 1);
        try {
            t.prelect();
        } catch (NoPlanException e) {
            System.out.println(e.toString() + ".......");
        }
        System.out.println(">>>");

        Teacher t2 = new Teacher("毕老师", 2);
        try {
            t2.prelect();
        } catch (NoPlanException e) {
            System.out.println(e.toString() + ".......");
        }
    }
}

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

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

class NoPlanException extends Exception {//没有计划的异常

    NoPlanException(String msg) {
        super(msg);
    }
}

class Computer {//可以抛出蓝屏，冒烟。设置重启。

    private int state = 1;//0 2

    Computer(int state) {
        this.state = state;
    }

    public void run() throws LanPingException, MaoYanException {
        if (state == 1) throw new LanPingException("电脑蓝屏啦！");
        if (state == 2) throw new MaoYanException("电脑冒烟啦！");
        System.out.println("电脑运行");

    }

    public void reset() {
        state = 0;
        System.out.println("电脑重启");
    }
}

class Teacher {//老师

    private String name;

    private Computer comp;//此时comp不知道是那个类型，故用Computer代替。

    Teacher(String name, int state) {

        this.name = name;
        comp = new Computer(state);
    }

    public void prelect() throws NoPlanException {//说明没计划的异常

        try {
            comp.run();//检测异常
            System.out.println(name + "讲课");
        } catch (LanPingException e) {
            System.out.println(e.toString());

            comp.reset();//清零，重启，

            prelect();//再次执行，并继续检测是否有抛出

        } catch (MaoYanException e) {//冒烟
            System.out.println(e.toString());
            test();
            //可以对电脑进行维修
            throw new NoPlanException("课时进度无法完成，原因：" + e.getMessage());
        }
    }

    public void test() {
        System.out.println("大家练习");
    }

}

运行结果：

LanPingException: 电脑蓝屏啦！
电脑重启
电脑运行
毕老师讲课
>>>
MaoYanException: 电脑冒烟啦！
大家练习
NoPlanException: 课时进度无法完成，原因：电脑冒烟啦！.......

异常的注意事项：

   1. RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。

   2. 子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。

   3. 如果父类抛出多个异常，那么子类只能抛出父类异常的子集。

简单说：子类覆盖父类只能抛出父类的异常或者子类的子集。

P.S.

如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。

Object类

Object：所有类的根类。Object是不断抽取而来，具备着所有对象都具备的共性内容。

示例：

public class PackageOne {
    public static void main(String[] args) {
        PersonTwo p1 = new PersonTwo(20);
        PersonTwo p2 = new PersonTwo(20);
        PersonTwo p3 = p1;

        //equals默认比较的是地址值，而不是数据。
        System.out.println(p1 == p2);//false
        System.out.println(p1.equals(p2));//false
        System.out.println(p1.equals(p3));//true
    }
}

class PersonTwo {
    private int age;

    PersonTwo(int age) {
        this.age = age;
    }
}

P.S.

== Object类的equals方法默认都是根据对象的哈希值判断两个对象是否相等。

可以通过覆盖Object的equals方法来重写比较规则。

示例：

public class PackageOne {
    public static void main(String[] args) {
        PersonTwo p1 = new PersonTwo(20);
        PersonTwo p2 = new PersonTwo(20);
        PersonTwo p3 = p1;

        //equals比较的是地址值，而不是数据。
        System.out.println(p1 == p2);//false
        System.out.println(p1.equals(p2));//true
        System.out.println(p1.equals(p3));//true
    }
}

class PersonTwo {
    private int age;

    PersonTwo(int age) {
        this.age = age;
    }

    @Override
    public boolean equals(Object obj) {
        //判断实例，obj原来是PersonTwo吗
        if (!(obj instanceof PersonTwo)) {
            throw new ClassCastException("类型错误");
        }
        PersonTwo p = (PersonTwo) obj;//强制变成person
        return this.age == p.age;//调用的this的属性age=接受的this。
    }
}

Object类的toString方法默认返回的内容是“对象所属的类名+@+对象的哈希值（十六进制）”。

示例：

public class PackageOne {
    public static void main(String[] args) {
        PersonTwo p1 = new PersonTwo(8);

        System.out.println(p1);//PersonTwo@8
        System.out.println(p1.toString());//PersonTwo@8
        System.out.println(p1.getClass().getName()+"$"+Integer.toHexString(p1.hashCode()));
        //PersonTwo$8
    }
}

class PersonTwo {
    private int age;

    PersonTwo(int age) {
        this.age = age;
    }

    //重写了哈希值
    @Override
    public int hashCode() {
        return age;
    }
}

王竹根

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象(继承+抛出异常）-第20天

在java中用类的形式对不正常情况进行了描述和封装对象。描述不正常的情况的类，就称为异常类。1. 以前正常流程代码和问题处理代码相结合，现在将正常流程代码和问题处理代码分离，提高阅读性。2. 其实异常就是java通过面向对象的思想将问题封装成了对象，用异常类对其进行描述。3. 不同的问题用不同的类进行具体的描述。比如角标越界、空指针异常等等。4....
复制链接

扫一扫