Java知识点05——泛型、异常处理

微醺CC

已于 2022-09-15 11:54:55 修改

阅读量554

点赞数 2

分类专栏：后端文章标签： java 开发语言后端

于 2022-02-24 21:03:19 首次发布

本文链接：https://blog.csdn.net/qq_43680543/article/details/123041761

版权

后端专栏收录该内容

15 篇文章 0 订阅

订阅专栏

Java知识点05——泛型、异常处理

一、泛型（Generic）
二、异常处理

声明：

该资料来自自己整理。
参考书籍 疯狂 Java讲义（第五版）李刚©著

一、泛型（Generic）

1.1 泛型概述

泛型：可以在类或方法中预知地使用未知的类型。

泛型机制将类型转换时的类型检查从运行时提前到了编译时，在强制类型转换的机制具有更好的可读性和安全性。

tips:一般在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

1.2 泛型的定义与使用

1.2.1 定义

定义格式：

修饰符 class 类名<代表泛型的变量> {  }

例如，API中的ArrayList集合：

class ArrayList<E>{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型：即什么时候确定泛型。

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

再例如，ArrayList<Integer> list = new ArrayList<Integer>();

此时，变量E的值就是Integer类型,那么我们的类型就可以理解为：

class ArrayList<Integer> { 
     public boolean add(Integer e) { }

     public Integer get(int index) {  }
     ...
}

举例自定义泛型类

public class MyGenericClass<MVP> {
	//没有MVP类型，在这里代表 未知的一种数据类型 未来传递什么就是什么类型
	private MVP mvp;
     
    public void setMVP(MVP mvp) {
        this.mvp = mvp;
    }
     
    public MVP getMVP() {
        return mvp;
    }
}

使用:

public class GenericClassDemo {
  	public static void main(String[] args) {		 
         // 创建一个泛型为String的类
         MyGenericClass<String> my = new MyGenericClass<String>();    	
         // 调用setMVP
         my.setMVP("大胡子登登");
         // 调用getMVP
         String mvp = my.getMVP();
         System.out.println(mvp);
         //创建一个泛型为Integer的类
         MyGenericClass<Integer> my2 = new MyGenericClass<Integer>(); 
         my2.setMVP(123);   	  
         Integer mvp2 = my2.getMVP();
    }
}

1.2.2 含泛型的类

定义格式：修饰符 class 类名< 代表泛型的变量 > { }

例如，API中的ArrayList集合：

class ArrayList< E >{ 
    public boolean add(E e){ }

    public E get(int index){ }
   	....
}

使用泛型：即什么时候确定泛型。

在创建对象的时候确定泛型

例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为：

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

1.2.3 含泛型的接口

定义格式：修饰符 interface 接口名<代表泛型的变量> { }

public interface MyGenericInterface<E>{
	public abstract void add(E e);
	
	public abstract E getE();  
}

使用格式：

1、定义类时确定泛型的类型

public class MyImp1 implements MyGenericInterface<String> {
	@Override
    public void add(String e) {
        // 省略...
    }

	@Override
	public String getE() {
		return null;
	}
}

此时，泛型E的值就是String类型。

2、始终不确定泛型的类型，直到创建对象时，确定泛型的类型

public class MyImp2<E> implements MyGenericInterface<E> {
	@Override
	public void add(E e) {
       	 // 省略...
	}

	@Override
	public E getE() {
		return null;
	}
}

确定泛型：

public class GenericInterface {
    public static void main(String[] args) {
        MyImp2<String>  my = new MyImp2<String>();  
        my.add("aa");
    }
}

1.2.4 含泛型的方法

定义格式：修饰符 < 代表泛型的变量 > 返回值类型方法名(参数){ }

例如

public class MyGenericMethod {	  
    public <MVP> void show(MVP mvp) {
    	System.out.println(mvp.getClass());
    }
    
