JAVA零基础小白学习免费教程day12-异常&Log4J

Posted 2023-01-18 teayear

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JAVA零基础小白学习免费教程day12-异常&Log4J相关的知识，希望对你有一定的参考价值。

day12_JAVAOOP

课程目标

1. 【理解】什么是异常
2. 【理解】异常的体系结构
3. 【掌握】处理异常的方式
4. 【理解】自定义异常
5. 【理解】Log4J的作用

视频：https://www.bilibili.com/video/BV1QG4y1J76q?p=64

异常概述

什么是异常

异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是：

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

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

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

异常的体系

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

Throwable体系
- Error:严重错误Error，无法通过处理的错误，只能事先避免，好比绝症。
- Exception:表示异常，异常产生后程序员可以通过代码的方式纠正，使程序继续运行，是必须要处理的。好比感冒、阑尾炎。
异常的分类

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

异常(Exception)的分类:【编译时期】和【运行时期】异常?

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

异常的处理

JVM默认处理异常的方式

如果程序出现了问题，我们没有做任何处理，最终JVM 会做默认的处理，

处理方式有如下两个步骤：
- 把异常的名称，错误原因及异常出现的位置等信息输出在了控制台
- 程序停止执行

代码演示

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

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

JVM处理异常过程分析

try-catch方式处理异常

定义格式

try 
	可能出现异常的代码;
 catch(异常类名 变量名) 
	异常的处理代码;

执行流程

程序从 try 里面的代码开始执行
出现异常，就会跳转到对应的 catch 里面去执行
执行完毕之后，程序还可以继续往下执行

代码示例

public class ExceptionDemo01 
    public static void main(String[] args) 
        int a = 10;
        int b = 0;
		//try存放的是可能出现问题的代码，如果有问题就进行catch，如果没有问题try和catch就不关心
        try 
            System.out.println("00000");
            //try中里放的代码越少越好
            System.out.println(a / b);
            //这里不会执行
            System.out.println("11111111111111111");
            //异常类尽量准确
        catch (Exception e)
            System.out.println("你不会数学，我来教你！！");
        
		//处理完之后不影响后台代码执行
        System.out.println("222222222222222");

throws和 throw 处理异常

什么是声明异常（throws）

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

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

声明异常格式

修饰符 返回值类型 方法名() throws 异常类名

什么是throw

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

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

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

throw用在方法内，用来抛出一个异常对象，将这个异常对象传递到调用者处，并结束当前方法的执行。
```
修饰符 返回值类型 方法名(参数列表) [throws 异常的类型] 
    if (判断条件) 
        throw new 异常对象("异常的原因");	
    
```
代码演示

public class ThrowsDemo 
    public static void main(String[] args) throws FileNotFoundException 
        read("a.txt");
    
    // 如果定义功能时有问题发生需要报告给调用者。可以通过在方法上使用throws关键字进行声明
    public static void read(String path) throws FileNotFoundException 
        if (!path.equals("a.txt")) //如果不是 a.txt这个文件 
            // 我假设  如果不是 a.txt 认为 该文件不存在 是一个错误 也就是异常  throw
            throw new FileNotFoundException("文件不存在");

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();

Exception大的异常

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

throw 与 throws的区别

1.throw代表动作,表示抛出一个异常的动作; throws代表一种状态,代表方法可能有异常抛出
2.throw用在方法实现中,而throws用在方法声明中
3.throw只能用于抛出一种异常,而throws可以抛出多个异常

Throwable类中常见方法

方法名	说明
String getMessage()	获取的异常的原因
String toString()	获取的是异常的类型和原因
void printStackTrace()	获取的是异常的类型原因和位置

