qidao123.com技术社区-IT企服评测·应用市场

标题: Java灵魂拷问13个为什么，你都会哪些？ [打印本页]

作者: 道家人 时间: 2024-11-13 10:37
标题: Java灵魂拷问13个为什么，你都会哪些？

大家好，我是 V 哥。今天看了阿里云开辟者社区关于 Java 的灵魂拷问，一线大厂在用 Java 时，都会考虑哪些问题呢，对于工作多年，又没有大厂履历的小伙伴不妨看看，V 哥总结的这13个为什么，你都会哪些？先赞后看，绝不摆烂。

1. 为什么禁止使用 BigDecimal 的 equals 方法做等值比力？

BigDecimal 的 equals 方法在等值比力时存在一些问题，通常不建议直接使用它来判定数值的相等性。下面是主要缘故起因以及推荐的替代方案：
1. equals 方法比力严格，包含了精度和符号的比力

BigDecimal.equals 不但比力数值本身，还会比力精度和符号。例如，BigDecimal 的 equals 方法会以为 1.0 和 1.00 是不同的值，因为它们的 scale 不同（即小数位数不同）。例如：

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("1.00");
System.out.println(a.equals(b)); // 输出 false

复制代码

只管 1.0 和 1.00 数值上是相等的，但 equals 方法会因为精度不同返回 false。
2. equals 方法会区分正负零

在 BigDecimal 中，正零 (0.0) 和负零 (-0.0) 是不相等的，而使用 equals 会导致 0.0 和 -0.0 被视为不相等。例如：

BigDecimal zero1 = new BigDecimal("0.0");
BigDecimal zero2 = new BigDecimal("-0.0");
System.out.println(zero1.equals(zero2)); // 输出 false

复制代码

这大概会导致误判，因为在大多数业务逻辑中，我们以为 0.0 和 -0.0 是等值的。
推荐的替代方案：使用 compareTo 方法

为了避免这些问题，建议使用 BigDecimal.compareTo 方法。compareTo 方法仅比力数值的大小，不关注精度和符号。因此，在需要判定两个 BigDecimal 是否等值时，使用 compareTo 更为合理：

BigDecimal a = new BigDecimal("1.0");
BigDecimal b = new BigDecimal("1.00");
System.out.println(a.compareTo(b) == 0); // 输出 true

复制代码

在这种情况下，1.0 和 1.00 被视为相等，即使它们的精度不同，compareTo 也会返回 0。
小结

不要使用 equals 方法：它会考虑精度和符号，容易导致误判。
推荐使用 compareTo 方法：只比力数值，忽略精度和正负零的差异，可以实现更符合业务需求的等值比力。

2. 为什么禁止使用double直接构造BigDecimal？

在使用 BigDecimal 时，不建议直接使用 double 作为构造参数。这是因为 double 类型在 Java 中的表示是基于二进制浮点数的，会引入精度偏差，从而导致禁绝确的结果。例如：

double d = 0.1;
BigDecimal bd = new BigDecimal(d);
System.out.println(bd); // 输出 0.1000000000000000055511151231257827021181583404541015625

复制代码

缘故起因解析

二进制浮点数的精度问题
double 使用 IEEE 754 标准表示小数，在二进制系统中，像 0.1 这样的小数无法准确表示，导致它在存储时会酿成一个近似值。这个近似值会直接通报给 BigDecimal 的构造方法，从而天生带有偏差的 BigDecimal 值。
结果禁绝确，影响业务计算
在一些金融计算或其他对精度要求高的场景中，直接使用 double 构造 BigDecimal 会带来潜在的偏差积聚，从而影响最终的结果。例如，在多次计算或累加时，偏差大概不断放大。

推荐的替代方案

使用字符串或准确值构造 BigDecimal
通过传入字符串形式的数字，可以避免精度偏差，因为字符串构造器不会引入任何二进制的近似计算。

BigDecimal bd = new BigDecimal("0.1");
System.out.println(bd); // 输出 0.1

复制代码

使用 BigDecimal.valueOf(double) 方法
另一个安全的方式是使用 BigDecimal.valueOf(double)，该方法会将 double 转换为 String 表示，然后构造 BigDecimal，从而避免精度丧失。

BigDecimal bd = BigDecimal.valueOf(0.1);
System.out.println(bd); // 输出 0.1

复制代码

小结

避免直接使用 double 构造 BigDecimal，以免引入二进制浮点数的精度偏差。
优先使用字符串构造器，或使用 BigDecimal.valueOf(double) 以确保精度。

3. 为什么禁止使用 Apache Beanutils 进行属性的 copy ？

Apache BeanUtils 是一个早期用于 Java Bean 属性复制的工具库，但在现代 Java 开辟中通常不推荐使用它来进行属性的拷贝，尤其在性能敏感的场景中。缘故起因主要包罗以下几点：
1. 性能问题

Apache BeanUtils.copyProperties() 使用了大量的反射操纵，且每次拷贝都需要对字段、方法进行查找和反射调用。反射机制虽然机动，但性能较低，尤其是在大量对象或频仍拷贝的场景中，会产生显著的性能瓶颈。
相比之下，Spring BeanUtils 或 Apache Commons Lang 的 FieldUtils 等工具颠末优化，使用了更高效的方式进行属性复制。在性能要求较高的场所，MapStruct 或 Dozer 等编译期代码天生的方式则可以完全避免运行时反射。
2. 类型转换问题