    public <MVP> MVP show2(MVP mvp) {	
    	return mvp;
    }
}

使用格式：调用方法时，确定泛型的类型

public class GenericMethodDemo {
    public static void main(String[] args) {
        // 创建对象
        MyGenericMethod mm = new MyGenericMethod();
        // 演示看方法提示
        mm.show("aaa");
        mm.show(123);
        mm.show(12.45);
    }
}

1.3 泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

1.3.1 通配符基本使用

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符。

此时只能接受数据,不能往该集合中存储数据。

举个例子大家理解使用即可：

public static void main(String[] args) {
    Collection<Intger> list1 = new ArrayList<Integer>();
    getElement(list1);
    Collection<String> list2 = new ArrayList<String>();
    getElement(list2);
}

public static void getElement(Collection<?> coll){}
//？代表可以接收任意类型

tips:泛型不存在继承关系 Collection list = new ArrayList();这种是错误的。

1.3.2 通配符高级使用----受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限：

格式： 类型名称 <? extends 类 > 对象名称
意义： 只能接收该类型及其子类

泛型的下限：

格式： 类型名称 <? super 类 > 对象名称
意义： 只能接收该类型及其父类型

比如：现已知Object类，String 类，Number类，Integer类，其中Number是Integer的父类

public static void main(String[] args) {
    Collection<Integer> list1 = new ArrayList<Integer>();
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
    
    getElement1(list1);
    getElement1(list2);//报错
    getElement1(list3);
    getElement1(list4);//报错
  
    getElement2(list1);//报错
    getElement2(list2);//报错
    getElement2(list3);
    getElement2(list4);
  
}

// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement1(Collection<? extends Number> coll){}

// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection<? super Number> coll){}

1.4 使用泛型的好处

将运行时期的ClassCastException，转移到了编译时期变成了编译失败。
避免了类型强转的麻烦。

通过我们如下代码体验一下：

public class GenericDemo2 {
	public static void main(String[] args) {
        Collection<String> list = new ArrayList<String>();
        list.add("abc");
        list.add("hjm");
        // list.add(5);//当集合明确类型后，存放类型不一致就会编译报错
        // 集合已经明确具体存放的元素类型，那么在使用迭代器的时候，迭代器也同样会知道具体遍历元素类型
        Iterator<String> it = list.iterator();
        while(it.hasNext()){
            String str = it.next();
            //当使用Iterator<String>控制元素类型后，就不需要强转了。获取到的元素直接就是String类型
            System.out.println(str.length());
        }
	}
}

tips:泛型是数据类型的一部分，我们将类名与泛型合并一起看做数据类型。

二、异常处理

2.1 异常

2.1.1 异常概念

Java提出了一种假设：如果程序可以顺利完成，那就“一切正常”，把系统的业务实现代码放在try块中定义，所有的异常处理逻辑放在catch块中进行处理。

异常：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。

在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。

异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行.

2.1.2 异常体系

异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lang.Exception，平常所说的异常指java.lang.Exception。

Throwable体系：

Error：Error错误，一般是指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败等，这种错误无法恢复和捕获，将导致应用程序中断。无法通过处理的错误，只能事先避免。
Exception：表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。

Throwable中的常用方法：

public void printStackTrace():打印异常的详细信息。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。
public String getMessage():获取发生异常的原因。

提示给用户的时候,就提示错误原因。
public String toString():获取异常的类型和异常描述信息(不用)。

【异常案例】

2.2 异常分类

我们平常说的异常就是指Exception，因为这类异常一旦出现，我们就要对代码进行更正，修复程序。

异常(Exception)的分类:根据在编译时期还是运行时期去检查异常?

编译时期异常：checked异常。在编译时期,就会检查,如果没有处理异常,则编译失败。(如日期格式化异常)
运行时期异常：runtime异常。在运行时期,检查异常.在编译时期,运行异常不会编译器检测(不报错)。(如数学异常)

2.2.1 异常的产生过程解析

先运行下面的程序，程序会产生一个数组索引越界异常ArrayIndexOfBoundsException。我们通过图解来解析下异常产生的过程。

工具类

public class ArrayTools {
    // 对给定的数组通过给定的角标获取元素。
    public static int getElement(int[] arr, int index) {
        int element = arr[index];
        return element;
    }
}

测试类

public class ExceptionDemo {
    public static void main(String[] args) {
        int[] arr = { 34, 12, 67 };
        intnum = ArrayTools.getElement(arr, 4)
        System.out.println("num=" + num);
        System.out.println("over");
    }
}

上述程序执行过程图解：

2.3 异常的处理

Java异常处理的五个关键字：try、catch、finally、throw、throws

2.3.1 抛出异常 throw

如果执行try块里的业务逻辑代码块时出现异常，系统自动生成一个异常对象，该异常对象被提交给Java运行时环境，这个过程被称为抛出（throw）异常。

在编写程序时，我们必须要考虑程序出现问题的情况。比如，在定义方法时，方法需要接受参数。那么，当调用方法使用接受到的参数时，首先需要先对参数数据进行合法的判断，数据若不合法，就应该告诉调用者，传递合法的数据进来。这时需要使用抛出异常的方式来告诉调用者。

在java中，提供了一个throw关键字，它用来抛出一个指定的异常对象。那么，抛出一个异常具体如何操作呢？

创建一个异常对象。封装一些提示信息(信息可以自己编写)。
需要将这个异常对象告知给调用者。怎么告知呢？怎么将这个异常对象传递到调用者处呢？通过关键字throw就可以完成。throw 异常对象。

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。

使用格式：throw new 异常类名(参数);

例如：

throw new NullPointerException("要访问的arr数组不存在");

throw new ArrayIndexOutOfBoundsException("该索引在数组中不存在，已超出范围");

学习完抛出异常的格式后，我们通过下面程序演示下throw的使用。

public class ThrowExceptionTest {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4};
        int index = 4;
        int element = getElement(arr,index);
    }
    private static int getElement(int[] arr, int index) {
        //判断 索引是否越界
        if(index<0 || index>=arr.length){
            /*
             判断条件如果满足，当执行完throw抛出异常对象后，方法已经无法继续运算。
             这时就会结束当前方法的执行，并将异常告知给调用者。这时就需要通过异常来解决。
              */
            throw new ArrayIndexOutOfBoundsException("数组越界异常。。。");
        }
        return arr[index];
    }
}