public class ExceptionDemo5 
    public static void main(String[] args) 
        show();
    
    public static void show()
        int a = 1;
        int b = 0;
        int c =0;
        try 
            //会执行
            System.out.println("我是江一燕11");
            //注意事项：1、try的作用范围   2、在try中尽量少放代码
            c = a/b;
            //不会执行，以上的代码出错了
            System.out.println("我是江一燕22");
         catch (Exception e) 
             e.printStackTrace();                   //错误信息输出最完整方法，常用
            // System.out.println( e.getMessage() );// by zero
            // System.out.println(e.toString());    //java.lang.ArithmeticException: / by zero
        
        System.out.println(c);
        System.out.println("我是dj ,dj");

finally 代码块

什么 finally

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

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

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

具体代码要等到讲IO流的时候，会写IO流处理异常标准格式

finally格式

try 
	可能出现异常的代码;
    	。。。
 catch(异常类名 变量名) 
	异常的处理代码;
 finally
    释放资源

注意

finally不能单独使用。必须配合着try…catch使用

代码示例

public static void main(String[] args) 
    try 
        int[] arr = 1,2,3;
        System.out.println(arr[3]);
     catch (Exception e) 
        e.printStackTrace();
     finally 
        System.out.println("finally代码块执行了.....");

注意

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

异常的注意事项

多个异常使用捕获又该如何处理呢？
1. 多个异常分别处理。
2. 多个异常一次捕获，多次处理。
3. 多个异常一次捕获一次处理。
一般我们是使用一次捕获多次处理方式，格式如下：
```
try
     编写可能会出现异常的代码
catch(异常类型A  e)  // 当try中出现A类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
catch(异常类型B  e)  // 当try中出现B类型异常,就用该catch来捕获.
     处理异常的代码
     //记录日志/打印异常信息/继续抛出异常
```
注意:这种异常处理方式，要求多个catch中的异常不能相同，并且若catch中的多个异常之间有子父类异常的关系，那么子类异常要求在上面的catch处理，父类异常在下面的catch处理。
运行时异常被抛出可以不处理。即不捕获也不声明抛出。
如果finally有return语句,永远返回finally中的结果,避免该情况.
如果父类抛出了多个异常,子类重写父类方法时,抛出和父类相同的异常或者是父类异常的子类或者不抛出异常。
父类方法没有抛出异常，子类重写父类该方法时也不可抛出异常。此时子类产生该异常，只能捕获处理，不能声明抛出

/**
 * 注意事项：
 *  1:能明确的尽量明确，不要用大的来处理。
 *  2:平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。
 */
public class Demo 
    public static void main(String[] args)
        int a = 10;
        int b = 0;
        int[] arr = 1,2,3;
        try 
            // System.out.println(a/b);
            System.out.println(arr[3]);
         catch (ArithmeticException ae) 
            ae.printStackTrace();
            System.out.println("我是算术异常");
         catch (ArrayIndexOutOfBoundsException ae) 
            ae.printStackTrace();
            System.out.println("我是数组异常");
         catch (Exception e )
            e.printStackTrace();
            System.out.println("我是异常");
        
        
     public static void main(String[] args) 
        int a = 10;
        int b = 0;
        int[] arr = 1,2,3;
        try 
            System.out.println(a/b);
            System.out.println(arr[9]);
            //。。。。异常
         catch (ArithmeticException | ArrayIndexOutOfBoundsException e) 
            e.printStackTrace();
        catch (Exception e) 
            e.printStackTrace();

如果在finally之前有return

/*
 * 面试题：
 * 2:如果catch里面有return语句，请问finally里面的代码还会执行吗?
 *   如果会，请问是在return前，还是return后。
 *        会。前。
 */
    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;
         catch (ArithmeticException e) 
            a = 30;
            return a;
            /*
             * return a在程序执行到这一步的时候，这里不是return a而是return 30;这个返回路径就形成了。
             * 但是呢，它发现后面还有finally，所以继续执行finally的内容，a=40
             * 再次回到以前的返回路径，继续走return 30;
             */
         finally 
         	System.out.println("我是finally");
        
        return a;

自定义异常

为什么要自定义异常

我们说了Java中不同的异常类,分别表示着某一种具体的异常情况,那么在开发中总是有些异常情况是SUN没有定义好的,此时我们根据自己业务的异常情况来定义异常类。例如年龄负数问题,考试成绩负数问题等等。

