Java基础（三）：Java异常机制以及底层实现原理

server/2024/11/13 5:31:53/

🌷一、异常

☘️1.1 什么是异常

Java异常是程序发生错误的一种处理机制，异常的顶级类是Throwable，Throwable字面意思就是可抛出的，该类是所有的错误和异常的超类，只有Throwable类或者Throwable子类的实例对象才可以被Java虚拟机抛出，或者被Java语句抛出。

🍇Throwable有两个子类Error和Exception

  • Error：表示错误，比如内存溢出。

  • Exception：表示异常，比如IO异常。

🍈Exception又分为运行时异常和非运行时异常

  • 运行时异常：也叫做非检查异常，在代码中抛出运行时异常时，Java编译器在编译时不会报错，只有在运行的时候才可能会抛出该异常，RuntimeException类和该类的子类都是运行时异常。

  • 非运行时异常：也叫做检查异常或者编译时异常，Java编译器在编译的时候如果发现程序抛出了检查异常，那么编译器就会报错，需要我们在代码中处理，要么捕获，要么继续抛出。没有继承RuntimeException的异常都是非运行时异常。

Error类及其子类，都是运行时异常

🌱1.2 代码示例

1.2.1 运行时异常

运行时异常，比如ArrayIndexOutOfBoundsException、NullPointerException、RuntimeException，当程序抛出运行时异常时，即使我们没有处理，编译器也不会报错，这种抛出不一定是显示的抛出，更多的是在运行时出现异常之后JVM自动的抛出。

java">public void runException () {throw new RuntimeException();
}

1.2.2 非运行时异常

非运行时异常，比如RuntimeException、NoSuchMethodException，当程序抛出了非运行时异常时，我们必须处理，否则编译器编译时就会报错。非运行时异常更多是提供给开发者用于对可能出现的异常情况进行处理。

java">public void nonRunException () {try {throw new FileNotFoundException();} catch (FileNotFoundException e) {e.printStackTrace();}
}

🌲1.3 异常处理方法

在Java中异常处理方法有两种：继续抛出、捕获处理。

1.3.1 继续抛出

抛出异常有一个关键字：throws，throws可以抛出多个异常，多个异常类用逗号分隔即可。

当方法中抛出异常之后，如果我们不对异常处理，可以在方法上使用throws抛出异常，这样就不需要方法处理异常，但是抛出异常的方法，需要调用者来处理异常。

1.3.2 捕获处理

异常的另外一种处理办法就是捕获处理，把异常在方法内部就处理掉，这样调用者调用方法时，不需要再处理异常。

捕获异常有几个关键字try、catch、finally

  • try：用于包裹异常的代码

  • catch：用于捕获异常之后的处理，可以有多个catch来捕获不同的异常，也可以用一个catch，不同的异常用符号|来分割

  • finally：无论如何都会执行的代码块

捕获异常有三种格式：

  • 第一种，用try捕获异常，然后在catch中处理。
java">try {
} catch () {
}
// 也可以有多个catch
try {
} catch () {
} catch () {
}
// 也可以在catch中直接捕获多个异常
try {
} catch (Exception1 | Exception2) { 
}
  • 第二种，用try捕获异常，在catch中处理异常，并且在finally中执行需要执行的代码
java">try {
} catch () {
} finally {
}
  • 第三种，捕获异常之后不处理，但是要在finally中执行需要执行的代码
java">try {
} finally {
}

🥬1.4 try-with-resources

try-with-reources是JDK1.7出来的新语法，这个语法有两个目的：主要是自动关闭资源，为了减少对finally的依赖，同时使得代码变得简洁一些、同时还可以传递被抑制的异常。

1.4.1 自动关闭资源

我们先说第一个，我们先看一下如果用传统的try-catch是怎么使用的。

如果我们用try-catch-finally来关闭异常，可以发现关闭资源的代码比业务代码还要多，看起来也不是很简洁。

java">public static void main(String[] args) {FileInputStream fileInputStream = null;try {fileInputStream = new FileInputStream("");} catch (FileNotFoundException e) {e.printStackTrace();} finally {try {if (fileInputStream != null) {fileInputStream.close();}} catch (IOException e) {e.printStackTrace();}}
}

现在我们用try-with-resource来改写这个，把需要关闭资源的放到try的括号里面，这样发生了异常会自动关闭。