注意：如果产生了问题，我们就会throw将问题描述类即异常进行抛出，也就是将问题返回给该方法的调用者。那么对于调用者来说，该怎么处理呢？一种是进行捕获处理，另一种就是继续讲问题声明出去，使用throws声明处理。

2.3.2 Objects非空判断

类Objects 在它的源码中，对对象为 null 的值进行了抛出异常操作。

public static <T> T requireNonNull(T obj)：查看指定引用对象不是null。

查看源码发现这里对为null的进行了抛出异常操作：

public static <T> T requireNonNull(T obj) {
    if (obj == null)
      	throw new NullPointerException();
    return obj;
}

import java.util.Objects;
public class ObjectsNullTest {
    public static void main(String[] args) {
        method(null);
    }
    public static void method(Object obj){
        //对传递过来的参数进行合法性校验
        //Objects.requireNonNull(obj);//NullPointerException
        //NullPointerException: 传递过来的对象为null
        Objects.requireNonNull(obj,"传递过来的对象为null");
    }
}

2.3.3 声明异常 throws（方法一）

声明异常：将问题标识出来，报告给调用者。如果方法内通过throw抛出了编译时异常，而没有捕获处理（稍后讲解该方式），那么必须通过throws进行声明，让调用者去处理。

关键字throws运用于方法声明之上,用于表示当前方法不处理异常,而是提醒该方法的调用者来处理异常(抛出异常).

声明异常格式：修饰符返回值类型方法名(参数) throws 异常类名1,异常类名2…{ }

【声明异常的代码演示】：

import java.io.FileNotFoundException;
import java.io.IOException;
/**
 * 注意：1.throws关键字必须写在方法声明处
 *      2.throws关键字后面声明的异常必须是Exception或者是Exception的子类
 *      3.方法内部如果抛出了多个异常对象，那么throws后边必须也声明多个异常，
 *          如果抛出的多个异常对象有父子关系，那么直接声明父类异常即可。
 *      4.调用了一个声明抛出异常的方法，我们就必须得处理声明的异常，要么继续使用throws声明抛出，
 *          交给方法的调用者处理，最终交给JVM；要么try...catch自己处理异常
 */
public class ThrowsException {

    //作为redFile方法的调用者main方法也必须对redFile方法抛出的异常进行处理
    public static void main(String[] args) throws IOException {
        redFile("d:\\a.doc");
        System.out.println("如果redFile方法抛出异常，则该行语句不会执行！！");
    }
    
    //FileNotFoundException extends IOException extends Exception
    //public static void redFile(String fileName) throws FileNotFoundException, IOException
    //所以这里使用声明一个父类异常对象即可即IOException
    public static void redFile(String fileName) throws IOException {
        if (!fileName.equals("c:\\a.txt")){
            throw new FileNotFoundException("文件路径不是规定的路径！");
        }
        if (fileName.endsWith(".txt")) {
            throw new IOException("文件后缀名不正确");
        }
        System.out.println("路径正确读取文件");
    }
}

注意：如果上述代码中main方法中的redFile()方法出现异常，则其后面的代码不会执行！！！！

throws用于进行异常类的声明，若该方法可能有多种异常情况产生，那么在throws后面可以写多个异常类，用逗号隔开。