在上述代码中，发现这些异常都是JDK内部定义好的，但是实际开发中也会出现很多异常,这些异常很可能在JDK中没有定义过,例如年龄负数问题,考试成绩负数问题.那么能不能自己定义异常呢？

什么是自定义异常类

一个类继承了java.lang.Exception或java.lang.RuntimeException类，那么这个类就是一个异常类

自定义异常类格式

public class 异常类 extends Exception | RuntimeException 
    public 异常类() 
    
    public 异常类(String message) 
        super(message);

自定义异常代码实现

需求

自定义一个业务逻辑异常: RegisterException类，模拟注册操作，如果用户名已存在，则抛出异常并提示：亲，该用户名已经被注册。

异常类RegisterException定义

// 业务逻辑异常
public class RegisterException extends Exception 
    /**     空参构造     */
    public RegisterException() 
    
    /**     
     * @param message 表示异常提示     */
    public RegisterException(String message) 
        super(message);

业务逻辑代码实现

public class Demo 
    // 模拟数据库中已存在账号
    private static String[] names = "bill","hill","jill";
    public static void main(String[] args) 
        //调用方法
        try
            for(int x = 0; x <names.length; x++)
                if(names[x].equals("bill"))//如果名字在这里面 就抛出登陆异常
                    throw new RegisterException("亲"+names[x]+"已经被注册了！");
                
            
        catch(RegisterException e)
            //处理异常
            e.printStackTrace();

Log4J

日志

什么是日志

日志用来记录用户操作、系统运行状态等，是一个系统的重要组成部分。对于一些简单的小程序，可能并不需要在如何记录日志的问题上花费太多精力。但是对于作为基础平台为很多产品提供服务的后端程序，就必须要考虑如何依靠良好的日志来保证系统可靠的运行了。

好的日志可以帮助系统的开发和运维人员：

了解线上系统的运行状态
快速准确定位线上问题
发现系统瓶颈
预警系统潜在风险
挖掘产品最大价值

不好的日志导致：

对系统的运行状态一知半解，甚至一无所知
系统出现问题无法定位，或者需要花费巨大的时间和精力
无法发现系统瓶颈，不知优化从何做起
无法基于日志对系统运行过程中的错误和潜在风险进行监控和报警
对挖掘用户行为和提升产品价值毫无帮助

日志分类

日志从功能来说，可分为诊断日志、统计日志、审计日志。

诊断日志，典型的有
- 请求入口和出口
- 外部服务调用和返回
- 资源消耗操作: 如读写文件等
- 容错行为：如云硬盘的副本修复操作
- 程序异常：如数据库无法连接
- 后台操作：定期执行删除的线程
- 启动、关闭、配置加载
统计日志
- 用户访问统计：用户IP、上传下载的数据量，请求耗时等
- 计费日志（如记录用户使用的网络资源或磁盘占用，格式较为严格，便于统计）
审计日志
- 管理操作
  
  对于简单的系统，可以将所有的日志输出到同一个日志文件中，并通过不同的关键字进行区分。而对于复杂的系统，将不同需求的日志输出到不同的日志文件中是必要的，通过对不同类型的文件采用不同的日志格式（例如对于计费日志可以直接输出为Json格式），可以方便接入其他的子系统。

日志级别

Log4j定义了8个级别的log（除去OFF和ALL，可以说分为6个级别），优先级从高到低依次为：OFF、FATAL、ERROR、WARN、INFO、DEBUG、TRACE、 ALL。

ALL

最低等级的，用于打开所有日志记录。
TRACE

designates finer-grained informational events than the DEBUG.Since:1.2.12,很低的日志级别，一般不会使用。
DEBUG

DEUBG 级别的主要输出调试性质的内容，该级别日志主要用于在开发、测试阶段输出。该级别的日志应尽可能地详尽，便于在开发、测试阶段出现问题或者异常时，对其进行分析。
INFO