BeanUtils.copyProperties 在属性类型不匹配时会隐式地进行类型转换。例如，将 String 类型的 "123" 转换为 Integer，如果转换失败，会抛出异常。这种隐式转换在处理数据时，大概带来不易察觉的错误，而且并不总是适合应用场景。
在准确的属性复制需求下，通常盼望类型不匹配时直接跳过拷贝，或明白抛堕落误，而不是隐式转换。例如，Spring BeanUtils.copyProperties 不会进行隐式转换，适合严格的属性匹配场景。
3. 潜在的安全问题

Apache BeanUtils 的 PropertyUtils 组件在执行反射操纵时存在一定的安全隐患。历史上，BeanUtils 的 PropertyUtils 曾有安全漏洞，使恶意用户可以通过经心构造的输入利用反射机制执行系统命令或加载恶意类。只管这些漏洞在现代版本中已得到修复，但该库的架构和实现仍较为陈旧，难以应对更高的安全需求。
4. 缺乏对嵌套对象的深拷贝支持

BeanUtils.copyProperties 仅支持浅拷贝，即只能复制对象的一级属性，无法递归地对嵌套对象进行复制。如果对象包含了复杂的嵌套结构，使用 BeanUtils.copyProperties 很容易出现不测行为或数据丢失。像 MapStruct 或 Dozer 这样的工具则提供对嵌套对象的深层复制能力，更适合复杂对象的深度拷贝需求。
推荐的替代方案

Spring BeanUtils.copyProperties()
Spring 的 BeanUtils.copyProperties() 提供了更优的性能和更好的类型安全性。它不做类型转换，且提供了方便的过滤器用于选择性拷贝属性。
MapStruct
MapStruct 是基于注解的对象映射框架，支持编译期天生代码，完全避免了反射的性能开销，且支持复杂对象、嵌套属性的深度拷贝，是性能要求较高的首选。
Dozer
Dozer 支持更机动的映射配置和深拷贝，适合对象结构复杂的情况。它可以处理嵌套属性映射、类型转换，且具有较好的自定义能力。

小结

Apache BeanUtils.copyProperties 不适合现代 Java 开辟的性能、安全性和机动性要求，推荐使用更高效、安全、机动的框架（如 Spring BeanUtils、MapStruct 等）来取代。
4. 为什么要求日期格式化时必须有使用 y 表示年，而不能用 Y ？

在日期格式化中，必须使用 y 而不是 Y 来表示年份，这是因为 y 和 Y 在 Java 和其他日期格式化工具中代表不同的寄义：

y 表示日历年（Calendar Year）
y 是标准的表示年份的字符，表示的是通常意义上的公历年，比如 2024 表示的就是这一年的年份。使用 y 时，日期格式化工具会准确地格式化出对应的年份数值：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
System.out.println(sdf.format(new Date())); // 输出: 2024-11-10

复制代码

Y 表示星期年（Week Year）
Y 表示的是“星期年”或称“ISO周年”（ISO week-numbering year），它是一种基于ISO周数的年份表示方式。这种表示法根据每年的第一个星期一地点的周来计算年份，如果某天属于新一年的第一个完整星期，则会归为新年的星期年。
例如，如果某年的最后几天在下一年开始的第一个星期中，它们大概会被归入下一年的 week year。同理，如果新年的前几天在上一年的最后一个完整星期内，这些天的星期年大概会归属上一年。这在日期和时间处理中大概导致不测的年份差异。

SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM-dd");
System.out.println(sdf.format(new Date())); // 可能输出与实际年份不同的值

复制代码

使用 Y 的潜在问题

使用 Y 表示年份会引发一些日期计算的错误，因为它依赖于周数的计算方式，不是每次都与实际的公历年份一致。例如：

2024年12月31日会被视作 2025 的 week year，导致使用 YYYY 格式化时得到 2025-12-31。
在跨年计算或特定日期逻辑中使用 Y 表示年份大概会出现错误，因为 week year 与通常理解的日历年并不总是符合。

什么时候使用 Y

Y 一样平常仅用于需要符合 ISO 8601 标准的日期格式，特殊是包含 ISO 周数（如“2024-W01-1”表示2024年的第一个星期一）的情况，而在一样平常情况下，我们都应使用 y 来表示日历年份。
小结

使用 y 来表示常规年份，避免日期格式化错误。
避免使用 Y 来表示年份，除非确实需要按照 ISO 周年的格式来解析和显示年份。

5. 为什么使用三目运算符时必需要注意类型对齐？

在使用三目运算符时，类型对齐非常重要，因为三目运算符的两个分支会被类型推断成一个共同的类型。若两者类型不同，Java 编译器会进行类型提升或自动转换，这大概导致不测的类型变化和潜在的错误。以下是需要注意的缘故起因和细节：
1. 三目运算符会自动进行类型提升