public class ThrowsDemo2 {
    public static void main(String[] args) throws IOException {
        read("a.txt");
    }

    public static void read(String path)throws FileNotFoundException, IOException {
        if (!path.equals("a.txt")) {//如果不是 a.txt这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            throw new FileNotFoundException("文件不存在");
        }
        if (!path.equals("b.txt")) {
            throw new IOException();
        }
    }
}

2.3.4 捕获异常 try…catch（方法二）

Java提出了一种假设：如果程序可以顺利完成，那就“一切正常”，把系统的业务实现代码放在try块中定义，所有的异常处理逻辑放在catch块中进行处理。

如果异常出现的话,会立刻终止程序,所以我们得处理异常:

该方法不处理,而是声明抛出,由该方法的调用者来处理(throws)。
在方法中使用try-catch的语句块来处理异常。

try-catch的方式就是捕获异常。

捕获异常：Java中对异常有针对性的语句进行捕获，可以对出现的异常进行指定方式的处理。

捕获异常语法如下：

try{
     编写可能会出现异常的代码
}catch(异常类型  e){
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

try： 该代码块中编写可能产生异常的代码。

catch： 用来进行某种异常的捕获，实现对捕获到的异常进行处理。

注意:try和catch都不能单独使用,必须连用。

捕获异常时，一定要注意先捕获小异常，再捕获大异常。

演示如下：

import java.io.IOException;
/**
 *注意：1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
 *      2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try...catch之后的代码【try中没有执行完的代码就不会执行】
 *        如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try...catch之后的代码
 */
public class TryCatchTest {
    public static void main(String[] args) {
        try{
            //将可能抛出异常的语句放在try块中
            redFile("d:\\hello.tx");
        }catch (IOException e){
            System.out.println("catch 中的处理逻辑代码");
        }
        System.out.println("try...catch 后面的代码可以继续执行");
    }
    
    private static void redFile(String fileName) throws IOException {
        if (!fileName.endsWith(".txt")){
            throw new IOException("文件后缀名不是.txt");
        }
        System.out.println("开始读取文件");
    }
}

2.4 访问异常信息

如何获取异常信息：

Throwable类中定义了一些查看方法:

public String getMessage():返回此throwable的简短描述；获取异常的描述信息,原因(提示给用户的时候,就提示错误原因。
public String toString():返回此throwable的详细消息字符串；获取异常的类型和异常描述信息(不用)。
public void printStackTrace():JVM打印异常对象（默认此方法），打印的异常信息最全面；打印异常的跟踪栈信息并输出到控制台。

包含了异常的类型,异常的原因,还包括异常出现的位置,在开发和调试阶段,都得使用printStackTrace。

import java.io.IOException;
/**
 *注意：1.try中可能会抛出多个异常对象，那么就可以使用多个catch来处理这些异常对象
 *      2.如果try中产生了异常，那么就会执行catch中的异常处理逻辑，执行完毕catch中的处理逻辑，继续执行try...catch之后的代码【try中没有执行完的代码就不会执行】
 *        如果try中没有产生异常，那么就不会执行catch中异常的处理逻辑，执行完try中的代码，继续执行try...catch之后的代码
 */
public class TryCatchTest {
    public static void main(String[] args) {
        try{
            //将可能抛出异常的语句放在try块中
            redFile("d:\\hello.tx");
        }catch (IOException e){
            System.out.println("catch 中的处理逻辑代码");
            System.out.println("e:"+e);
            System.out.println("String getMessage():"+e.getMessage());
            System.out.println("String toString():"+e.toString());
            e.printStackTrace();
        }
        System.out.println("try...catch 后面的代码可以继续执行");
    }
    
    private static void redFile(String fileName) throws IOException {
        if (!fileName.endsWith(".txt")){
            throw new IOException("文件后缀名不是.txt");
        }
        System.out.println("开始读取文件");
    }
}

2.5 finally 代码块

finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

什么时候的代码必须最终执行？

当我们在try语句块中打开了一些物理资源(磁盘文件/网络连接/数据库连接等),我们都得在使用完之后,最终关闭打开的资源。

finally的语法: try...catch....finally：自身需要处理异常,最终还得关闭资源。

注意:finally不能单独使用。

比如在我们之后学习的IO流中，当打开了一个关联文件的资源，最后程序不管结果如何，都需要把这个资源关闭掉。

finally代码参考如下【案例】：

public class TryCatchDemo4 {
    public static void main(String[] args) {
        try {
            //可能产生异常的代码
            read("a.txt");
        } catch (FileNotFoundException e) {
            //异常的处理逻辑
            throw new RuntimeException(e);
        } finally {
            //无论是否出现异常，都会执行
            System.out.println("不管程序怎样，这里都将会被执行。");
            System.out.println("一般用于资源释放！！");
        }
        System.out.println("over");
    }
    
    //产生异常的red()方法
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("a.txt")) {
            throw new FileNotFoundException("文件不存在");
        }
    }
}