java">public static void main(String[] args)  {try(FileInputStream fileInputStream = new FileInputStream("")) {int result = fileInputStream.read();} catch (IOException e) {e.printStackTrace();}
}

那么try-with-resource是怎么实现自动关闭，我们反编译一下字节码，可以看到本质上还是用的try-catch来实现的，只不过是在try里面调用了close。

java">public static void main(String[] args) {
try {FileInputStream fileInputStream = new FileInputStream("file.txt");Object var2 = null;if (fileInputStream != null) {if (var2 != null) {try {fileInputStream.close();} catch (Throwable var4) {((Throwable)var2).addSuppressed(var4);}} else {fileInputStream.close();}}
} catch (IOException var5) {IOException e = var5;e.printStackTrace();
}

1.4.2 传递抑制的异常

如果try和finally都发生了异常，并且抛出那么finally中的异常就会覆盖try中的异常。

我们在一个方法里面先抛出一个FileNotFoundException异常，然后再finally里面关闭这个流的时候又会出现NullPointerException异常，在main方法进行捕获之后可以发现最后只打印了NullPointerException异常，而FileNotFoundException并没有打印出来。

java">public static void main(String[] args) {try {c();} catch (Exception e) {e.printStackTrace();}
}public static void c () throws IOException {FileInputStream fileInputStream = null;try {fileInputStream = new FileInputStream("");} catch (FileNotFoundException e) {throw e;} finally {try {fileInputStream.close();} catch (IOException e) {throw e;}}
}

打印出来的异常信息

java">java.lang.NullPointerExceptionat com.lee.study.exception.Demo.c(Demo.java:26)at com.lee.study.exception.Demo.main(Demo.java:12)

我们再用try-with-resources改写一下，这里我们需要构造一个自定义的类，实现在关闭的时候也抛出异常。

java">public static void main(String[] args) {try (MyAutoCloseable myAutoCloseable = new MyAutoCloseable();) {myAutoCloseable.read();}catch (Exception e) {e.printStackTrace();}}
}
// 实现了AutoCloseable接口可以自动的调用close方法
class MyAutoCloseable implements AutoCloseable {public void read() throws Exception {throw new Exception("read");
}@Override
public void close() throws Exception {throw new Exception("close");
}

打印出来的异常信息

java">java.lang.Exception: readat com.lee.study.exception.MyAutoCloseable.read(Demo.java:22)at com.lee.study.exception.Demo.main(Demo.java:12)Suppressed: java.lang.Exception: closeat com.lee.study.exception.MyAutoCloseable.close(Demo.java:27)at com.lee.study.exception.Demo.main(Demo.java:13)

我们看下反编译代码，可以看到在finally中关闭的时候调用了一个方法addSuppressed，这个方法就是用来把这些抑制的异常都记录下来。

java">public static void main(String[] args) {try {MyAutoCloseable myAutoCloseable = new MyAutoCloseable();Throwable var2 = null;try {myAutoCloseable.read();} catch (Throwable var12) {var2 = var12;throw var12;} finally {if (myAutoCloseable != null) {if (var2 != null) {try {myAutoCloseable.close();} catch (Throwable var11) {var2.addSuppressed(var11);}} else {myAutoCloseable.close();}}}} catch (Exception var14) {Exception e = var14;e.printStackTrace();}}

🌳1.5 自定义异常

除了Java中提供的异常之外，我们也可以自定义一些异常，自定义异常可以自定义运行时异常和非运行时异常两种方式。

1.5.1 自定义运行时异常

自定义运行时异常之需要继承RuntimeException这个方法即可，这里我们加了一个构造方法，这样可以创建异常对象时加一些描述异常信息。

java">public class DemoRuntimeException extends RuntimeException{public DemoRuntimeException (String message) {super(message);}
}

1.5.2 自定义非运行时异常

自定义非运行时异常只需要继承Exception，这里也是加了一个构造方法，描述异常信息。

java">public class DemoNonRuntimeException extends Exception{public DemoNonRuntimeException (String message) {super(message);}
}

🌸二、源码分析

🌴2.1 变量