三目运算符的返回值类型是根据 true 和 false 分支的类型推断出来的。为了得到一致的结果，Java 会自动将不同的类型提升为更高精度的类型。例如，若一个分支返回 int 而另一个分支返回 double，Java 会将 int 提升为 double：

int x = 5;
double y = 10.5;
double result = (x > 0) ? x : y; // 返回 double 类型
System.out.println(result); // 输出 5.0

复制代码

这里返回值 5 被提升为 5.0。虽然代码在这个例子中不会堕落，但在某些情况下，这种自动提升会导致不测的精度丧失或类型不匹配的问题。
2. 自动拆箱和装箱大概引发 NullPointerException

在 Java 中，基本类型和包装类型的对齐需要特殊小心。三目运算符会尝试将包装类型和基本类型对齐成相同类型，这会导致自动装箱和拆箱，如果某个分支为 null 且需要拆箱，大概会引发 NullPointerException：

Integer a = null;
int b = 10;
int result = (a != null) ? a : b; // 如果 a 为 null，结果会发生自动拆箱，引发 NullPointerException

复制代码

由于 a 为 null，Java 会尝试将其拆箱为 int，从而抛出 NullPointerException。为避免这种情况，可以确保类型对齐，或避免对大概为 null 的对象进行拆箱。
3. 返回值类型不一致大概导致编译错误

如果三目运算符的两种返回类型无法被编译器自动转换为一个兼容类型，代码会直接报错。例如：

int x = 5;
String y = "10";
Object result = (x > 0) ? x : y; // 编译错误：int 和 String 不兼容

复制代码

在这种情况下，int 和 String 无法被提升到相同类型，因此会引发编译错误。若确实盼望返回不同类型的值，可以手动指定共同的超类型，例如将结果定义为 Object 类型：

Object result = (x > 0) ? Integer.valueOf(x) : y; // 这里 result 为 Object

复制代码

4. 类型对齐可以提升代码的可读性

保持三目运算符返回的类型一致，能让代码更加清晰，便于理解和维护。类型对齐可以避免类型转换和自动提升带来的混乱，使代码更容易预测和理解：

double result = (condition) ? 1.0 : 0.0; // 返回 double

复制代码

小结

保持类型一致性，确保 true 和 false 分支的类型相同，避免不测的类型提升。
小心自动装箱和拆箱，避免 null 参与三目运算符计算。
在返回不同类型时选择符合的公共类型，如使用 Object 或显式转换。

6. 为什么建议初始化 HashMap 的容量大小？

初始化 HashMap 的容量大小是为了提高性能和淘汰内存浪费。通过设置符合的初始容量，可以淘汰 HashMap 的扩容次数，提高程序运行效率。以下是详细缘故起因和建议：
1. 淘汰扩容次数，提高性能

HashMap 默认的初始容量为 16，当超过负载因子阈值（默认是 0.75，即到达容量的 75%）时，HashMap 会自动进行扩容操纵，将容量扩大为原来的两倍。扩容涉及到重新计算哈希并将数据重新分布到新的桶中，这个过程非常耗时，尤其在元素较多时，扩容会显著影响性能。
通过设置符合的初始容量，可以避免或淘汰扩容操纵，提高 HashMap 的存取效率。
2. 节省内存，避免不须要的内存开销

如果预计要存储大量数据但没有指定容量，HashMap 大概会多次扩容，每次扩容会分配新的内存空间，并将原有数据复制到新空间中，造成内存浪费。如果在创建 HashMap 时能合理估算其容量，则可以一次性分配足够的空间，从而避免重复分配内存带来的资源浪费。
3. 避免扩容带来的线程安全问题

在并发情况下，频仍扩容大概导致线程不安全，即使是 ConcurrentHashMap 也不能完全避免扩容带来的性能和一致性问题。初始化符合的容量可以淘汰并发情况下扩容带来的风险。
如何估算符合的容量

预估数据量：如果预计 HashMap 将存储 n 个元素，可以将初始容量设置为 (n / 0.75)，再向上取整为最接近的 2 的幂次方。

int initialCapacity = (int) Math.ceil(n / 0.75);
Map<String, String> map = new HashMap<>(initialCapacity);

复制代码

取 2 的幂次方：HashMap 的容量总是以 2 的幂次方增长，因为在进行哈希运算时，可以高效利用按位与操纵来计算哈希桶索引。因此，初始容量设为 2 的幂次方会使哈希分布更均匀。

示例代码

int expectedSize = 1000; // 预估需要存储的键值对数量
int initialCapacity = (int) Math.ceil(expectedSize / 0.75);
HashMap<String, Integer> map = new HashMap<>(initialCapacity);

复制代码

小结

初始化 HashMap 的容量大小有以下好处：

提高性能：淘汰扩容次数，优化存取效率。
节省内存：避免多次扩容引起的内存浪费。
提升线程安全：在并发情况下淘汰扩容带来的线程不安全风险。

合理初始化 HashMap 容量对于高性能应用尤为重要，尤其在存储大量数据时可以显著提升程序的运行效率。
7. 为什么禁止使用 Executors 创建线程池？