当只有在try或者catch中调用退出JVM的相关方法,此时finally才不会执行,否则finally永远会执行。

2.6 异常注意事项

2.6.1 多异常捕获

public class MultiExceptionTest {
    public static void main(String[] args) {
        try {
            int a = Integer.parseInt(args[0]);
            int b = Integer.parseInt(args[1]);
            int c = a / b;
            System.out.println("您输入的两个数相除的结果是："+c);
        }catch (IndexOutOfBoundsException | NumberFormatException | ArithmeticException ie){
            System.out.println("程序发生了数组越界异常、数字格式异常、算数异常之一");
            //捕获多异常时，异常变量默认有final修饰，重新赋值会报错
            //ie = new ArithmeticException("test");
        }catch (Exception e){
            System.out.println("未知异常");
            //捕获一种异常时，异常变量没有final修饰
            e = new RuntimeException("test");
        }
    }
}

多个异常使用捕获又该如何处理呢？

多个异常分别处理。
多个异常一次捕获，多次处理。
多个异常一次捕获一次处理。

一般我们是使用一次捕获多次处理方式，格式如下：

try{
     编写可能会出现异常的代码
}catch(异常类型A  e){  当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}catch(异常类型B  e){  当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
}

注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。

public class TryCatchTest02 {
    public static void main(String[] args) {
    
        //1.多个异常分别处理
        System.out.println("//1.多个异常分别处理");
        try{
            int[] arr = {1,2,3};
            System.out.println(arr[3]);
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }
        try{
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }
        
        //2.多个异常一次捕获，多次处理
        /**
         * ArrayIndexOutOfBoundsException extends IndexOutOfBoundsException
         * 注意：1.catch里面定义的异常变量，如果有子父类关系，那么子类异常变量必须写在上边，否则会报错
         */
        try{
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println(e);
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }
        
        //3.多个异常一次捕获一次处理 即抛出的异常是所有出现异常的 公共父类！！
        try{
            List<Integer> list = new ArrayList<>();
            list.add(1);
            list.add(2);
            list.add(3);
            System.out.println(list.get(3));
        }catch (IndexOutOfBoundsException e){
            System.out.println(e);
        }
        System.out.println("后续代码...");
    }
}

运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果finally有return语句,永远返回finally中的结果,避免该情况.
如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出
通常情况下，不要再 finally块 中使用如 return 或 throw 等导致方法终止的语句，一旦在finally块中使用了return或throw语句，将会使try块、catch块中的return、throw语句失效！

2.6.2 子父类异常

public class ZiFuClassException {
    public void show01() throws NullPointerException,ClassCastException{}
    public void show02() throws IndexOutOfBoundsException{}
    public void show03() throws IndexOutOfBoundsException{}
    public void show04() {}
}

class Zi extends ZiFuClassException{
    //1.子类重写父类方法时，抛出和父类相同的异常
    public void show01() throws NullPointerException,ClassCastException{}
    
    //2.子类重写父类方法时，抛出父类异常的子类
    public void show02() throws ArrayIndexOutOfBoundsException{}
    
    //3.子类重写父类方法时，不抛出异常
    public void show03() {}
    
    //4.父类方法没有抛出异常，子类重写父类方法时也不能抛出异常,
    //   此时此类产生该异常，只能捕获处理，不能声明处理
    //public void show04() thorws Exception{} //错误
    public void show04(){
        try {
            throw new Exception("编译期异常");
        }catch (Exception e){
            System.out.println(e);
        }
    }
}

2.7 自定义异常

2.7.1 概述、定义

什么是自定义异常类:

在开发中根据自己业务的异常情况来定义异常类.

自定义一个业务逻辑异常: RegisterException。一个注册异常类。

异常类如何定义:

自定义一个编译期异常: 自定义类并继承于java.lang.Exception。
自定义一个运行时期的异常类:自定义类并继承于java.lang.RuntimeException。

2.7.2 自定义异常的练习

要求：我们模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

首先定义一个登陆异常类RegisterException：

// 业务逻辑异常
public class RegisterException extends Exception {
    /**
     * 空参构造
     */
    public RegisterException() {
    }