INFO日志主要记录系统关键信息，旨在保留系统正常工作期间关键运行指标，开发人员可以将初始化系统配置、业务状态变化信息，或者用户业务流程中的核心处理记录到INFO日志中，方便日常运维工作以及错误回溯时上下文场景复现。建议在项目完成后，在测试环境将日志级别调成 INFO，然后通过 INFO 级别的信息看看是否能了解这个应用的运用情况，如果出现问题后是否这些日志能否提供有用的排查问题的信息。
WARN

WARN 级别的主要输出警告性质的内容，这些内容是可以预知且是有规划的，比如，某个方法入参为空或者该参数的值不满足运行该方法的条件时。在 WARN 级别的时应输出较为详尽的信息，以便于事后对日志进行分析
ERROR

ERROR 级别主要针对于一些不可预知的信息，诸如：错误、异常等，比如，在 catch 块中抓获的网络通信、数据库连接等异常，若异常对系统的整个流程影响不大，可以使用 WARN 级别日志输出。在输出 ERROR 级别的日志时，尽量多地输出方法入参数、方法执行过程中产生的对象等数据，在带有错误、异常对象的数据时，需要将该对象一并输出
FATAL

指出每个严重的错误事件将会导致应用程序的退出。这个级别比较高了。重大错误，这种级别你可以直接停止程序了。
OFF

最高等级的，用于关闭所有日志记录。

日志小结

如果将log level设置在某一个级别上，那么比此级别优先级高的log都能打印出来。例如，如果设置优先级为WARN，那么OFF、FATAL、ERROR、WARN 4个级别的log能正常输出，而INFO、DEBUG、TRACE、 ALL级别的log则会被忽略。Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。

Log4J的默认级别为：ERROR

Log4J

Log4J概述

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件等；我们也可以控制每一条日志的输出格式；通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。在apache网站：jakarta.apache.org/log4j 可以免费下载到Log4j最新版本的软件包。

Log4J的基本使用

导入log4j-1.2.17.jar

导入log4j的配置文件
注意配置文件放在src,会自动加载

代码实现

public class Log4JDemo 
    public static void main(String[] args) 
        // 获取日志记录器对象
        以上是关于JAVA零基础小白学习免费教程day12-异常&Log4J的主要内容，如果未能解决你的问题，请参考以下文章 
 JAVA零基础小白学习免费教程day14-Set&HashMap
 JAVA零基础小白学习免费教程day14-Set&HashMap
 JAVA零基础小白学习免费教程day13-Collection&数据结构
 JAVA零基础小白学习免费教程day13-Collection&数据结构
 JAVA零基础小白免费学习教程day16-字节流&字符流
 JAVA零基础小白免费学习教程day16-字节流&字符流

JAVA零基础小白学习免费教程day12-异常&Log4J

day12_JAVAOOP

课程目标

异常概述

什么是异常

异常的体系

Throwable体系

异常的处理

JVM默认处理异常的方式

处理方式有如下两个步骤：

代码演示

JVM处理异常过程分析

try-catch方式处理异常

定义格式

执行流程

代码示例

throws和 throw 处理异常

什么是声明异常（throws）

声明异常格式

什么是throw

Exception大的异常

throw 与 throws的区别

Throwable类中常见方法

finally 代码块

什么 finally

finally格式

注意

代码示例

注意

异常的注意事项

如果在finally之前有return

自定义异常

为什么要自定义异常

什么是自定义异常类

自定义异常类格式

自定义异常代码实现

需求

异常类RegisterException定义

业务逻辑代码实现

Log4J

日志

什么是日志

日志分类

诊断日志， 典型的有

统计日志

审计日志

日志级别

ALL

TRACE

DEBUG

INFO

WARN

ERROR

FATAL

OFF

日志小结

Log4J

Log4J概述

Log4J的基本使用

导入log4j-1.2.17.jar

导入log4j的配置文件

代码实现

诊断日志，典型的有