在 Java 中创建线程池时，不推荐直接使用 Executors 提供的快捷方法（例如 Executors.newFixedThreadPool()、Executors.newCachedThreadPool() 等），而推荐使用 ThreadPoolExecutor 构造方法来手动配置线程池。这种做法主要是为了避免 Executors 创建线程池时隐藏的风险，确保线程池配置符合需求。具体缘故起因如下：
1. 不透明的使命队列长度导致OOM风险

newFixedThreadPool() 和 newSingleThreadExecutor() 使用的是无界队列 LinkedBlockingQueue。无界队列可以存放无限数量的使命，一旦使命量非常大，队列会灵敏占用大量内存，导致 OutOfMemoryError（OOM）。
newCachedThreadPool() 使用的是 SynchronousQueue，该队列没有存储使命的能力，每个使命到来时必须立即有一个空闲线程来处理使命，否则将创建一个新线程。当使命到达速率超过线程销毁速率时，线程数量会快速增加，导致 OOM。

2. 线程数无法控制，导致资源耗尽

在 newCachedThreadPool() 创建的线程池中，线程数没有上限，短时间内大量请求会导致线程数暴增，耗尽系统资源。newFixedThreadPool() 和 newSingleThreadExecutor() 虽然限制了核心线程数，但未限制使命队列长度，依然大概耗尽内存。
在业务需求不确定或使命激增的场景下，建议明白限制线程池的最大线程数和队列长度，以更好地控制系统资源的使用，避免因线程数无法控制导致的性能问题。
3. 缺乏合理的拒绝计谋控制

Executors 创建的线程池默认使用 AbortPolicy 拒绝计谋，即当线程池到达饱和时会抛出 RejectedExecutionException 异常。
不同的业务场景大概需要不同的拒绝计谋，例如可以使用 CallerRunsPolicy（让提交使命的线程执行使命）或 DiscardOldestPolicy（抛弃最旧的使命）来平衡使命处理。

手动创建 ThreadPoolExecutor 时，可以指定适合业务需求的拒绝计谋，从而更机动地处理线程池满载的情况，避免异常或系统性能下降。
4. 机动配置核心参数

使用 ThreadPoolExecutor 的构造方法可以手动设置以下参数，以便根据业务需求机动配置线程池：

corePoolSize：核心线程数，避免空闲线程被频仍销毁和重建。
maximumPoolSize：最大线程数，控制线程池能使用的最大资源。
keepAliveTime：非核心线程的存活时间，适合控制线程销毁频率。
workQueue：使命队列类型和长度，便于管理使命积压的情况。

这些参数的合理配置可以有效平衡线程池的性能、资源占用和使命处理能力，避免使用默认配置时不符合需求的情况。
推荐的线程池创建方式

建议直接使用 ThreadPoolExecutor 构造方法配置线程池，例如：

int corePoolSize = 10;
int maximumPoolSize = 20;
long keepAliveTime = 60L;
BlockingQueue<Runnable> workQueue = new ArrayBlockingQueue<>(100);
ThreadPoolExecutor executor = new ThreadPoolExecutor(
corePoolSize,
maximumPoolSize,
keepAliveTime,
TimeUnit.SECONDS,
workQueue,
new ThreadPoolExecutor.CallerRunsPolicy() // 拒绝策略
);

复制代码

小结

使用 Executors 创建线程池会带来不易察觉的风险，大概导致系统资源耗尽或使命堆积，手动配置 ThreadPoolExecutor 可以更好地控制线程池的行为，使其符合实际业务需求和资源限制。因此，为了系统的健壮性和可控性，建议避免使用 Executors 快捷方法来创建线程池。
8. 为什么要求审慎使用 ArrayList 中的 subList 方法？

在使用 ArrayList 的 subList 方法时需要审慎，因为它有一些潜在的陷阱，容易导致不测的错误和难以排查的异常。以下是 subList 需要小心使用的缘故起因和注意事项：
1. subList 返回的是视图，而不是独立副本

ArrayList 的 subList 方法返回的是原列表的一部分视图（view），而不是一个独立的副本。对 subList 的修改会直接影响原列表，反之亦然：

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
List<Integer> subList = list.subList(1, 4);
subList.set(0, 10); // 修改 subList
System.out.println(list); // 原列表也受到影响：[1, 10, 3, 4, 5]

复制代码

这种共享视图的机制在某些场景中大概引发不测的修改，导致数据被不测改变，从而影响到原始数据结构的完整性和正确性。
2. subList 的结构性修改限制

当对 ArrayList 本身（而非 subList 视图）进行结构性修改（add、remove 等改变列表大小的操纵）后，再操纵 subList 会导致 ConcurrentModificationException 异常。这是因为 subList 和原 ArrayList 之间共享结构性修改的状态，一旦其中一个发生修改，另一方就会失效：

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
List<Integer> subList = list.subList(1, 4);
list.add(6); // 修改原列表的结构
subList.get(0); // 抛出 ConcurrentModificationException

复制代码

这种限制意味着 subList 不适合在列表频仍变化的场景中使用，否则很容易引发并发修改异常。
3. subList 和 ArrayList 的 removeAll 等操纵大概导致错误