    /**
     *
     * @param message 表示异常提示
     */
    public RegisterException(String message) {
        super(message);
    }
}

/**
 * 自定义异常类：
 *      java提供的异常类，不够我们使用，需要子集定义一些异常类
 * 格式：
 *      public class XXXException extends Excetpion | RuntimeException{
 *          添加一个空参数的构造方法
 *          添加一个带异常信息的构造方法
 *      }
 * 注意：
 *      1.自定义异常类一般都是以Exception结尾，说明该类是一个异常类
 *      2.自定义异常类，必须得继承Exception或者RuntimeException
 *           继承Exception：那么自定义的异常类就是一个编译期异常，
 *              如果方法内部抛出了编译期异常，就必须处理这个异常，要么throws，要么try...catch。
 *           继承RuntimeException：那么自定义的异常类就是一个运行期异常，
 *              无需处理，交给虚拟机处理（中断处理）
 */
public class CustomException extends Exception{
    //添加一个空参数的方法
    public CustomException(){
        super();
    }
    //添加一个带异常信息的构造方法
    //方法内部会调用父类带异常信息的构造方法，让父类来处理这个异常信息
    public CustomException(String message){
        super(message);
    }
}

模拟登陆操作，使用数组模拟数据库中存储的数据，并提供当前注册账号是否存在方法用于判断。

public class Demo {
    // 模拟数据库中已存在账号
    private static String[] names = {"bill","hill","jill"};
   
    public static void main(String[] args) {     
        //调用方法
        try{
            // 可能出现异常的代码
            checkUsername("nill");
            System.out.println("注册成功");//如果没有异常就是注册成功
        }catch(RegisterException e){
            //处理异常
            e.printStackTrace();
        }
    }

    //判断当前注册账号是否存在
    //因为是编译期异常，又想调用者去处理 所以声明该异常
    public static boolean checkUsername(String uname) throws RegisterException{
        for (String name : names) {
            if(name.equals(uname)){//如果名字在这里面 就抛出登陆异常
                throw new RegisterException("亲"+name+"已经被注册了！");
            }
        }
        return true;
    }
}

2.8 JDK7 和 JDK9 对try…catch的优化

JDK7前处理

之前的入门练习，我们一直把异常抛出，而实际开发中并不能这样处理，建议使用try...catch...finally 代码块，处理异常部分，代码使用演示：

public class HandleException1 {
    public static void main(String[] args) {
      	// 声明变量
        FileWriter fw = null;
        try {
            //创建流对象
            fw = new FileWriter("fw.txt");
            // 写出数据
            fw.write("我是程序员"); //我是程序员
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (fw != null) {
                    fw.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

JDK7的处理(扩展知识点了解内容)

还可以使用JDK7优化后的try-with-resource 语句，该语句确保了每个资源在语句结束时关闭（该资源类需要实现 AutoCloseable 接口并重写 close 方法，才可以自动关闭）。所谓的资源（resource）是指在程序完成后，必须关闭的对象。
格式：

try (创建流对象语句，如果多个,使用';'隔开) {
	// 读写数据
} catch (IOException e) {
	e.printStackTrace();
}

代码使用演示：

public class HandleException2 {
    public static void main(String[] args) {
      	// 创建流对象
        try ( FileWriter fw = new FileWriter("fw.txt"); ) {
            // 写出数据
            fw.write("我是程序员"); //我是程序员
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

JDK9的改进(扩展知识点了解内容)

JDK9中try-with-resource 的改进，对于引入对象的方式，支持的更加简洁。被引入的对象，同样可以自动关闭，无需手动close，我们来了解一下格式。

改进前格式：

// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");
// 引入方式：创建新的变量保存
try (Resource r1 = resource1;
     Resource r2 = resource2) {
     // 使用对象
}

改进后格式：

// 被final修饰的对象
final Resource resource1 = new Resource("resource1");
// 普通对象
Resource resource2 = new Resource("resource2");

// 引入方式：直接引入
try (resource1; resource2) {
     // 使用对象
}

改进后，代码使用演示：

public class TryDemo {
    public static void main(String[] args) throws IOException {
       	// 创建流对象
        final  FileReader fr  = new FileReader("in.txt");
        FileWriter fw = new FileWriter("out.txt");
       	// 引入到try中
        try (fr; fw) {
          	// 定义变量
            int b;
          	// 读取数据
          	while ((b = fr.read())!=-1) {
            	// 写出数据
            	fw.write(b);
          	}
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}