java">// 用来保存栈信息的轨迹
private transient Object backtrace;// 记录描述异常信息
private String detailMessage;// 描述这个异常是哪个Throwable导致的，默认是当前Throwable
private Throwable cause = this;// 记录异常抛出位置的栈信息，每个StackTraceElement代表一个栈
private static final StackTraceElement[] UNASSIGNED_STACK = new StackTraceElement[0];
private StackTraceElement[] stackTrace = UNASSIGNED_STACK;//用来保存被屏蔽的异常对象，如果在finally中抛出了异常，就会覆盖try中的异常，这个是JDK 1.7引入的新特性
private static final List<Throwable> SUPPRESSED_SENTINEL =Collections.unmodifiableList(new ArrayList<Throwable>(0));
private List<Throwable> suppressedExceptions = SUPPRESSED_SENTINEL;

🌵2.2 构造方法

java">/*** 无参构造方法，只调用了fillInStackTrace方法*/
public Throwable() {fillInStackTrace();
}/*** @param message 描述异常的信息，打印异常信息会一并打印*/
public Throwable(String message) {fillInStackTrace();detailMessage = message;
}/*** @param message 描述异常的信息，打印异常信息会一并打印* @param cause 当前异常是哪个Throwable导致的*/
public Throwable(String message, Throwable cause) {fillInStackTrace();detailMessage = message;this.cause = cause;
}/*** @param cause 当前异常是哪个Throwable导致的*/
public Throwable(Throwable cause) {fillInStackTrace();detailMessage = (cause==null ? null : cause.toString());this.cause = cause;
}/*** @param message 描述异常的信息，打印异常信息会一并打印* @param cause 当前异常是哪个Throwable导致的* @param enableSuppression 是否开启记录被屏蔽的对象* @param writableStackTrace 是否开启记录异常栈信息*/
protected Throwable(String message, Throwable cause,boolean enableSuppression,boolean writableStackTrace) {if (writableStackTrace) {fillInStackTrace();} else {stackTrace = null;}detailMessage = message;this.cause = cause;if (!enableSuppression)suppressedExceptions = null;
}

🌾2.3 fillInStackTrace

2.3.1 方法描述

在构造方法中都会先调用一下这个fillInStackTrace方法，这个方法主要是获取栈信息，并且对保存栈信息数组进行清空。

首先会判断当前保存栈信息数组stackTrace和栈信息轨迹backtrace是否为空，如果不为空的话调用native的fillInStackTrace获取栈信息，然后把保存栈信息数组stackTrace清空。

当创建Throwable传入的参数writableStackTrace为false，stackTrace就会为空，这样就不会开启异常栈信息的记录。如果你不需要记录栈信息，在自定义异常时可以重新这个方法，直接返回this。

java">public synchronized Throwable fillInStackTrace() {if (stackTrace != null || backtrace != null) {fillInStackTrace(0);stackTrace = UNASSIGNED_STACK;}return this;
}private native Throwable fillInStackTrace(int dummy);

2.3.2 代码示例

先看一个例子，在main方法中调用a，并且捕获异常，打印异常信息，在a调用b，并捕获异常，打印异常信息。

java">public class Demo {public static void main(String[] args) {try {a ();} catch (Exception e) {e.printStackTrace();}}public static void a () throws Exception {try {c();} catch (Exception e) {e.printStackTrace();throw e;}}public static void c () throws Exception {throw new Exception("报错了");}
}

把异常信息打印出来，发现两次打印的是一样的，也就是捕获到异常又抛出，异常的栈轨迹是一样的。

java">java.lang.Exception: 报错了at com.lee.study.exception.Demo.c(Demo.java:25)at com.lee.study.exception.Demo.a(Demo.java:17)at com.lee.study.exception.Demo.main(Demo.java:9)
java.lang.Exception: 报错了at com.lee.study.exception.Demo.c(Demo.java:25)at com.lee.study.exception.Demo.a(Demo.java:17)at com.lee.study.exception.Demo.main(Demo.java:9)

我们将代码修改一下，在catch里面调用一下fillInStackTrace方法

java">public class Demo {public static void main(String[] args) {try {a ();} catch (Exception e) {e.printStackTrace();}}public static void a () throws Exception {try {c();} catch (Exception e) {e.printStackTrace();// 调用一下fillInStackTracee.fillInStackTrace();throw e;}}public static void c () throws Exception {throw new Exception("报错了");}
}

再看一下打印的栈轨迹信息，第二次打印的时候已经没有调用b的轨迹了。其实调用这个方法，相当于是把异常栈的数组给清空了。