subList 天生的视图列表大概会在批量删除操纵中出现问题，例如调用 removeAll 方法时，subList 的行为不一致或发生异常。对于 ArrayList 的 subList，一些批量修改方法（如 removeAll、retainAll）大概会在删除视图元素后，导致 ArrayList 产生不可预料的状态，甚至引发 IndexOutOfBoundsException 等异常。
4. 推荐的安全使用方式

如果需要一个独立的子列表，可以通过 new ArrayList(originalList.subList(start, end)) 来创建一个子列表的副本，从而避免 subList 的共享视图问题：

ArrayList<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
ArrayList<Integer> subListCopy = new ArrayList<>(list.subList(1, 4)); // 创建副本
list.add(6); // 修改原列表
subListCopy.get(0); // 安全，不会受到影响

复制代码

小结

使用 ArrayList 的 subList 方法需要注意以下几点：

视图机制：subList 只是原列表的视图，修改其中一个会影响另一个。
结构性修改限制：结构性修改原列表后再访问 subList 会抛出 ConcurrentModificationException。
批量操纵问题：subList 的批量操纵大概引发不可预料的错误。
建议创建副本：如需独立操纵子列表，最好创建 subList 的副本以避免潜在问题。

审慎使用 subList 可以避免不测的错误，提高代码的健壮性。
9. 为什么禁止在 foreach 循环里进行元素的 remove/add 操纵？

在 Java 中，禁止在 foreach 循环中进行元素的 remove 或 add 操纵，主要是因为这种操纵大概导致 ConcurrentModificationException 异常，大概导致循环行为不符合预期。具体缘故起因如下：
1. ConcurrentModificationException 异常

当你在 foreach 循环中直接修改集合（例如 remove 或 add 元素），会导致并发修改问题。foreach 循环底层使用了集合的 Iterator 来遍历元素。大多数集合类（如 ArrayList、HashSet 等）都会维护一个 modCount 计数器，表示集合的结构变更次数。当你在遍历时修改集合的结构（如删除或添加元素），modCount 会发生变化，而 Iterator 会检测到这种结构性修改，从而抛出 ConcurrentModificationException 异常，防止程序在多线程情况中出现不测行为。
例如：

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
for (String s : list) {
if (s.equals("b")) {
list.remove(s); // 会抛出 ConcurrentModificationException
}
}

复制代码

在上面的代码中，foreach 循环遍历 list 时，如果删除了元素 b，它会修改 list 的结构，从而导致 Iterator 检测到并发修改，抛出异常。
2. 不可预测的行为

即使没有抛出 ConcurrentModificationException，在 foreach 循环中修改集合也会导致不可预测的行为。例如，remove 或 add 操纵会改变集合的大小和内容，大概会影响迭代的顺序或导致遗漏某些元素，甚至造成死循环或跳过某些元素。
例如：

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
for (String s : list) {
if (s.equals("b")) {
list.add("e"); // 修改集合的大小
}
System.out.println(s);
}

复制代码

在这个例子中，add 操纵会向 list 中添加一个新元素 "e"，从而修改了集合的结构。因为 foreach 循环的内部实现使用了迭代器，它大概不会考虑到修改后的新元素，导致输出顺序或遍历结果与预期不同。
3. 迭代器的 remove() 方法

如果需要在循环中删除元素，推荐使用 Iterator 显式地进行删除操纵。Iterator 提供了一个安全的 remove() 方法，可以在遍历时安全地删除元素，而不会引发 ConcurrentModificationException。
例如：

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c", "d"));
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String s = iterator.next();
if (s.equals("b")) {
iterator.remove(); // 使用 Iterator 的 remove() 方法
}
}

复制代码

使用 Iterator.remove() 可以安全地在遍历时删除元素，而不会抛出并发修改异常。
小结

在 foreach 循环中直接进行 remove 或 add 操纵是不安全的，主要有以下缘故起因：

ConcurrentModificationException：直接修改集合会触发迭代器的并发修改检测，导致异常。
不可预测的行为：修改集合的结构大概导致元素遗漏、顺序错乱或程序逻辑堕落。
使用 Iterator 替代：使用 Iterator 的 remove() 方法可以避免这些问题，实现安全的元素删除操纵。

因此，正确的做法是使用 Iterator 显式地处理元素的删除或修改，而不是直接在 foreach 循环中进行修改。
10. 为什么禁止工程师直接使用日志系统 (Log4j、Logback) 中的 API ？

在很多工程实践中，禁止工程师直接使用日志系统（如 Log4j、Logback）中的 API，主要是出于以下几个缘故起因：
1. 日志配置与实现的分离

直接使用日志系统的 API 大概会导致日志记录逻辑与应用的业务逻辑精密耦合，使得日志配置和实现的分离变得困难。现代的日志框架（如 Log4j、Logback）允许通过外部配置文件（如 log4j.xml 或 logback.xml）机动配置日志级别、输出格式、输出位置等，而不是硬编码到应用代码中。直接使用日志 API 会导致日志的配置与业务代码绑定在一起，不易修改和维护。
建议的做法：通过使用日志框架的日志抽象接口（如 org.slf4j.Logger）来记录日志，而不是直接依赖具体的日志实现。这种方式提供了更大的机动性，日志实现可以在运行时通过配置文件更换而无需修改代码。
2. 机动性与可扩展性问题

