牛客网刷题（2）

有借用大佬的评论，侵删

这几天一直突击复习学的我有点抑郁

[1. 不同编程软件数据类型的字节占用空间](#1. 不同编程软件数据类型的字节占用空间)

[2. ASCII 码核心数值速记](#2. ASCII 码核心数值速记)

[3.finally 块无论是否抛出异常、是否有 return，都会执行。](#3.finally 块无论是否抛出异常、是否有 return，都会执行。)

[4. Java 三大核心注解详解](#4. Java 三大核心注解详解)

[4.1 @Override 注解](#4.1 @Override 注解)

[4.2 @Deprecated 注解](#4.2 @Deprecated 注解)

[4.3 @SuppressWarnings 注解](#4.3 @SuppressWarnings 注解)

[5. 多线程通信工具与 TLS 线程局部存储解析](#5. 多线程通信工具与 TLS 线程局部存储解析)

[5.1 线程通信工具核心规则（wait/notify/Condition）](#5.1 线程通信工具核心规则（wait/notify/Condition）)

[5.2 TLS（线程局部存储）](#5.2 TLS（线程局部存储）)

[6. 类的向上转型与向下转型核心规则](#6. 类的向上转型与向下转型核心规则)

[7. forward 与 redirect 核心区别](#7. forward 与 redirect 核心区别)

[8. ConcurrentHashMap 底层结构选择原因](#8. ConcurrentHashMap 底层结构选择原因)

[9. 类加载顺序 + ArrayList 核心特性 + 成员内部类代码示例](#9. 类加载顺序 + ArrayList 核心特性 + 成员内部类代码示例)

[9.1 正常类的加载执行顺序](#9.1 正常类的加载执行顺序)

[9.2 ArrayList 核心容量特性](#9.2 ArrayList 核心容量特性)

[9.3 成员内部类核心代码示例（Java）](#9.3 成员内部类核心代码示例（Java）)

[10. Java 垃圾回收机制 + JVM 常用指令](#10. Java 垃圾回收机制 + JVM 常用指令)

[10.1 垃圾回收（GC）核心要点](#10.1 垃圾回收（GC）核心要点)

[10.2 JVM 常用调试 / 监控指令](#10.2 JVM 常用调试 / 监控指令)

[11. StringBuffer 的 length 与 capacity 核心规则](#11. StringBuffer 的 length 与 capacity 核心规则)

[12. 逻辑或（||）与按位或（|）的执行差异](#12. 逻辑或（||）与按位或（|）的执行差异)

[13. Java 接口成员默认修饰符 + abstract 使用规则](#13. Java 接口成员默认修饰符 + abstract 使用规则)

[13.1 接口中成员的默认修饰符（不写时自动隐含）](#13.1 接口中成员的默认修饰符（不写时自动隐含）)

[13.2 abstract 关键字使用限制](#13.2 abstract 关键字使用限制)

[14. 接口字段必须为 public static final 的底层原因](#14. 接口字段必须为 public static final 的底层原因)

[15. 静态变量（类变量）与实例变量（对象变量）特性对比](#15. 静态变量（类变量）与实例变量（对象变量）特性对比)

[16. 类的字段（成员变量）与方法（成员方法）特性对](#16. 类的字段（成员变量）与方法（成员方法）特性对)比

1. 不同编程软件数据类型的字节占用空间

数据类型	Java (固定)	C++ (典型 64 位)	Python (CPython 实现)
整数类
byte / int8	1 字节	char: 1 字节	❌ 无此类型
short / int16	2 字节	short: 2 字节	❌ 无固定短整型
int / int32	4 字节	int: 4 字节	动态：小整数对象约 28 字节（含对象头），数值越大内存占用越大
long / int64	8 字节	long: 4/8 字节 *long long: 8 字节	同 int（Python 3 中 int 为任意精度）
浮点类
float	4 字节	4 字节	对象约 24 字节（底层存储 8 字节 double）
double	8 字节	8 字节	同 float（Python 无单精度 float）
字符 / 布尔
char	2 字节 (Unicode)	char: 1 字节wchar_t: 2/4 字节 *	str 为对象：单字符约 50 + 字节（含对象头 + 编码开销）
boolean	规范未定（教学常称 1 字节；数组中占 1 字节）	bool: 1 字节	bool 为 int 子类，对象约 28 字节（True/False 为单例）
特殊说明	与平台无关 ✅	强平台依赖 ⚠️	对象开销主导 ⚠️

2. ASCII 码核心数值速记

核心基础数值：

数字 0：48
大写字母 A：65
小写字母 a：97数值组合速记：486597 → 486 597 → 486（486+111）

3.finally 块无论是否抛出异常、是否有 return，都会执行。

4. Java 三大核心注解详解

聚焦核心作用、修饰目标、关键特性，保留@SuppressWarnings关键字核心用途，适配学习和开发场景。

4.1 @Override 注解

核心作用：显式指明方法是覆写 / 实现超类（父类）或接口的方法，让编译器做覆写合法性强制校验，提前暴露错误。
修饰目标：仅能修饰方法，不可修饰类、变量等其他元素。
关键特性 ：
1. 若未真正覆写 / 实现（如方法名拼写错误、参数列表不一致），编译器直接抛编译错误（非运行时异常）；
2. 不写该注解，合法覆写依然有效，注解仅为显式校验手段，提升代码可读性。

4.2 @Deprecated 注解

核心作用：标记程序元素为不建议使用状态，提示开发者该元素有缺陷、有替代方案，或未来会被移除 / 停止支持。
修饰目标：可修饰类、方法、变量（所有核心程序元素）。
关键特性 ：
1. 被注解元素仍可正常使用，编译器仅抛警告（非编译错误）；
2. 适配 JDK / 第三方 jar 包 API，也适用于项目自定义代码，规范团队开发；
3. 长期使用有风险，版本升级时该元素可能被删除，导致运行时错误。

4.3 @SuppressWarnings 注解

核心作用 ：抑制编译器编译时产生的指定类型警告，让编译器不再抛出对应警告信息。
修饰目标：类、方法、变量、语句块等（可精准作用于单个代码片段或整个类）。
关键注意事项 ：开发中严禁随意使用 ，抑制警告会屏蔽代码潜在问题（如空值风险、泛型未指定类型），仅可在确认无风险的特殊场景临时使用，且需精准指定警告类型，避免通配符抑制所有警告。
核心关键字及抑制场景：

关键字	抑制的警告类型
all	抑制所有类型的警告（严禁随意使用）
boxing	抑制装箱 / 拆箱操作相关警告
cast	抑制类型强制转换相关警告
deprecation	抑制使用 @Deprecated 元素的过时警告
fallthrough	抑制 switch 语句缺少 break 的穿透警告
null	抑制空值分析相关警告（如空指针风险）
rawtypes	抑制泛型未指定具体类型的警告
serial	抑制可序列化类缺少 serialVersionUID 的警告
unchecked	抑制泛型未检查操作的警告（最常用）
unused	抑制未使用代码（未使用变量 / 方法）的警告

5. 多线程通信工具与 TLS 线程局部存储解析

5.1 线程通信工具核心规则（wait/notify/Condition）

Object 类、Lock 框架、Thread 类、ReentrantLock 的线程通信相关核心要点：

Object类提供wait()/notify()/notifyAll()，必须在 synchronized 同步块内使用；
Condition是 Lock 框架的线程通信工具，提供await()/signal()/signalAll()，功能与 wait/notify 类似，支持多个等待队列 ，必须在 Lock 锁定后使用；
Thread类继承 Object 虽拥有 wait/notify，但这些方法基于对象锁使用，并非 Thread 类自身的线程通信方法；
ReentrantLock无直接的 wait/notify 方法，需通过newCondition()获取 Condition 对象实现线程通信。

5.2 TLS（线程局部存储）

TLS 为每个线程提供独立的变量副本，是重要的并发编程技术

TLS 是解决多线程访问冲突的技术，通过独立副本避免数据竞争；
TLS 为每个线程创建并维护独立变量副本，副本与线程绑定，其他线程无法访问；
TLS 不代表完全无需同步，若操作涉及多步骤或其他共享资源，仍需同步机制；
Java 中的ThreadLocal类是 TLS 技术的具体实现，用于创建线程局部变量。

6. 类的向上转型与向下转型核心规则

向上转型（子类转父类） ：自动且安全，无需显式转换；
向下转型（父类转子类） ：必须显式转换 ，且仅当对象实际类型 是目标类型或其子类时成功，否则抛出ClassCastException。

7. forward 与 redirect 核心区别

（严格来说是前端知识点，但是以后都是要转全栈的说不定呢记一下吧）

forward（请求转发）和 redirect（重定向）是服务端页面跳转的两种方式，核心区别分 4 个维度：

地址栏显示 ：
- forward：服务器读取目标 URL 内容后返回浏览器，地址栏保留原地址；
- redirect：服务端发送状态码，让浏览器重新请求新 URL，地址栏显示新 URL。
数据共享 ：
- forward：转发页面与目标页面可共享 request 域数据；
- redirect：不可共享request 域数据。
适用场景 ：
- forward：用户登录时，根据角色转发到对应模块；
- redirect：用户注销登录返回主页面、跳转到其他网站。
执行效率 ：
- forward：效率高（服务器内部跳转，仅 1 次请求）；
- redirect：效率低（浏览器重新请求，2 次请求）。

8. ConcurrentHashMap 底层结构选择原因

ConcurrentHashMap未使用 B + 树，而是选用红黑树，核心原因：红黑树更适合内存存储 ，而 B + 树是为磁盘存储场景设计（适合大规模数据的磁盘 IO 优化）。

9. 类加载顺序 + ArrayList 核心特性 + 成员内部类代码示例

9.1 正常类的加载执行顺序

静态变量 / 静态代码块 → main 方法 → 非静态变量 / 非静态代码块 → 构造方法

9.2 ArrayList 核心容量特性

无参构造默认初始数组大小为 10；
扩容后大小为扩容前的 1.5 倍 ，最大容量小于Integer.MAX_VALUE - 8；
带初始值的构造，数组大小为传入值，无初始扩容操作；
集合中「有序」指记录元素的插入顺序。

9.3 成员内部类核心代码示例（Java）

成员内部类依托外部类实例存在，可直接访问外部类所有成员（包括私有），外部类访问内部类需先创建内部类实例。

复制代码

class Outter {
    // 外部类私有成员变量
    private int a = 10;
    // 成员内部类
    class Inner {
        // 内部类公有成员变量
        public int b = 20;
        // 内部类直接访问外部类私有成员
        public void m() {
            int c = a;
            System.out.println("内部类Inner的m()方法：获取外部类私有变量a = " + a + "，赋值给c后，c = " + c);
        }
    }
    // 外部类访问内部类，必须先创建内部类实例
    public void m() {
        Inner inner = new Inner();
        int m = inner.b;
        System.out.println("外部类Outter的m()方法：通过内部类实例获取b = " + inner.b + "，赋值给m后，m = " + m);
    }
    // 程序入口main方法（static）
    public static void main(String[] args) {
        // 1. 创建外部类实例（成员内部类无法单独创建）
        Outter outter = new Outter();
        // 2. 调用外部类方法
        outter.m();
        // 3. 创建成员内部类实例：外部类实例.new 内部类名()
        Inner inner = outter.new Inner();
        // 4. 调用内部类方法
        inner.m();
        // 直接访问内部类成员变量
        System.out.println("直接访问内部类实例的成员变量b = " + inner.b);
    }
}

10. Java 垃圾回收机制 + JVM 常用指令

10.1 垃圾回收（GC）核心要点

GC主要针对堆区回收，栈区内存随线程结束自动释放；
堆区分为三个区域：年轻代、年老代（老年代）、永久代（方法区）；
年轻代：新创建的对象（大对象除外）存放于此，经过多次 Minor GC（年轻代专属回收）存活的对象会移至年老代；
年老代：存放年轻代移来的对象 + 大对象，由 Full GC（整堆回收）负责回收；
永久代：存储 final 常量、static 变量、常量池，属于方法区实现；
核心细节：String的substring()方法底层会new 一个新 String 对象返回，直接 new 的 String 对象会根据大小分配至年轻代 / 年老代。

10.2 JVM 常用调试 / 监控指令

jps：查看本机 Java 进程信息；
jstack：打印线程栈信息，生成线程 dump 文件；
jmap：打印内存映射，生成堆 dump 文件；
jstat：JVM 性能监控工具（实时监控内存、GC 等）；
jhat：堆内存分析工具（解析 jmap 生成的 dump 文件）；
jconsole：简易的 JVM 可视化监控控制台；
jvisualvm：功能强大的 JVM 可视化控制台（集成监控、分析、调试）。

11. StringBuffer 的 length 与 capacity 核心规则

StringBuffer s = new StringBuffer(x);（x 为初始化容量 ），s.append("Y");（Y 为长度为 y 的字符串），核心规则：

length() ：始终返回当前字符串实际长度，即 y；
capacity() （容器容量）：
- 当 y < x 时，容量为 x（不扩容）；
- 当 x < y < 2x+2 时，容量扩容为 2x+2；
- 当 y > 2*x+2 时，容量扩容为 y（按需扩容）。

12. 逻辑或（||）与按位或（|）的执行差异

核心区别为短路特性：

逻辑或||：前面表达式为 true 时，直接跳过后面表达式（短路）；
按位或|：无论前面表达式是否为 true，都会执行后面表达式（无短路）。

13. Java 接口成员默认修饰符 + abstract 使用规则

13.1 接口中成员的默认修饰符（不写时自动隐含）

接口中字段：public static final；
接口中方法：public abstract（Java 8 及以后默认方法 / 静态方法除外）。

13.2 abstract 关键字使用限制

abstract仅能修饰类和方法 ，不能修饰字段。

14. 接口字段必须为 public static final 的底层原因

接口字段的三个修饰符为强制要求，核心原因适配接口的设计特性（接口不能实例化，方法默认为抽象）：

public：接口支持多层级继承 / 实现，public 满足不同层级的变量访问范围；
static：接口不能实例化，非 static 变量需实例化后访问，无实际意义；
final：接口方法默认为 abstract，无法修改变量值，若变量非 final，直接修改静态变量会导致所有实现类的值被修改，失去接口设计意义。

15. 静态变量（类变量）与实例变量（对象变量）特性对比

特性	静态变量（类变量）	实例变量（对象变量）
修饰符	必须加 static	不加 static（默认）
归属	属于类本身	属于类的每个对象 / 实例
内存分配	类加载时分配 1 份，存方法区	对象创建时分配，每个对象 1 份，存堆
访问方式	推荐「类名。变量名」，也可对象名	仅能「对象名。变量名」，类名访问编译报错
生命周期	随类加载创建，类卸载销毁	随对象创建，对象被 GC 回收销毁
与对象的关系	所有对象共享同一份值	每个对象独有一份值，互相独立
静态方法中能否访问	可以直接访问	不能直接访问（需创建对象）

16. 类的字段（成员变量）与方法（成员方法）特性对比

特性	字段（成员变量）	方法（成员方法）
核心作用	存储数据，保存类 / 对象的状态	执行逻辑，操作数据，实现类 / 对象的行为功能
语法特征	「类型 + 变量名」，无括号、无参数	「修饰符 + 返回值 + 方法名 (参数列表){代码块}」，必有括号
分类	静态字段、实例字段	静态方法、实例方法
调用方式	静态：类名。字段名实例：对象名。字段名	静态：类名。方法名 (参数)实例：对象名。方法名 (参数)
与数据的关系	是数据本身（存值）	是操作数据的逻辑（用值 / 改值）
返回值	无返回值概念，本身就是值	有返回值（指定类型）/ 无返回值（void）
静态上下文访问	静态方法可直接访问静态字段，不能直接访问实例字段	静态方法可直接调用静态方法，不能直接调用实例方法（需创建对象）