java">java.lang.Exception: 报错了at com.lee.study.exception.Demo.c(Demo.java:27)at com.lee.study.exception.Demo.a(Demo.java:17)at com.lee.study.exception.Demo.main(Demo.java:9)
java.lang.Exception: 报错了at com.lee.study.exception.Demo.a(Demo.java:21)at com.lee.study.exception.Demo.main(Demo.java:9)

2.3.3 爬栈

有时候我们不需要记录异常栈轨迹信息，有两种方法实现，第一个是在创建Throwable时writableStackTrace设置为false，第二个是我们可以重写fillInStackTrace方法，直接返回this。

定义一个异常，并且调用打印异常信息

java">public class DemoNonRuntimeException extends Exception{public DemoNonRuntimeException (String message) {super(message);}
}
public class Demo {public static void main(String[] args) {try {c ();} catch (DemoNonRuntimeException e) {e.printStackTrace();}}public static void c () throws DemoNonRuntimeException {throw new DemoNonRuntimeException("报错了");}
}

打印的异常信息

java">com.lee.study.exception.DemoNonRuntimeException: 报错了at com.lee.study.exception.Demo.c(Demo.java:17)at com.lee.study.exception.Demo.main(Demo.java:9)

如果我们重写fillInStackTrace方法

java">public class DemoNonRuntimeException extends Exception{public DemoNonRuntimeException (String message) {super(message);}public Throwable fillInStackTrace () {return this;}
}public class Demo {public static void main(String[] args) {try {c ();} catch (DemoNonRuntimeException e) {e.printStackTrace();}}public static void c () throws DemoNonRuntimeException {throw new DemoNonRuntimeException("报错了");}
}

再打印异常信息，就会发现已经没有栈轨迹信息了。

java">com.lee.study.exception.DemoNonRuntimeException: 报错了

🌿2.4 printStackTrace

这个方法是用来打印异常栈信息的方法，我们对这个方法应该是最熟悉的。

java">private void printStackTrace(PrintStreamOrWriter s) {Set<Throwable> dejaVu =Collections.newSetFromMap(new IdentityHashMap<Throwable, Boolean>());dejaVu.add(this);synchronized (s.lock()) {s.println(this);StackTraceElement[] trace = getOurStackTrace();for (StackTraceElement traceElement : trace)s.println("\tat " + traceElement);for (Throwable se : getSuppressed())se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION, "\t", dejaVu);Throwable ourCause = getCause();if (ourCause != null)ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, "", dejaVu);}
}

🍀2.5 getMessage

用于获取异常描述信息

java">public String getMessage() {return detailMessage;
}

🌹三、JVM处理异常原理

这里我们从字节码的角度来分析一下异常的实现原理，主要是try-catch的实现原理，因为throws时不处理异常的，只是继续抛出。

这里我们以三个例子来说明异常处理的原理：

🥇try-catch

🥈try-catch-finally

🥉try-catch-finally，并在finally中return

🍁3.1 分析前准备

3.1.1 安装字节码分析工具

因为需要字节码分析异常处理的原理，首先我们需要在idea中安装字节码工具：jclasslib插件。

安装好之后，我们找到需要分析的编译后的class文件，然后选择导航栏的View-Show Bytecode With Jclasslib查看字节码文件。

在这里插入图片描述

3.1.2 异常表

在Java中，如果一个方法有try-catch处理，在被编译成字节码都会生成一个异常表，异常表是一个表格，每一个都代表一个异常处理。

在这里插入图片描述

🥇起始PC：代表这个异常处理器监控的字节码开始位置。

🥈结束PC：代表这个异常处理器监控的字节码结束位置（不包括最后一行）。

🥉跳转PC：代表监控范围内如果发生了异常，跳转到该行字节码去执行。

🍂3.2 try-catch

3.2.1 示例代码

java">public class Demo {public static void main(String[] args) throws Exception {invoke(0, 1);}public static void invoke (int a, int b) throws Exception {try {if (b == 0) {throw new ArithmeticException();}int c = a / b;} catch (ArithmeticException e) {throw new Exception();}}
}

3.2.2 字节码

java"> 0 iload_11 ifne 12 (+11)4 new #3 <java/lang/ArithmeticException>7 dup8 invokespecial #4 <java/lang/ArithmeticException.<init>>
11 athrow
12 iload_0
13 iload_1
14 idiv
15 istore_2
16 goto 28 (+12)
19 astore_2
20 new #5 <java/lang/Exception>
23 dup
24 invokespecial #6 <java/lang/Exception.<init>>
27 athrow
28 return