如果工程师直接使用日志库的 API，项目在需要切换日志框架（比如从 Log4j 转换到 Logback 或其他框架）时，需要修改大量的代码，增加了系统的耦合度和维护难度。另一方面，使用日志抽象层（如 SLF4J）可以避免这一问题，因为 SLF4J 是一个日志抽象层，底层可以切换具体的日志实现而无需改变业务代码。
示例：

// 不推荐：直接使用 Log4j 的 API
import org.apache.log4j.Logger;
Logger logger = Logger.getLogger(MyClass.class);
logger.info("This is a log message");
// 推荐：通过 SLF4J 接口来记录日志
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
Logger logger = LoggerFactory.getLogger(MyClass.class);
logger.info("This is a log message");

复制代码

使用 SLF4J 可以在不同的情况中机动切换日志实现，而无需修改代码。
3. 日志记录与调试不一致

如果工程师直接使用日志框架的 API，大概会在日志记录时不遵循一致的日志计谋。例如，日志的级别、格式、日志输出的内容等大概不统一，导致日志信息混乱、不易追踪。通过统一的日志抽象接口（如 SLF4J）和规范的日志记录计谋（通过 AOP 或日志框架自带的特性）可以保持日志的一致性和规范性。
最佳实践：

通过统一的日志管理类或工具类来封装日志记录方法，确保所有日志记录都遵循统一的格式和规范。
在日志中统一使用适当的日志级别（如 DEBUG、INFO、WARN、ERROR）和标准格式。

4. 日志的性能影响

日志记录大概对应用的性能产生一定的影响，尤其是在日志记录过于频仍或日志输出内容过多的情况下。通过直接使用日志框架的 API，大概无法机动控制日志输出的频率、内容或过滤计谋，从而造成性能问题。很多日志框架（如 Log4j 和 Logback）提供了高级的配置选项，如异步日志、日志缓存等特性，可以显著提高性能。
推荐做法：

使用日志框架提供的异步日志功能来提高性能。
配置适当的日志级别，避免在生产情况中输出过多的调试信息。

5. 日志管理的统一性与规范

在团队开辟中，直接使用日志框架的 API 会导致不同开辟人员在不同模块中记录日志时不遵循统一规范，导致日志格式不统一、信息不一致，甚至产生重复的日志记录。通过日志管理工具类或封装类，可以确保所有开辟人员遵循统一的日志记录计谋。
示例：

创建一个统一的 LoggerFactory 工厂类来天生日志记录对象。
统一定义日志级别和输出格式，确保日志输出一致。

小结

禁止工程师直接使用日志系统（如 Log4j、Logback）中的 API，主要是为了：

解耦日志实现与业务逻辑：通过使用日志抽象层（如 SLF4J），可以更轻松地切换日志框架，避免硬编码。
提高机动性与可维护性：避免在应用中重复使用框架 API，提高日志配置的机动性和一致性。
规范日志记录行为：通过封装日志记录，确保日志级别、格式和内容的统一，增强可读性和可追踪性。
优化性能：通过配置日志框架的高级功能（如异步日志），提高日志系统的性能，淘汰对应用的影响。
统一日志管理：避免团队成员在不同模块中使用不一致的日志记录方式，确保日志输出的标准化。

最好的做法是通过日志抽象层（如 SLF4J）进行日志记录，同时通过日志管理工具类进行统一的配置和调用，确保日志的高效、规范和机动性。
11. 为什么建议开辟者审慎使用继续？

在面向对象编程（OOP）中，继续是一种常见的代码复用方式，它允许一个类继续另一个类的属性和行为。然而，虽然继续可以提高代码的复用性，但过分或不妥使用继续大概会导致代码的复杂性增加，进而带来一些潜在的问题。因此，建议开辟者在使用继续时要审慎，以下是一些关键缘故起因：
1. 增加了类之间的耦合性

继续会导致子类和父类之间形成精密的耦合关系。子类依赖于父类的实现，这意味着如果父类发生变化，大概会影响到所有继续自该父类的子类，导致修改和维护变得更加困难。这种精密耦合关系也限制了子类的机动性，因为它必须遵循父类的接口和实现。
例子：

class Animal {
void eat() {
System.out.println("Animal is eating");
}
}
class Dog extends Animal {
@Override
void eat() {
System.out.println("Dog is eating");
}
}

复制代码

如果父类 Animal 做了改动（如修改 eat() 方法的实现），Dog 类也会受到影响。这样的耦合会增加后期维护的复杂度。
2. 破坏了封装性（Encapsulation）

继续大概破坏封装性，因为子类可以直接访问父类的成员（字段和方法），尤其是当父类成员被设置为 protected 或 public 时。这种情况大概导致子类暴露不应被外界访问的细节，破坏了数据的封装性。
例子：

class Vehicle {
protected int speed;
}
class Car extends Vehicle {
void accelerate() {
speed += 10; // 直接访问父类的 protected 字段
}
}

复制代码

在这种情况下，Car 类直接访问了父类 Vehicle 的 speed 字段，而不是通过公共接口来修改它，导致封装性低落。
3. 继续大概会导致类的条理结构不合理