3.2.3 异常表

在这里插入图片描述

3.2.4 分析

  1. 在字节码11行athrow抛出了异常ArithmeticException。

  2. JVM会去异常表中找，是否有ArithmeticException的异常处理器。

  3. 在异常表中有ArithmeticException的处理器，跳转到19行继续执行。

  4. 在27行又抛出了一个异常Exception。

  5. JVM会继续在异常表中找，是否有Exception的异常处理器。

  6. 这里没有Exception的处理器，会返回到方法的调用者继续执行上述流程，如果还是没找到就结束线程。

🍃3.3 try-catch-finally

3.3.1 示例代码

java">public class Demo {public static void main(String[] args) throws Exception {invoke(0, 1);}public static void invoke (int a, int b) throws Exception {try {if (b == 0) {throw new ArithmeticException();}int c = a / b;} catch (ArithmeticException e) {throw new Exception();} finally {System.out.println("执行方法");}}
}

3.3.2 字节码

java"> 0 iload_11 ifne 12 (+11)4 new #3 <java/lang/ArithmeticException>7 dup8 invokespecial #4 <java/lang/ArithmeticException.<init>>
11 athrow
12 iload_0
13 iload_1
14 idiv
15 istore_2
16 getstatic #5 <java/lang/System.out>
19 ldc #6 <执行方法>
21 invokevirtual #7 <java/io/PrintStream.println>
24 goto 47 (+23)
27 astore_2
28 new #8 <java/lang/Exception>
31 dup
32 invokespecial #9 <java/lang/Exception.<init>>
35 athrow
36 astore_3
37 getstatic #5 <java/lang/System.out>
40 ldc #6 <执行方法>
42 invokevirtual #7 <java/io/PrintStream.println>
45 aload_3
46 athrow
47 return

3.3.3 异常表

在这里插入图片描述

3.3.4 分析

  1. 增加了finally之后，在异常表中多了两个异常处理器，并且都是any的，表示任何异常都可以捕获。

  2. 这两个异常处理器最终都跳转到36行执行

3.3.5 为什么finally一定会执行

分两种情况如果代码执行中发生了异常和没有发生异常

  • 发生了异常

    无论时在try还是在catch中，第二个和第三个异常处理器都会捕获到，都会跳转到36行继续执行也就是finally中的内容

  • 没有发生异常

    在编译的时候会把finally的字节码拷贝到try里面代码块的后面，这样也会执行，所以为什么字节码里面有两处finally的内容

🍄3.4 try-finally-return

3.4.1 示例代码

java">public class Demo {public static void main(String[] args) {invoke();}public static int invoke () {int a = 1;try {a = 2;return a;} finally {a = 3;return a;}}
}

3.4.2 字节码

从字节码分析中分析，当finally中有return之后，会将try里面的覆盖掉，在6-9就是return的内容，而try里面的return已经不见了。

java"> 0 iconst_1 // 将1放入操作数栈1 istore_0 // 将1存储到局部变量表第一个位置2 iconst_2 // 将2放入操作数栈3 istore_0 // 将2存储到局部变量表第一个位置4 iload_0  // 加载局部变量表第一个位置元素放入操作数栈5 istore_1 // 将2存储到局部变量表第二个位置6 iconst_3 // 将3放入操作数栈7 istore_0 // 将3存储到局部变量表第一个位置8 iload_0 // 加载局部变量表第一个位置元素放入操作数栈9 ireturn // 返回
10 astore_2  
11 iconst_3 // 将3放入操作数栈
12 istore_0 // 将3存储到局部变量表第一个位置
13 iload_0 // 加载局部变量表第一个位置元素放入操作数栈
14 ireturn // 返回

🪴3.5 finally赋值

3.5.1 示例代码

java">public class Demo {public static void main(String[] args) {invoke();}public static int invoke () {int a = 1;try {a = 2;return a;} finally {a = 3;}}
}

3.5.2 字节码

java"> 0 iconst_1 // 将1放入操作数栈1 istore_0 // 将1存储到局部变量表第一个位置2 iconst_2 // 将2放入操作数栈3 istore_0 // 将2存储到局部变量表第一个位置4 iload_0 // 从局部变量表中加载第一个位置元素放入操作数栈5 istore_1 // 将2存储到局部变量表第二个位置6 iconst_3 // 将3放入操作数栈7 istore_0 // 将3存储到局部变量表第一个位置8 iload_1 // 从局部变量表中夹在第二哥位置元素放入操作数栈，也就是29 ireturn //返回
10 astore_2
11 iconst_3
12 istore_0
13 aload_2
14 athrow