继续每每会导致不合理的类条理结构，特殊是在试图通过继续来表达“是一个”（is-a）关系时，实际情况大概并不符合这种逻辑。滥用继续大概会使类之间的关系变得复杂和不直观，导致代码结构混乱。
例子：
假设我们有一个 Car 类和一个 Truck 类，都继续自 Vehicle 类。如果 Car 和 Truck 共享很多方法和属性，这样的设计大概是符合的。但是，如果 Car 和 Truck 之间差异很大，仅通过继续来构建它们的关系，大概会导致继续条理过于复杂，代码阅读和理解变得困难。
4. 继续大概导致不易发现的错误

由于子类继续了父类的行为，任何对父类的修改都有大概影响到子类的行为。更糟糕的是，错误或不一致的修改大概在父类中发生，而这些错误大概不会立即暴露出来，直到程序运行到某个特定的地方，才会显现堕落误。
例子：
假设你修改了父类的某个方法，但忘记更新或调整子类中相应的重写方法，这大概会导致难以发现的错误。
5. 继续限制了机动性（不可重用性问题）

继续创建了一个父类与子类之间的固定关系，这意味着如果你想在一个完全不同的上下文中重用一个类，你大概不能通过继续来实现。在某些情况下，组合比继续更为机动，允许你将多个行为组合到一个类中，而不是通过继续来强行构建类的条理结构。
例子：

// 组合而非继承
class Engine {
void start() {
System.out.println("Engine started");
}
}
class Car {
private Engine engine = new Engine(); // 通过组合来使用 Engine
void start() {
engine.start();
}
}

复制代码

通过组合，可以机动地使用不同的组件，而不需要继续整个类。这样做的优点是更具扩展性和机动性。
6. 继续限制了方法的重用（可维护性差）

如果你过分依赖继续，你的代码会容易受到父类实现的限制，难以机动地添加新功能或进行扩展。例如，在继续链中添加新的功能大概会导致一大堆方法的修改和重写，而不通过继续，可以更轻松地将功能作为独立模块来重用。
7. 使用接口和组合更优

相比继续，接口（Interface） 和 组合（Composition） 更符合面向对象设计的原则。接口允许类只暴露所需的功能，而不暴露实现细节，组合则允许你将多个不同的行为组合在一起，使得系统更加机动和可扩展。通过接口和组合，可以避免继续的许多问题。
推荐设计模式：

计谋模式（Strategy Pattern）：通过接口和组合来替代继续。
装饰器模式（Decorator Pattern）：使用组合和署理来扩展行为，而非通过继续。

小结

只管继续是面向对象编程中的一个重要特性，但滥用继续大概带来许多问题，特殊是在以下几个方面：

增加类之间的耦合，低落机动性；
破坏封装性，暴露不应访问的内部实现；
大概导致类条理结构复杂，增加理解和维护的难度；
限制代码的重用和扩展性。

因此，推荐优先使用组合而非继续，并尽大概使用接口来实现机动的扩展。如果必须使用继续，确保它能够清晰地表达“是一个”的关系，并避免过深的继续条理。
12. 为什么禁止开辟人员修改 serialVersionUID 字段的值？

serialVersionUID 是 Java 中用来标识序列化版本的一个静态字段。它的作用是确保在反序列化时，JVM 可以验证序列化的类与当前类的兼容性，以避免版本不兼容导致的错误。只管 serialVersionUID 可以由开辟人员手动定义，禁止开辟人员修改 serialVersionUID 字段的值 的缘故起因如下：
1. 序列化与反序列化兼容性

serialVersionUID 的主要作用是保证在序列化和反序列化过程中，类的版本兼容性。它是用来标识类的版本的，如果序列化和反序列化过程中使用的类的 serialVersionUID 不匹配，就会抛出 InvalidClassException。

不匹配的 serialVersionUID 会导致序列化的数据与当前类不兼容，导致反序列化失败。
修改 serialVersionUID 的值会改变类的版本标识，导致已序列化的数据在反序列化时不能成功读取，特殊是在类结构发生改变（例如添加或删除字段）时。

例如：

// 类的第一次版本
public class MyClass implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
// 其他字段和方法
}
// 类的第二次修改版本
public class MyClass implements Serializable {
private static final long serialVersionUID = 2L; // 修改了 serialVersionUID
private String name;
private int age; // 新增字段
// 其他字段和方法
}

复制代码

如果修改了 serialVersionUID，而之前序列化的数据是使用版本 1 的类进行序列化的，反序列化时会因为 serialVersionUID 不匹配而导致失败。
2. 避免不须要的版本辩论

Java 会根据类的字段、方法等信息自动天生 serialVersionUID，这个值是基于类的结构计算出来的。如果开辟人员修改了 serialVersionUID，大概会破坏 Java 自动天生的版本控制机制，从而导致版本控制不一致，增加了维护复杂性。
如果手动修改 serialVersionUID，容易出现以下几种问题：

由于类结构没有变化，修改 serialVersionUID 大概会导致已序列化的数据无法恢复。
如果不同的开辟人员修改了 serialVersionUID，大概会在不同的机器或系统间引起序列化不一致。

3. 影响序列化兼容性

Java 提供了两种主要的兼容性规则：

兼容性向前：如果类的字段或方法发生改变，但没有改变 serialVersionUID，则反序列化是可以工作的。
兼容性向后：如果你修改了类的结构（如字段变动、方法署名改变等），并且保持相同的 serialVersionUID，反序列化仍然可以工作。

如果不小心修改了 serialVersionUID，大概导致以下情况：

向前兼容性：新版本的类不能兼容老版本的对象，导致反序列化失败。
向后兼容性：老版本的类无法反序列化新版本的对象。

4. 自动天生 vs 手动指定

自动天生的 serialVersionUID：Java 会根据类的结构自动天生 serialVersionUID，这样如果类的结构发生变化，serialVersionUID 会自动变化，确保不兼容的版本之间不会出现不测的反序列化行为。
手动指定 serialVersionUID：手动修改 serialVersionUID 大概导致版本控制不一致，特殊是在多人开辟、分布式摆设的情况中，容易出现反序列化失败的问题。

5. 避免非预期的反序列化问题

手动修改 serialVersionUID 大概会导致数据丢失或反序列化时抛出异常。例如，如果开辟人员错误地修改了 serialVersionUID，系统在尝试反序列化时大概会因为 serialVersionUID 不匹配而无法成功加载对象，导致异常的发生。
小结

禁止开辟人员修改 serialVersionUID 字段的值，主要是为了：

确保序列化与反序列化的兼容性，避免版本不匹配导致反序列化失败。
避免不须要的版本辩论和数据丢失，特殊是在类结构修改时。
保持 Java 自动管理 serialVersionUID 的优势，保证类的版本一致性和可维护性。

如果确实需要修改 serialVersionUID，应确保修改后的版本与已经序列化的数据兼容，并遵循合理的版本管理计谋。
13. 为什么禁止开辟人员使用 isSuccess 作为变量名？

禁止开辟人员使用 isSuccess 作为变量名，主要是为了遵循更好的编程规范和提高代码的可读性、可维护性。这个变量名问题的核心在于其容易引起歧义和肴杂。具体缘故起因如下：
1. 不符合布尔值命名约定

在 Java 中，通常使用 is 或 has 开头的变量名来表示布尔值（boolean 类型）。这类命名通常遵循特定的语义约定，表示某个条件是否成立。例如：

isEnabled 表示某个功能是否启用；
hasPermission 表示是否有权限。

问题：

isSuccess 看起来像一个布尔值（boolean 类型），但它实际上大概并不直接表示一个布尔值，而是一个状态或结果。这种命名大概会导致肴杂，开辟者大概误以为它是布尔类型的变量，而实际上它大概是一个描述状态的对象、字符串大概其他类型的数据。

2. 语义不明白

isSuccess 这个名字外貌上表示“是否成功”，但是它缺少具体的上下文，导致语义不够明白。真正表示是否成功的布尔值应该直接使用 boolean 类型的变量，并且使用清晰明白的命名。
例如：

isCompleted：表示某个使命是否完成。
isSuccessful：表示某个操纵是否成功。

这些命名能更明白地表达布尔变量的寄义，避免理解上的歧义。
3. 与标准的 is 前缀肴杂

is 前缀通常用来表示“是否”某个条件成立，实用于返回布尔值的方法大概变量。isSuccess 这样的命名会让开辟人员误以为它是一个布尔值，大概一个 boolean 类型的值，但实际上它大概是一个复杂类型大概其他非布尔类型，造成不须要的肴杂。
例如：

boolean isSuccess = someMethod(); // 看起来是布尔值，但实际类型可能不同

复制代码

这种情况大概导致开辟人员产生误解，以为 isSuccess 代表的是布尔值，但它大概是某个表示成功的对象、枚举大概其他数据类型。
4. 更好的命名建议

为了避免歧义和肴杂，开辟人员应使用更加明白且符合命名规范的名称。以下是一些命名的改进建议：

如果是布尔值，命名为 isSuccessful 或 wasSuccessful。
如果是表示结果的对象，使用更具体的名称，例如 operationResult 或 statusCode，以表明它是一个描述操纵结果的变量。

5. 提升代码的可读性和可维护性

清晰且具有意义的命名能够帮助团队成员或未来的开辟者更快地理解代码的意图。如果变量名过于模糊（如 isSuccess），就大概让人对实在际寄义产生疑问，尤其是在阅读较大或复杂的代码时。良好的命名能够提升代码的可读性和可维护性。
小结

isSuccess 这样的命名不清晰，容易与布尔类型的变量产生肴杂，进而影响代码的可读性。
命名应尽量明白，避免使用容易引起歧义的名称，特殊是在布尔值类型的命名时。
建议使用更具描述性的名称，如 isSuccessful 或 wasSuccessful，更清晰地表达变量的意义。

最后

以上是 V 哥经心总结的13个 Java 编程中的小小编码问题，也是V 哥日常编码中总结的学习笔记，分享给大家，如果内容对你有帮助，请不要吝啬来个小赞呗，关注威哥爱编程，Java 路上，你我相伴前行。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

欢迎光临 qidao123.com技术社区-IT企服评测·应用市场 (https://dis.qidao123.com/)