3.5.3 分析

这里在finally中对a进行赋值，但是在try中返回，最后返回的值是2还是3？

这里返回的是2，虽然finally里面的内容一定会执行，但是从字节码中可以得知，在返回的时候是将局部变量表第二个位置的元素返回的，而3是存储在局部变量表第一个位置。


http://www.ppmy.cn/server/40205.html

相关文章

苹果平板HOME键成历史，全面屏时代到来？2024平板电脑市场趋势分析

苹果平板HOME键成历史，全面屏时代到来？2024平板电脑市场趋势分析

近期苹果公司在“放飞吧”发布会上推出了新款iPad Pro和iPad Air平板电脑&#xff0c;并下架了最后一款带有实体Home按键的iPad 9。这一变化标志着Home键在苹果iPad产品线中成为了历史&#xff0c;引起了不少网友的怀念和感慨。 与此同时&#xff0c;今年3月线上平板电脑市场迎…
阅读更多...
常用设计模式

常用设计模式

设计模式分三种&#xff1a;创建型、结构型、行为型 1、简单工厂模式、工厂模式、抽象工厂模式 简单工厂&#xff1a;工厂-》产品 工厂&#xff1a;抽象工厂-》工厂1-》产品1 -》工厂2-》产品2 抽象工厂&#xff1a;抽象工厂-》工厂1-》抽象产品-》产品1/产品2 2、建造者模式…
阅读更多...
什么是IP跳变？

什么是IP跳变？

IP 跳跃&#xff08;也称为 IP 跳动&#xff09;的概念已引起使用代理访问网站的用户的极大关注。但 IP 跳跃到底是什么&#xff1f;为什么它对于各种在线活动至关重要&#xff1f; 在本文中&#xff0c;我们将深入探讨 IP 跳跃的世界&#xff0c;探索其实际应用、用例、潜在问…
阅读更多...
【Python单点知识】类成员汇总讲解——包含类方法、静态方法、私有成员说明

【Python单点知识】类成员汇总讲解——包含类方法、静态方法、私有成员说明

文章目录 0. 前言1. 属性&#xff08;Attributes&#xff09;1.1 类属性&#xff08;Class Attributes&#xff09;1.2 实例属性&#xff08;Instance Attributes&#xff09; 2. 方法&#xff08;Methods&#xff09;2.1 实例方法&#xff08;Instance Methods&#xff09;2.2…
阅读更多...
如何在Mac 电脑上安装 Homebrew

如何在Mac 电脑上安装 Homebrew

1、打开终端应用程序 在终端中输入以下命令并回车: /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" 这个命令会自动下载并运行 Homebrew 的安装脚本。 系统可能会提示您输入管理员密码,请输入您的 Mac 登录…
阅读更多...
Vivado功耗之散热模型详解

Vivado功耗之散热模型详解

目录 一、前言 二、热模型 三、结温计算 四、散热器计算 五、参考资料 一、前言 ​在功耗评估中&#xff0c;Vivado中report power流程以及XPE中都有关于environment的配置&#xff0c;该界面配置涉及到多个晦涩的概念&#xff0c;之前的文章中也对相关概念进行过翻译&…
阅读更多...
第十二篇：数据库系统导论 - 探索数据管理的基石

第十二篇：数据库系统导论 - 探索数据管理的基石

数据库系统导论 - 探索数据管理的基石 1 引言 数据的力量&#xff1a;揭秘数据库系统的核心 在信息时代&#xff0c;数据无处不在&#xff0c;它们成为了企业和社会运作的基础。我们如何储存、检索、更新和维护这些数据&#xff0c;决定了我们能否从这些数据中获得力量。数据…
阅读更多...
CSS-盒子模型元素溢出

CSS-盒子模型元素溢出

作用&#xff1a;控制溢出的元素的内容的显示方式 属性&#xff1a;overflow 属性值 属性值效果hidden溢出隐藏scroll溢出滚动&#xff08;无论是否溢出&#xff0c;都显示滚动条位置&#xff09;auto溢出滚动&#xff08;溢出才显示滚动条位置&#xff09; <!DOCTYPE html&…
阅读更多...
最新文章

Copyright @ 2022~2023