id stringlengths 16 23 | source stringclasses 4
values | source_repo stringclasses 4
values | source_url stringclasses 4
values | doc_title stringlengths 2 42 | category stringclasses 35
values | question stringlengths 1 408 | answer stringlengths 5 26.4k | importance stringclasses 6
values | has_answer stringclasses 2
values | collected_at stringdate 2021-12-02 03:06:40 2026-07-28 12:37:33 | tags stringclasses 2
values | note stringclasses 11
values | raw_markdown stringlengths 13 28.6k | language stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
bestJavaer_00200 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 美团内推 | interview | 美团内推 | 美团内推，大佬说扫码就完了。
校招二维码
社招二维码
<img src="https://tva1.sinaimg.cn/large/008i3skNly1gt5n62cuv0j30s90z0mzu.jpg" alt="image-20210805091138018" style="zoom:50%;" /> | true | 2026-07-28T12:37:33Z | ## 美团内推
美团内推，大佬说扫码就完了。
校招二维码
社招二维码
<img src="https://tva1.sinaimg.cn/large/008i3skNly1gt5n62cuv0j30s90z0mzu.jpg" alt="image-20210805091138018" style="zoom:50%;" /> | zh | |||
bestJavaer_00201 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 腾讯内推 | interview | 腾讯云即时通信 IM 云后台开发工程师 | Base ：西安
联系人：Steven_sfp （微信）
工作职责
1、负责即时通信IM云控制台系统设计、CGI及Web后台服务程序研发；
2、负责即时通信IM云运营支持系统、质量监控系统及配置系统的研发，确保相关系统稳定可靠运行；
3、负责IM云与合作伙伴产品的集成和交付工作。
工作要求
1、本科及以上学历，扎实的计算机基本功，2 年以上 Linux 后台开发经验；
2、编程基本功力扎实，至少熟悉2门开发语言：PHP、Golang、Python，熟悉Web开发框架；
3、精通常用数据结构及算法，熟悉TCP/IP协议，socket编程，熟悉Mysql或其他大型数据库，熟悉数据库原
理和常用性能优化技术；
4、熟练掌握常见的设计模式和... | true | 2026-07-28T12:37:33Z | ## 腾讯云即时通信 IM 云后台开发工程师
Base ：西安
联系人：Steven_sfp （微信）
工作职责
1、负责即时通信IM云控制台系统设计、CGI及Web后台服务程序研发；
2、负责即时通信IM云运营支持系统、质量监控系统及配置系统的研发，确保相关系统稳定可靠运行；
3、负责IM云与合作伙伴产品的集成和交付工作。
工作要求
1、本科及以上学历，扎实的计算机基本功，2 年以上 Linux 后台开发经验；
2、编程基本功力扎实，至少熟悉2门开发语言：PHP、Golang、Python，熟悉Web开发框架；
3、精通常用数据结构及算法，熟悉TCP/IP协议，socket编程，熟悉Mysql或其他大型数据... | zh | |||
bestJavaer_00202 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 新奥内推 | interview | 岗位汇总 | 联系人：徐晓斌
手机号： 18056201250
邮箱：18056201250@189.cn
 | true | 2026-07-28T12:37:33Z | ## 岗位汇总
联系人：徐晓斌
手机号： 18056201250
邮箱：18056201250@189.cn
 | zh | |||
bestJavaer_00203 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | @SuppressWarnings 用法 | java | Idea 设置泛型检查，变量、方法未使用检查 | 从 eclipse 转换到idea 发现有很多不习惯的地方，比如说
```java
String s;
List list = new ArrayList();
```
没有未使用的变量，未检查泛型，未使用的方法提示，特意查找了一下相关资料
### 设置泛型检查
我使用的是mac电脑，windows电脑应该类似
打开如图
<img src="https://img2018.cnblogs.com/blog/1515111/201905/1515111-20190524094526617-1947420796.png" style="zoom:50%;" />
会出现如下页面
;
```
没有未使用的变量，未检查泛型，未使用的方法提示，特意查找了一下相关资料
### 设置泛型检查
我使用的是mac电脑，windows电脑应该类似
打开如图
<img src="https://img2018.cnblogs.com/blog/1515111/201905/1515111-20190524094526617-1947420796.png" style="zoom:50%;" />
会... | zh | |||
bestJavaer_00204 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 细数浅拷贝和深拷贝 | java | 关于引用 | 在 Java 中，除了**基本数据类型**（四类八种数据类型）之外，还存在引用数据类型。一般使用 `=` 号做赋值操作的时候，对于基本数据类型，实际上是拷贝的它的值，但是对于对象而言，其实赋值的只是这个对象的引用，也就是将原对象的引用传递过去，但是他们实际上还是指向的同一个对象。如下代码所示
```java
public class Food{
String name;
int num;
String taste;
constructor()
get and set()
toString()
}
```
测试类：
```java
public static void main(String[] args) {
int i1 = 10... | true | 2026-07-28T12:37:33Z | 相近问题也见于: bestJavaer | ## 关于引用
在 Java 中，除了**基本数据类型**（四类八种数据类型）之外，还存在引用数据类型。一般使用 `=` 号做赋值操作的时候，对于基本数据类型，实际上是拷贝的它的值，但是对于对象而言，其实赋值的只是这个对象的引用，也就是将原对象的引用传递过去，但是他们实际上还是指向的同一个对象。如下代码所示
```java
public class Food{
String name;
int num;
String taste;
constructor()
get and set()
toString()
}
```
测试类：
```java
public static vo... | zh | ||
bestJavaer_00205 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 细数浅拷贝和深拷贝 | java | 关于浅拷贝和深拷贝 | 浅拷贝和深拷贝其实就是在`引用`的这个基础上来做区分的，如果在拷贝的时候，只对基本数据类型进行拷贝，对引用数据类型只是进行了引用的传递，没有真正的创建一个新的对象，这种拷贝方式就认为是`浅拷贝`。反之，在对引用数据类型进行拷贝的时候，创建了一个新的对象，并且复制其内的成员变量，这种拷贝方式就被认为是`深拷贝`。
### 浅拷贝
那么如何实现`浅拷贝(Shallow copy)`呢？很简单，就是在需要拷贝的类上实现 Cloneable 接口并重写其 clone() 方法就可以了。
下面我们对 Food 类进行修改，我们让他实现 Cloneable 接口，并重写 clone() 方法。
```java
public class Food... | true | 2026-07-28T12:37:33Z | 相近问题也见于: bestJavaer | ## 关于浅拷贝和深拷贝
浅拷贝和深拷贝其实就是在`引用`的这个基础上来做区分的，如果在拷贝的时候，只对基本数据类型进行拷贝，对引用数据类型只是进行了引用的传递，没有真正的创建一个新的对象，这种拷贝方式就认为是`浅拷贝`。反之，在对引用数据类型进行拷贝的时候，创建了一个新的对象，并且复制其内的成员变量，这种拷贝方式就被认为是`深拷贝`。
### 浅拷贝
那么如何实现`浅拷贝(Shallow copy)`呢？很简单，就是在需要拷贝的类上实现 Cloneable 接口并重写其 clone() 方法就可以了。
下面我们对 Food 类进行修改，我们让他实现 Cloneable 接口，并重写 clone() 方法。
```java... | zh | ||
bestJavaer_00206 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 细数浅拷贝和深拷贝 | java | 一些说明 | 针对 Cloneable 接口，有下面三点使用说明
* 如果类实现了 Cloneable 接口，再调用 Object 的 clone() 方法**可以合法地对该类实例进行按字段复制**。
* 如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone() 方法，则会导致抛出`CloneNotSupporteddException`。
* 实现此接口的类应该使用公共方法重写 Object 的clone() 方法，因为 Object 的 clone() 方法是一个受保护的方法。
 方法**可以合法地对该类实例进行按字段复制**。
* 如果在没有实现 Cloneable 接口的实例上调用 Object 的 clone() 方法，则会导致抛出`CloneNotSupporteddException`。
* 实现此接口的类应该使用公共方法重写 Object 的clone() 方法，因为 Object 的 clone() 方法是一个受保护的方法。
工欲善其事必先利其器，让我们先来过一遍整个集合框架的组成部分：
1. 集合框架提供了两个遍历接口：`Iterator`和`ListI... | true | 2026-07-28T12:37:33Z | ## 集合框架总览
下图堪称集合框架的**上帝视角**，讲到集合框架不得不看的就是这幅图，当然，你会觉得眼花缭乱，不知如何看起，这篇文章带你一步一步地秒杀上面的每一个接口、抽象类和具体类。我们将会从最顶层的接口开始讲起，一步一步往下深入，帮助你把对集合的认知构建起一个知识网络。
工欲善其事必先利其器，让我们先来过一遍整个集合框架的组成部分：
1. 集合框架提供了两个遍历接口：`It... | zh | |||
bestJavaer_00208 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 超全Java集合框架讲解 | java | Map 集合体系详解 | `Map`接口是由`<key, value>`组成的集合，由`key`映射到**唯一**的`value`，所以`Map`不能包含重复的`key`，每个键**至多**映射一个值。下图是整个 Map 集合体系的主要组成部分，我将会按照日常使用频率从高到低一一讲解。
不得不提的是 Map 的设计理念：**定位元素**的时间复杂度优化到 `O(1)`
Map 体系下主要分为 AbstractMap 和 SortedMap两类集合
`AbstractMap`是对 Map 接口的扩展，它定义了普通的 Map 集合具有的**通用行为**，可以避免子类重复编写大量相同的代码，子类继承 AbstractMap 后可以重写它的方法，**实现额外的逻辑*... | true | 2026-07-28T12:37:33Z | ## Map 集合体系详解
`Map`接口是由`<key, value>`组成的集合，由`key`映射到**唯一**的`value`，所以`Map`不能包含重复的`key`，每个键**至多**映射一个值。下图是整个 Map 集合体系的主要组成部分，我将会按照日常使用频率从高到低一一讲解。
不得不提的是 Map 的设计理念：**定位元素**的时间复杂度优化到 `O(1)`
Map 体系下主要分为 AbstractMap 和 SortedMap两类集合
`AbstractMap`是对 Map 接口的扩展，它定义了普通的 Map 集合具有的**通用行为**，可以避免子类重复编写大量相同的代码，子类继承 AbstractMap 后可... | zh | |||
bestJavaer_00209 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 超全Java集合框架讲解 | java | Collection 集合体系详解 | Collection 集合体系的顶层接口就是`Collection`，它规定了该集合下的一系列行为约定。
该集合下可以分为三大类集合：List，Set和Queue
`Set`接口定义了该类集合**不允许存储重复**的元素，且任何操作时均需要通过**哈希函数映射**到集合内部定位元素，集合内部的元素**默认**是**无序**的。
`List`接口定义了该类集合**允许存储重复**的元素，且集合内部的元素按照元素插入的顺序**有序排列**，可以通过**索引**访问元素。
`Queue`接口定义了该类集合是以`队列`作为存储结构，所以集合内部的元素**有序排列**，仅可以操作**头结点**元素，无法访问队列中间的元素。
上面三个接口是**... | true | 2026-07-28T12:37:33Z | ## Collection 集合体系详解
Collection 集合体系的顶层接口就是`Collection`，它规定了该集合下的一系列行为约定。
该集合下可以分为三大类集合：List，Set和Queue
`Set`接口定义了该类集合**不允许存储重复**的元素，且任何操作时均需要通过**哈希函数映射**到集合内部定位元素，集合内部的元素**默认**是**无序**的。
`List`接口定义了该类集合**允许存储重复**的元素，且集合内部的元素按照元素插入的顺序**有序排列**，可以通过**索引**访问元素。
`Queue`接口定义了该类集合是以`队列`作为存储结构，所以集合内部的元素**有序排列**，仅可以操作**头结点*... | zh | |||
bestJavaer_00210 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 超全Java集合框架讲解 | java | List 接口 | List 接口和 Set 接口齐头并进，是我们日常开发中接触的很多的一种集合类型了。整个 List 集合的组成部分如下图
<img src="https://cdn.nlark.com/yuque/0/2020/png/1694029/1596123811338-4c47cdc8-bac9-4670-91ee-6d8a82159bc6.png" alt="img" style="zoom:67%;" />
`List` 接口直接继承 Collection 接口，它定义为可以存储**重复**元素的集合，并且元素按照插入顺序**有序排列**，且可以通过**索引**访问指定位置的元素。常见的实现有：ArrayList、LinkedList... | true | 2026-07-28T12:37:33Z | ## List 接口
List 接口和 Set 接口齐头并进，是我们日常开发中接触的很多的一种集合类型了。整个 List 集合的组成部分如下图
<img src="https://cdn.nlark.com/yuque/0/2020/png/1694029/1596123811338-4c47cdc8-bac9-4670-91ee-6d8a82159bc6.png" alt="img" style="zoom:67%;" />
`List` 接口直接继承 Collection 接口，它定义为可以存储**重复**元素的集合，并且元素按照插入顺序**有序排列**，且可以通过**索引**访问指定位置的元素。常见的实现有：ArrayL... | zh | |||
bestJavaer_00211 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 超全Java集合框架讲解 | java | Queue接口 | `Queue`队列，在 JDK 中有两种不同类型的集合实现：**单向队列**（AbstractQueue） 和 **双端队列**（Deque）
Queue 中提供了两套增加、删除元素的 API，当插入或删除元素失败时，会有**两种不同的失败处理策略**。
| 方法及失败策略 | 插入方法 | 删除方法 | 查找方法 |
| :------------- | :------- | :------- | --------... | true | 2026-07-28T12:37:33Z | ## Queue接口
`Queue`队列，在 JDK 中有两种不同类型的集合实现：**单向队列**（AbstractQueue） 和 **双端队列**（Deque）
Queue 中提供了两套增加、删除元素的 API，当插入或删除元素失败时，会有**两种不同的失败处理策略**。
| 方法及失败策略 | 插入方法 | 删除方法 | 查找方法 |
| :------------- | :------- | :---... | zh | |||
bestJavaer_00212 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 超全Java集合框架讲解 | java | 文末总结 | 这一篇文章对各个集合都有些`点到即止`的味道，此文的目的是对整个集合框架有一个较为整体的了解，分析了最常用的集合的相关特性，以及某些特殊集合的应用场景例如`TreeSet`、`TreeMap`这种可定制排序的集合。
- `Collection` 接口提供了整个集合框架**最通用**的增删改查以及集合自身操作的抽象方法，让子类去实现
- `Set` 接口决定了它的子类都是**无序、无重复元素**的集合，其主要实现有HashSet、TreeSet、LinkedHashSet。
- `HashSet` 底层采用 `HashMap` 实现，而 `TreeSet` 底层使用 `TreeMap` 实现，大部分 Set 集合的操作都会转换为 Ma... | true | 2026-07-28T12:37:33Z | ## 文末总结
这一篇文章对各个集合都有些`点到即止`的味道，此文的目的是对整个集合框架有一个较为整体的了解，分析了最常用的集合的相关特性，以及某些特殊集合的应用场景例如`TreeSet`、`TreeMap`这种可定制排序的集合。
- `Collection` 接口提供了整个集合框架**最通用**的增删改查以及集合自身操作的抽象方法，让子类去实现
- `Set` 接口决定了它的子类都是**无序、无重复元素**的集合，其主要实现有HashSet、TreeSet、LinkedHashSet。
- `HashSet` 底层采用 `HashMap` 实现，而 `TreeSet` 底层使用 `TreeMap` 实现，大部分 Set ... | zh | |||
bestJavaer_00213 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Comparable 和 Comparator的理解 | java | 对Comparable 的解释 | Comparable是一个排序接口
此接口给实现类提供了一个排序的方法，此接口有且只有一个方法
```java
public int compareTo(T o);
```
compareTo方法接受任意类型的参数，来进行比较
list或者数组实现了这个接口能够自动的进行排序，相关类的方法有Collections.sort()，Arrays.sort();
SortedMap 接口的key内置了compareTo方法来进行键排序，SortedSet 也是内置了compareTo方法作为其内部元素的比较手段
### compareTo()方法与equals()方法的比较
compareTo()方法不同于equals()方法，它的返回值... | true | 2026-07-28T12:37:33Z | ## 对Comparable 的解释
Comparable是一个排序接口
此接口给实现类提供了一个排序的方法，此接口有且只有一个方法
```java
public int compareTo(T o);
```
compareTo方法接受任意类型的参数，来进行比较
list或者数组实现了这个接口能够自动的进行排序，相关类的方法有Collections.sort()，Arrays.sort();
SortedMap 接口的key内置了compareTo方法来进行键排序，SortedSet 也是内置了compareTo方法作为其内部元素的比较手段
### compareTo()方法与equals()方法的比较
comp... | zh | |||
bestJavaer_00214 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Comparable 和 Comparator的理解 | java | 对Comparator 的解释 | Comparator 相当于一个比较器，作用和Comparable类似，也是使用Collections.sort() 和 Arrays.sort()来进行排序，也可以对SortedMap 和 SortedSet 的数据结构进行精准的控制，你可以不用实现此接口或者Comparable接口就可以实现次序比较。 TreeSet 和 TreeMap的数据结构底层也是使用Comparator 来实现。不同于Comparable ，比较器可以任选地允许比较null参数，同时保持要求等价关系。
### Comparator比较器的方法
```java
int compare(T o1, T o2);
```
compare() 方法的用法和Com... | true | 2026-07-28T12:37:33Z | ## 对Comparator 的解释
Comparator 相当于一个比较器，作用和Comparable类似，也是使用Collections.sort() 和 Arrays.sort()来进行排序，也可以对SortedMap 和 SortedSet 的数据结构进行精准的控制，你可以不用实现此接口或者Comparable接口就可以实现次序比较。 TreeSet 和 TreeMap的数据结构底层也是使用Comparator 来实现。不同于Comparable ，比较器可以任选地允许比较null参数，同时保持要求等价关系。
### Comparator比较器的方法
```java
int compare(T o1, T o2);
`... | zh | |||
bestJavaer_00215 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Comparable 和 Comparator的理解 | java | Comparable 和 Comparator 的对比 | 1、Comparable 更像是自然排序
2、Comparator 更像是定制排序
**同时存在时采用 Comparator（定制排序）的规则进行比较。**
对于一些普通的数据类型（比如 String, Integer, Double…），它们默认实现了Comparable 接口，实现了 compareTo 方法，我们可以直接使用。
而对于一些自定义类，它们可能在不同情况下需要实现不同的比较策略，我们可以新创建 Comparator 接口，然后使用特定的 Comparator 实现进行比较。
;
```
这段代码中，我们在堆区域中分配了一块内存，然后把 obj 对象指向了这块内存区域。
不知道你有没有看过 new 的字节码呢？下面是这段代码的字节码
;
```
这段代码中，我们在堆区域中分配了一块内存，然后把 obj 对象指向了这块内存区域。
不知道你有没有看过 new 的字节码呢？下面是这段代码的字节码
Class.forName("com.cxuan.test.User").newInstance();
// 或者使用
User user = User.class.newInstance();
```
下面我们分析一下这个字节码，其实使用第一种方式和第二种方式就差了一个 Class.forName 的字节码，这是一个静态方法，应该用的是 `invokestatic`，下面我们验证... | true | 2026-07-28T12:37:33Z | ## 使用 newInstance 方法来创建
这个`newInstance` 方法指的是 `class` 类中的方法，newInstance 方法会调用无参的构造方法创建对象。
我们可以使用 newInstance 方法创建对象，下面是使用示例代码
```java
User user = (User)Class.forName("com.cxuan.test.User").newInstance();
// 或者使用
User user = User.class.newInstance();
```
下面我们分析一下这个字节码，其实使用第一种方式和第二种方式就差了一个 Class.forName 的字节码，这是一个静态... | zh | |||
bestJavaer_00218 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 创建对象的五种方式 | java | 使用反射来创建对象 | 使用反射来创建对象其实也是使用了 newInstance 方法，只不过这个方法是 `Constructor` ，Java 反射中构造器的方法，我们可以通过这种方式来创建一个新的对象。如下代码所示
```java
Constructor<User> constructor = User.class.getConstructor();
User user = constructor.newInstance();
```
下面是它的字节码
这里解释下 ... | true | 2026-07-28T12:37:33Z | ## 使用反射来创建对象
使用反射来创建对象其实也是使用了 newInstance 方法，只不过这个方法是 `Constructor` ，Java 反射中构造器的方法，我们可以通过这种方式来创建一个新的对象。如下代码所示
```java
Constructor<User> constructor = User.class.getConstructor();
User user = constructor.newInstance();
```
下面是它的字节码
` 方法来创建，它的前提是你需要实现 Cloneable 接口并实现其定义的 clone 方法。用 clone 方法创建对象并不会调用任何构造函数。
如下代码所示
```java
Constructor<User> constructor = User.class.getConstructor();
User user = constructor.newInstance();
user.setName("cxuan");
User user2 = (User)user.clone();
System.out.println(user2.getName());
``... | true | 2026-07-28T12:37:33Z | ## 使用对象克隆来创建对象
这是第四种创建方式，使用 Cloneable 类中的 `clone()` 方法来创建，它的前提是你需要实现 Cloneable 接口并实现其定义的 clone 方法。用 clone 方法创建对象并不会调用任何构造函数。
如下代码所示
```java
Constructor<User> constructor = User.class.getConstructor();
User user = constructor.newInstance();
user.setName("cxuan");
User user2 = (User)user.clone();
System.out.println(u... | zh | |||
bestJavaer_00220 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 创建对象的五种方式 | java | 使用反序列化创建对象 | 当我们使用序列化和反序列化时，JVM 也会帮我们创建一个单独的对象。在反序列化时，JVM 创建对象不会调用任何构造函数，如下代码所示
```java
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxx"));
out.writeObject(user2);
out.close();
//Deserialization
ObjectInputStream in = new ObjectInputStream(new FileInputStream("xxx"));
User user3 = (User) in.readObject();
i... | true | 2026-07-28T12:37:33Z | ## 使用反序列化创建对象
当我们使用序列化和反序列化时，JVM 也会帮我们创建一个单独的对象。在反序列化时，JVM 创建对象不会调用任何构造函数，如下代码所示
```java
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("xxx"));
out.writeObject(user2);
out.close();
//Deserialization
ObjectInputStream in = new ObjectInputStream(new FileInputStream("xxx"));
User user3 = (User) in... | zh | |||
bestJavaer_00221 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 动态代理 | java | 代理模式 | `代理模式(Proxy Pattern)`是 23 种设计模式的一种，属于`结构型模式`。他指的是一个对象本身不做实际的操作，而是通过其他对象来得到自己想要的结果。这样做的好处是可以在**目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能**。
>这里能体现出一个非常重要的编程思想：不要随意去改源码，如果需要修改，可以通过代理的方式来扩展该方法。
<img src="/Users/mr.l/Library/Application Support/typora-user-images/image-20201216234014690.png" alt="image-20201216234014690" style="zoom... | true | 2026-07-28T12:37:33Z | 相近问题也见于: bestJavaer | ## 代理模式
`代理模式(Proxy Pattern)`是 23 种设计模式的一种，属于`结构型模式`。他指的是一个对象本身不做实际的操作，而是通过其他对象来得到自己想要的结果。这样做的好处是可以在**目标对象实现的基础上，增强额外的功能操作，即扩展目标对象的功能**。
>这里能体现出一个非常重要的编程思想：不要随意去改源码，如果需要修改，可以通过代理的方式来扩展该方法。
<img src="/Users/mr.l/Library/Application Support/typora-user-images/image-20201216234014690.png" alt="image-20201216234014690" ... | zh | ||
bestJavaer_00222 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 动态代理 | java | 静态代理 | 从编译期是否能确定最终的执行方法可以把代理模式分为静态代理和动态代理，我们先演示一下动态代理，这里有一个需求，领导想在系统中添加一个用户，但是他不自己添加，他让下面的程序员来添加，我们看一下这个过程。
首先构建一个用户接口，定义一个保存用户的模版方法。
```java
public interface UserDao {
void saveUser();
}
```
构建一个用户实现类，这个用户实现类是真正进行用户操作的方法
```java
public class UserDaoImpl implements UserDao{
@Override
public void saveUser() {
System.out.printl... | true | 2026-07-28T12:37:33Z | ## 静态代理
从编译期是否能确定最终的执行方法可以把代理模式分为静态代理和动态代理，我们先演示一下动态代理，这里有一个需求，领导想在系统中添加一个用户，但是他不自己添加，他让下面的程序员来添加，我们看一下这个过程。
首先构建一个用户接口，定义一个保存用户的模版方法。
```java
public interface UserDao {
void saveUser();
}
```
构建一个用户实现类，这个用户实现类是真正进行用户操作的方法
```java
public class UserDaoImpl implements UserDao{
@Override
public void sav... | zh | |||
bestJavaer_00223 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 动态代理 | java | 动态代理 | ### JDK 动态代理
于是乎 cxuan 上网求助，发现了一个叫做动态代理的概念，通读了一下，发现有点意思，于是乎 cxuan 修改了一下静态代理的代码，新增了一个 `UserHandler` 的用户代理，并做了一下 `test`，代码如下
```java
public class UserHandler implements InvocationHandler {
private UserDao userDao;
public UserHandler(UserDao userDao){
this.userDao = userDao;
}
@Override
public Object invoke(Object proxy, ... | true | 2026-07-28T12:37:33Z | ## 动态代理
### JDK 动态代理
于是乎 cxuan 上网求助，发现了一个叫做动态代理的概念，通读了一下，发现有点意思，于是乎 cxuan 修改了一下静态代理的代码，新增了一个 `UserHandler` 的用户代理，并做了一下 `test`，代码如下
```java
public class UserHandler implements InvocationHandler {
private UserDao userDao;
public UserHandler(UserDao userDao){
this.userDao = userDao;
}
@Overri... | zh | |||
bestJavaer_00224 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Exception 和 Error | java | 认识 Exception | `Exception` 位于 `java.lang` 包下，它是一种顶级接口，继承于 `Throwable` 类，Exception 类及其子类都是 Throwable 的组成条件，是程序出现的合理情况。
在认识 Exception 之前，有必要先了解一下什么是 `Throwable`。
### 什么是 Throwable
Throwable 类是 Java 语言中所有`错误(errors)`和`异常(exceptions)`的父类。只有继承于 Throwable 的类或者其子类才能够被抛出，还有一种方式是带有 Java 中的 `@throw` 注解的类也可以抛出。
在[Java规范](https://docs.oracle.com... | true | 2026-07-28T12:37:33Z | ## 认识 Exception
`Exception` 位于 `java.lang` 包下，它是一种顶级接口，继承于 `Throwable` 类，Exception 类及其子类都是 Throwable 的组成条件，是程序出现的合理情况。
在认识 Exception 之前，有必要先了解一下什么是 `Throwable`。
### 什么是 Throwable
Throwable 类是 Java 语言中所有`错误(errors)`和`异常(exceptions)`的父类。只有继承于 Throwable 的类或者其子类才能够被抛出，还有一种方式是带有 Java 中的 `@throw` 注解的类也可以抛出。
在[Java规范](ht... | zh | |||
bestJavaer_00225 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Exception 和 Error | java | 什么是 Error | Error 是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。这些错误是不可检查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况，比如 `OutOfMemoryError` 和 `StackOverflowError`异常的出现会有几种情况，这里需要先介绍一下 Java 内存模型 JDK1.7。
其中包括两部分，**... | true | 2026-07-28T12:37:33Z | ## 什么是 Error
Error 是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM（Java 虚拟机）出现的问题。这些错误是不可检查的，因为它们在应用程序的控制和处理能力之 外，而且绝大多数是程序运行时不允许出现的状况，比如 `OutOfMemoryError` 和 `StackOverflowError`异常的出现会有几种情况，这里需要先介绍一下 Java 内存模型 JDK1.7。
![](https://img2020.cnblogs.com/blog/1515111/202004/1515111-20200408140326181-1670569087.... | zh | |||
bestJavaer_00226 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Exception 和 Error | java | 一道经典的面试题 | 一道非常经典的面试题，**NoClassDefFoundError 和 ClassNotFoundException 有什么区别**？
在类的加载过程中， JVM 或者 ClassLoader 无法找到对应的类时，都可能会引起这两种异常/错误，由于不同的 ClassLoader 会从不同的地方加载类，有时是错误的 CLASSPATH 类路径导致的这类错误，有时是某个库的 jar 包缺失引发这类错误。NoClassDefFoundError 表示这个类在编译时期存在，但是在运行时却找不到此类，有时静态初始化块也会导致 NoClassDefFoundError 错误。
>ClassLoader 是类路径装载器，在Java 中，类路径装载... | true | 2026-07-28T12:37:33Z | ## 一道经典的面试题
一道非常经典的面试题，**NoClassDefFoundError 和 ClassNotFoundException 有什么区别**？
在类的加载过程中， JVM 或者 ClassLoader 无法找到对应的类时，都可能会引起这两种异常/错误，由于不同的 ClassLoader 会从不同的地方加载类，有时是错误的 CLASSPATH 类路径导致的这类错误，有时是某个库的 jar 包缺失引发这类错误。NoClassDefFoundError 表示这个类在编译时期存在，但是在运行时却找不到此类，有时静态初始化块也会导致 NoClassDefFoundError 错误。
>ClassLoader 是类路径装载... | zh | |||
bestJavaer_00227 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 深入理解 final、finally 和 finalize 关键字 | java | final、finally 和 finalize | 我相信在座的各位都是资深程序员，final 这种基础关键字就不用多说了。不过，还是要照顾一下小白读者，毕竟我们都是从小白走过来的嘛。
### final 修饰类、属性和方法
`final` 可以用来修饰类，final 修饰的类不允许其他类继承，也就是说，final 修饰的类是独一无二的。如下所示
<img src="https://s1.ax1x.com/2020/11/02/BBZFfO.png" alt="final002" border="0">
我们首先定义了一个 FinalUsage 类，它使用 final 修饰，同时我们又定义了一个 FinalUsageExtend 类，它想要`继承(extend)` FinalUsag... | true | 2026-07-28T12:37:33Z | ## final、finally 和 finalize
我相信在座的各位都是资深程序员，final 这种基础关键字就不用多说了。不过，还是要照顾一下小白读者，毕竟我们都是从小白走过来的嘛。
### final 修饰类、属性和方法
`final` 可以用来修饰类，final 修饰的类不允许其他类继承，也就是说，final 修饰的类是独一无二的。如下所示
<img src="https://s1.ax1x.com/2020/11/02/BBZFfO.png" alt="final002" border="0">
我们首先定义了一个 FinalUsage 类，它使用 final 修饰，同时我们又定义了一个 FinalUsageE... | zh | |||
bestJavaer_00228 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 深入理解 final、finally 和 finalize 关键字 | java | 深入理解 final 、finally 和 finalize | ### final 设计
许多编程语言都会有某种方法来告知编译器，某一块数据是恒定不变的。有时候恒定不变的数据很有用，比如
* 一个永不改变的编译期常量 。例如 **static final int num = 1024**
* 一个运行时被初始化的值，而且你不希望改变它
final 的设计会和 `abstract` 的设计产生冲突，因为 abstract 关键字主要修饰`抽象类`，而抽象类需要被具体的类所实现。final 表示禁止继承，也就不会存在被实现的问题。因为只有继承后，子类才可以实现父类的方法。
类中的所有 `private` 都隐式的指定为 `final` 的，在 private 修饰的代码中使用 final 并没有额外... | true | 2026-07-28T12:37:33Z | ## 深入理解 final 、finally 和 finalize
### final 设计
许多编程语言都会有某种方法来告知编译器，某一块数据是恒定不变的。有时候恒定不变的数据很有用，比如
* 一个永不改变的编译期常量 。例如 **static final int num = 1024**
* 一个运行时被初始化的值，而且你不希望改变它
final 的设计会和 `abstract` 的设计产生冲突，因为 abstract 关键字主要修饰`抽象类`，而抽象类需要被具体的类所实现。final 表示禁止继承，也就不会存在被实现的问题。因为只有继承后，子类才可以实现父类的方法。
类中的所有 `private` 都隐式的指定为 `... | zh | |||
bestJavaer_00229 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | for 、foreach 、iterator 三种遍历方式的比较 | java | for 、foreach 、iterator 三种遍历方式的比较 | ### 习惯用法
**for、foreach循环、iterator迭代器**都是我们常用的一种遍历方式，你可以用它来遍历任何东西：包括数组、集合等
for 惯用法：
```java
List<String> list = new ArrayList<String>();
String[] arr = new String[]{"1,2,3,4"};
for(int i = 0;i < arr.length;i++){
System.out.println(arr[i]);
}
for(int i = 0;i < list.size();i++){
System.out.println(list.get(i));
}
```
fore... | true | 2026-07-28T12:37:33Z | ## for 、foreach 、iterator 三种遍历方式的比较
* [for 、foreach 、iterator 三种遍历方式的比较](#for-foreach-iterator-三种遍历方式的比较)
* [习惯用法](#习惯用法)
* [速度对比](#速度对比)
* [remove操作三种遍历方式的影响](#remove操作三种遍历方式的影响)
* [for循环的remove](#for循环的remove)
* [foreach 中的remove](#foreach-中的remove)
* [Iterator迭代器的remove]... | zh | |||
bestJavaer_00230 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 看完这篇 HashMap，和面试官扯皮就没问题了 | java | HashMap 概述 | **如果你没有时间细抠本文，可以直接看 HashMap 概述，能让你对 HashMap 有个大致的了解**。
HashMap 是 Map 接口的实现，HashMap 允许空的 key-value 键值对，HashMap 被认为是 Hashtable 的增强版，HashMap 是一个非线程安全的容器，如果想构造线程安全的 Map 考虑使用 ConcurrentHashMap。HashMap 是无序的，因为 HashMap 无法保证内部存储的键值对的有序性。
HashMap 的底层数据结构是数组 + 链表的集合体，数组在 HashMap 中又被称为`桶(bucket)`。遍历 HashMap 需要的时间损耗为 HashMap 实例桶的数... | true | 2026-07-28T12:37:33Z | ## HashMap 概述
**如果你没有时间细抠本文，可以直接看 HashMap 概述，能让你对 HashMap 有个大致的了解**。
HashMap 是 Map 接口的实现，HashMap 允许空的 key-value 键值对，HashMap 被认为是 Hashtable 的增强版，HashMap 是一个非线程安全的容器，如果想构造线程安全的 Map 考虑使用 ConcurrentHashMap。HashMap 是无序的，因为 HashMap 无法保证内部存储的键值对的有序性。
HashMap 的底层数据结构是数组 + 链表的集合体，数组在 HashMap 中又被称为`桶(bucket)`。遍历 HashMap 需要的时间... | zh | |||
bestJavaer_00231 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 看完这篇 HashMap，和面试官扯皮就没问题了 | java | HashMap 和 HashTable 的区别 | 我们上面介绍了一下 HashMap ，现在来介绍一下 HashTable
### 相同点
HashMap 和 HashTable 都是基于哈希表实现的，其内部每个元素都是 `key-value` 键值对，HashMap 和 HashTable 都实现了 Map、Cloneable、Serializable 接口。
### 不同点
* 父类不同：HashMap 继承了 `AbstractMap` 类，而 HashTable 继承了 `Dictionary` 类
最主要的三个类(接口)就是 `HashMap`,`AbstractMap`和 `Map` 了，HashMap 我们上面已经在概述中简单介绍了一下，下面来介绍一下 AbstractMap。
### AbstractMap 类
这个抽象类是 Map 接口的骨干实现，以求最大化的减少实现类的工作量。为了实现不可修改的 map，程序员仅需要继承这个类并且提供 entrySet 方法的... | true | 2026-07-28T12:37:33Z | ## HashMap 底层结构
要了解一个类，先要了解这个类的结构，先来看一下 HashMap 的结构：
最主要的三个类(接口)就是 `HashMap`,`AbstractMap`和 `Map` 了，HashMap 我们上面已经在概述中简单介绍了一下，下面来介绍一下 AbstractMap。
### AbstractMap 类
这个抽象类是 Map 接口的骨干实现，以求最大化的减少实现类的工作量。为了实现不可修改的 map，程序员仅需要继... | zh | |||
bestJavaer_00234 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 看完这篇 HashMap，和面试官扯皮就没问题了 | java | 关于 HashMap 的面试题 | ### HashMap 的数据结构
JDK1.7 中，HashMap 采用`位桶 + 链表`的实现，即使用`链表`来处理冲突，同一 hash 值的链表都存储在一个数组中。但是当位于一个桶中的元素较多，即 hash 值相等的元素较多时，通过 key 值依次查找的效率较低。
所以，与 JDK 1.7 相比，JDK 1.8 在底层结构方面做了一些改变，当每个桶中元素大于 8 的时候，会转变为红黑树，目的就是优化查询效率。
### HashMap 的 put 过程
大致过程如下，首先会使用 hash 方法计算对象的哈希码，根据哈希码来确定在 bucket 中存放的位置，如果 bucket 中没有 Node 节点则直接进行 put，如果对应 ... | true | 2026-07-28T12:37:33Z | ## 关于 HashMap 的面试题
### HashMap 的数据结构
JDK1.7 中，HashMap 采用`位桶 + 链表`的实现，即使用`链表`来处理冲突，同一 hash 值的链表都存储在一个数组中。但是当位于一个桶中的元素较多，即 hash 值相等的元素较多时，通过 key 值依次查找的效率较低。
所以，与 JDK 1.7 相比，JDK 1.8 在底层结构方面做了一些改变，当每个桶中元素大于 8 的时候，会转变为红黑树，目的就是优化查询效率。
### HashMap 的 put 过程
大致过程如下，首先会使用 hash 方法计算对象的哈希码，根据哈希码来确定在 bucket 中存放的位置，如果 bucket 中没... | zh | |||
bestJavaer_00235 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 错误一：Array 转换成 ArrayList | Array 转换成 ArrayList 还能出错？这是哪个笨。。。。。。
等等，你先别着急说，先来看看是怎么回事。
如果要将数组转换为 ArrayList，我们一般的做法会是这样
```java
List<String> list = Arrays.asList(arr);
```
Arrays.asList() 将返回一个 ArrayList，它是 Arrays 中的私有静态类，它不是 java.util.ArrayList 类。如下图所示
A... | true | 2026-07-28T12:37:33Z | ## 错误一：Array 转换成 ArrayList
Array 转换成 ArrayList 还能出错？这是哪个笨。。。。。。
等等，你先别着急说，先来看看是怎么回事。
如果要将数组转换为 ArrayList，我们一般的做法会是这样
```java
List<String> list = Arrays.asList(arr);
```
Arrays.asList() 将返回一个 ArrayList，它是 Arrays 中的私有静态类，它不是 java.util.ArrayList 类。如下图所示
);
return set.contains(targetValue);
```
这段代码虽然没错，但是有额外的性能损耗，正常情况下，不用将其再转换为 *set*，直接这么做就好了：
```java
return Arrays.asList(arr).contains(targetValue);
```
或者使用下面这种方式（穷举法，循环判断）
```java
for(String s: arr){
if(s.equals(targetValue))
re... | true | 2026-07-28T12:37:33Z | ## 错误二：检查数组是否包含某个值
检查数组中是否包含某个值，部分程序员经常会这么做：
```java
Set<String> set = new HashSet<String>(Arrays.asList(arr));
return set.contains(targetValue);
```
这段代码虽然没错，但是有额外的性能损耗，正常情况下，不用将其再转换为 *set*，直接这么做就好了：
```java
return Arrays.asList(arr).contains(targetValue);
```
或者使用下面这种方式（穷举法，循环判断）
```java
for(String s: arr){
if... | zh | |||
bestJavaer_00237 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 错误三：在 List 中循环删除元素 | <img src="https://tva1.sinaimg.cn/large/008i3skNly1gv5dh9519ij60fc0aggly02.jpg" alt="image-20211006101709155" style="zoom:50%;" />
说到底，为什么不能这么做（集合内删除元素）呢？且看下面代码
```java
ArrayList<String> list = new ArrayList<String>(Arrays.asList("a", "b", "c", "d"));
for (int i = 0; i < list.size(); i++) {
list.remove(i);
}
System.out... | true | 2026-07-28T12:37:33Z | ## 错误三：在 List 中循环删除元素
这个错误我相信很多小伙伴都知道了，在循环中删除元素是个禁忌，有段时间内我在审查代码的时候就喜欢看团队的其他小伙伴有没有犯这个错误。
<img src="https://tva1.sinaimg.cn/large/008i3skNly1gv5dh9519ij60fc0aggly02.jpg" alt="image-20211006101709155" style="zoom:50%;" />
说到底，为什么不能这么做（集合内删除元素）呢？且看下面代码
```java
ArrayList<String> list = new ArrayList<String>(Arrays.asLis... | zh | |||
bestJavaer_00238 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 错误四：Hashtable 和 HashMap | 这是一条算法方面的规约：按照算法的约定，Hashtable 是数据结构的名称，但是在 Java 中，数据结构的名称是 HashMap，Hashtable 和 HashMap 的主要区别之一就是 Hashtable 是同步的，所以很多时候你不需要 Hashtable ，而是使用 HashMap。 | true | 2026-07-28T12:37:33Z | ## 错误四：Hashtable 和 HashMap
这是一条算法方面的规约：按照算法的约定，Hashtable 是数据结构的名称，但是在 Java 中，数据结构的名称是 HashMap，Hashtable 和 HashMap 的主要区别之一就是 Hashtable 是同步的，所以很多时候你不需要 Hashtable ，而是使用 HashMap。 | zh | |||
bestJavaer_00239 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 错误五：使用原始类型的集合 | 这是一条泛型方面的约束：
在 Java 中，原始类型和无界通配符类型很容易混合在一起。以 Set 为例，Set 是原始类型，而 Set<?> 是无界通配符类型。
比如下面使用原始类型 List 作为参数的代码：
```java
public static void add(List list, Object o){
list.add(o);
}
public static void main(String[] args){
List<String> list = new ArrayList<String>();
add(list, 10);
String s = list.get(0);
}
```
这段代码会抛出 *java.la... | true | 2026-07-28T12:37:33Z | ## 错误五：使用原始类型的集合
这是一条泛型方面的约束：
在 Java 中，原始类型和无界通配符类型很容易混合在一起。以 Set 为例，Set 是原始类型，而 Set<?> 是无界通配符类型。
比如下面使用原始类型 List 作为参数的代码：
```java
public static void add(List list, Object o){
list.add(o);
}
public static void main(String[] args){
List<String> list = new ArrayList<String>();
add(list, 10);
String s = list.get(0... | zh | |||
bestJavaer_00240 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 错误六：访问级别问题 | 我相信大部分开发在设计 class 或者成员变量的时候，都会简单粗暴的直接声明 *public xxx*，这是一种糟糕的设计，声明为 public 就很容易赤身裸体，这样对于类或者成员变量来说，都存在一定危险性。 | true | 2026-07-28T12:37:33Z | ## 错误六：访问级别问题
我相信大部分开发在设计 class 或者成员变量的时候，都会简单粗暴的直接声明 *public xxx*，这是一种糟糕的设计，声明为 public 就很容易赤身裸体，这样对于类或者成员变量来说，都存在一定危险性。 | zh | |||
bestJavaer_00241 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 错误七：ArrayList 和 LinkedList | 哈哈哈，ArrayList 是我见过程序员使用频次最高的工具类，没有之一。
<img src="https://tva1.sinaimg.cn/large/008i3skNly1gv5p07snopj60j70j90ve02.jpg" alt="image-20211006165557687" style="zoom:50%;" />
当开发人员不知道 ArrayList 和 LinkedList 的区别时，他们经常使用 ArrayList（其实实际上，就算知道他们的区别，他们也不用 LinkedList，因为这点性能不值一提），因为看起来 ArrayList 更熟悉。。。。。。
但是实际上，ArrayList 和 LinkedLi... | true | 2026-07-28T12:37:33Z | ## 错误七：ArrayList 和 LinkedList
哈哈哈，ArrayList 是我见过程序员使用频次最高的工具类，没有之一。
<img src="https://tva1.sinaimg.cn/large/008i3skNly1gv5p07snopj60j70j90ve02.jpg" alt="image-20211006165557687" style="zoom:50%;" />
当开发人员不知道 ArrayList 和 LinkedList 的区别时，他们经常使用 ArrayList（其实实际上，就算知道他们的区别，他们也不用 LinkedList，因为这点性能不值一提），因为看起来 ArrayList 更熟悉... | zh | |||
bestJavaer_00242 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 错误八：可变和不可变 | 不可变对象有很多优点，比如简单、安全等。但是不可变对象需要为每个不同的值分配一个单独的对象，对象不具备**复用性**，如果这类对象过多可能会导致垃圾回收的成本很高。在可变和不可变之间进行选择时需要有一个平衡。
一般来说，可变对象用于避免产生过多的中间对象。 比如你要连接大量字符串。 如果你使用一个不可变的字符串，你会产生很多可以立即进行垃圾回收的对象。 这会浪费 CPU 的时间和精力，使用可变对象是正确的解决方案（例如 StringBuilder）。如下代码所示：
```java
String result="";
for(String s: arr){
result = result + s;
}
```
所以，正确选择可变对象还... | true | 2026-07-28T12:37:33Z | ## 错误八：可变和不可变
不可变对象有很多优点，比如简单、安全等。但是不可变对象需要为每个不同的值分配一个单独的对象，对象不具备**复用性**，如果这类对象过多可能会导致垃圾回收的成本很高。在可变和不可变之间进行选择时需要有一个平衡。
一般来说，可变对象用于避免产生过多的中间对象。 比如你要连接大量字符串。 如果你使用一个不可变的字符串，你会产生很多可以立即进行垃圾回收的对象。 这会浪费 CPU 的时间和精力，使用可变对象是正确的解决方案（例如 StringBuilder）。如下代码所示：
```java
String result="";
for(String s: arr){
result = result + s;
... | zh | |||
bestJavaer_00243 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 错误九：构造函数 | 首先看一段代码，分析为什么会编译不通过？
发生此编译错误是因为未定义默认 Super 的构造函数。 在 Java 中，如果一个类没有定义构造函数，编译器会默认为该类插入一个默认的无参数构造函数。 如果在 Super 类中定义了构造函数，在这种情况下 Super(String s)，编译器将不会插入默认的无参数构造函数。 这就是上面 Super 类的情况。
要想解决这个问题，只需要在 Super 中添加一个无参数的构造函数即可。
```java... | true | 2026-07-28T12:37:33Z | ## 错误九：构造函数
首先看一段代码，分析为什么会编译不通过？
发生此编译错误是因为未定义默认 Super 的构造函数。 在 Java 中，如果一个类没有定义构造函数，编译器会默认为该类插入一个默认的无参数构造函数。 如果在 Super 类中定义了构造函数，在这种情况下 Super(String s)，编译器将不会插入默认的无参数构造函数。 这就是上面 Super 类的情况。
要想解决这个问题，只需要在 Super 中添加一个无参数... | zh | |||
bestJavaer_00244 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 错误十：到底是使用 "" 还是构造函数 | 考虑下面代码：
```java
String x = "abc";
String y = new String("abc");
```
上面这两段代码有什么区别吗？
可能下面这段代码会给出你回答
```java
String a = "abcd";
String b = "abcd";
System.out.println(a == b); // True
System.out.println(a.equals(b)); // True
String c = new String("abcd");
String d = new String("abcd");
System.out.println(c == d); // Fals... | true | 2026-07-28T12:37:33Z | ## 错误十：到底是使用 "" 还是构造函数
考虑下面代码：
```java
String x = "abc";
String y = new String("abc");
```
上面这两段代码有什么区别吗？
可能下面这段代码会给出你回答
```java
String a = "abcd";
String b = "abcd";
System.out.println(a == b); // True
System.out.println(a.equals(b)); // True
String c = new String("abcd");
String d = new String("abcd");
System... | zh | |||
bestJavaer_00245 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 开发最容易犯的 10 个错误 | java | 最后 | cxuan 写了六本 PDF，全网下载量已经 10w + ，每本都非常硬核，你可以关注下方公众号在后台回复「cxuan」即可领取。
 | true | 2026-07-28T12:37:33Z | 相近问题也见于: bestJavaer | ## 最后
cxuan 写了六本 PDF，全网下载量已经 10w + ，每本都非常硬核，你可以关注下方公众号在后台回复「cxuan」即可领取。
 | zh | ||
bestJavaer_00246 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | 传统的 BIO | Java IO流是一个庞大的生态环境，其内部提供了很多不同的**输入流和输出流**，细分下去还有字节流和字符流，甚至还有**缓冲流**提高 IO 性能，转换流将字节流转换为字符流······看到这些就已经对 IO 产生恐惧了，在日常开发中少不了对文件的 IO 操作，虽然 apache 已经提供了 `Commons IO` 这种封装好的组件，但面对特殊场景时，我们仍需要自己去封装一个高性能的文件 IO 工具类，本文将会解析 Java IO 中涉及到的各个类，以及讲解如何正确、高效地使用它们。 | true | 2026-07-28T12:37:33Z | ## 传统的 BIO
Java IO流是一个庞大的生态环境，其内部提供了很多不同的**输入流和输出流**，细分下去还有字节流和字符流，甚至还有**缓冲流**提高 IO 性能，转换流将字节流转换为字符流······看到这些就已经对 IO 产生恐惧了，在日常开发中少不了对文件的 IO 操作，虽然 apache 已经提供了 `Commons IO` 这种封装好的组件，但面对特殊场景时，我们仍需要自己去封装一个高性能的文件 IO 工具类，本文将会解析 Java IO 中涉及到的各个类，以及讲解如何正确、高效地使用它们。 | zh | |||
bestJavaer_00247 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | BIO NIO 和 AIO 的区别 | 我们会以一个经典的**烧开水**的例子通俗地讲解它们之间的区别
| 类型 | 烧开水 |
| :--: | :----------------------------------------------------------: |
| BIO | 一直监测着某个水壶，该水壶烧开水后再监测下一个水壶 |
| NIO | 每隔一段时间就看看所有水壶的状态，哪个水壶烧开水就去处理哪个水壶 |
| AIO | 不用监测水壶，每个水壶烧开水后都会主动通知线程说：“我的水烧开了，来处理我吧” |
**BIO (... | true | 2026-07-28T12:37:33Z | ## BIO NIO 和 AIO 的区别
我们会以一个经典的**烧开水**的例子通俗地讲解它们之间的区别
| 类型 | 烧开水 |
| :--: | :----------------------------------------------------------: |
| BIO | 一直监测着某个水壶，该水壶烧开水后再监测下一个水壶 |
| NIO | 每隔一段时间就看看所有水壶的状态，哪个水壶烧开水就去处理哪个水壶 |
| AIO | 不用监测水壶，每个水壶烧开水后都会主动通知线程说：“... | zh | |||
bestJavaer_00248 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | 什么是流 | 知识科普：我们知道任何一个文件都是以**二进制**形式存在于设备中，计算机就只有 `0` 和 `1`，你能看见的东西全部都是由这两个数字组成，你看这篇文章时，这篇文章也是由01组成，只不过这些二进制串经过各种转换演变成一个个文字、一张张图片跃然屏幕上。
而**流**就是将这些二进制串在各种设备之间进行传输，如果你觉得有些抽象，我举个例子就会好理解一些：
> 下图是一张图片，它由01串组成，我们可以通过程序把一张图片拷贝到一个文件夹中，
>
> 把图片转化成二进制数据集，把数据一点一点地传递到文件夹中 , 类似于水的流动 , 这样整体的数据就是一个数据流
图示中的硬盘只是其中一种设备，还有非常多的设备都可以应用在IO流中，例如：打印机、硬盘、显示器、手机······
根据**处理数据的基本单位**不同分类：字节流 和 字符流
- 字节流：以**字节（8 bit）**为单位做数据的传输
- 字符流：以**字符**为单位（1字符 =... | true | 2026-07-28T12:37:33Z | ## 流的分类
根据**数据流向**不同分类：输入流 和 输出流
- **输入流**：从磁盘或者其它设备中将数据输入到进程中
- **输出流**：将进程中的数据输出到磁盘或其它设备上保存
图示中的硬盘只是其中一种设备，还有非常多的设备都可以应用在IO流中，例如：打印机、硬盘、显示器、手机······
根据**处理数据的基本单位**不同分类：字节流 和 字符流
- 字节流：以**字节（8 bit）**为单位做数据的传输
- 字符流：以*... | zh | |||
bestJavaer_00250 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | 节点流和处理流 | 在这里需要额外插入一个小节讲解节点流和处理流。
- **节点流**：节点流是**真正传输数据**的流对象，用于向特定的一个地方（节点）读写数据，称为节点流。例如 FileInputStream
- **处理流**：处理流是**对节点流的封装**，使用外层的处理流读写数据，本质上是利用节点流的功能，外层的处理流可以提供额外的功能。处理流的基类都是以 `Filter` 开头。
上图将 `ByteArrayInputStream` 封装成 `Dat... | true | 2026-07-28T12:37:33Z | ## 节点流和处理流
在这里需要额外插入一个小节讲解节点流和处理流。
- **节点流**：节点流是**真正传输数据**的流对象，用于向特定的一个地方（节点）读写数据，称为节点流。例如 FileInputStream
- **处理流**：处理流是**对节点流的封装**，使用外层的处理流读写数据，本质上是利用节点流的功能，外层的处理流可以提供额外的功能。处理流的基类都是以 `Filter` 开头。
上图将 `ByteArrayInputS... | zh | |||
bestJavaer_00251 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | Java IO 的核心类 File | Java 提供了 File类，它指向计算机操作系统中的文件和目录，通过该类只能访问文件和目录，无法访问内容。 它内部主要提供了 `3` 种操作：
- **访问文件的属性**：绝对路径、相对路径、文件名······
- **文件检测**：是否文件、是否目录、文件是否存在、文件的读/写/执行权限······
- **操作文件**：创建目录、创建文件、删除文件······
上面举例的操作都是在开发中非常常用的，File 类远不止这些操作，更多的操作可以直接去 API 文档中根据需求查找。
访问文件的属性：
| API | 功能 ... | true | 2026-07-28T12:37:33Z | ## Java IO 的核心类 File
Java 提供了 File类，它指向计算机操作系统中的文件和目录，通过该类只能访问文件和目录，无法访问内容。 它内部主要提供了 `3` 种操作：
- **访问文件的属性**：绝对路径、相对路径、文件名······
- **文件检测**：是否文件、是否目录、文件是否存在、文件的读/写/执行权限······
- **操作文件**：创建目录、创建文件、删除文件······
上面举例的操作都是在开发中非常常用的，File 类远不止这些操作，更多的操作可以直接去 API 文档中根据需求查找。
访问文件的属性：
| API | ... | zh | |||
bestJavaer_00252 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | Java IO 流对象 | 回顾流的分类有2种：
- 根据**数据流向**分为输入流和输出流
- 根据**数据类型**分为字节流和字符流
所以，本小节将以字节流和字符流作为主要分割点，在其内部再细分为输入流和输出流进行讲解。
### 字节流对象
字节流对象大部分输入流和输出流都是**成双成对地出现**，所以学习的时候可以将输入流和输出流一一对应的流对象关联起来，输入流和输出流只是**数据流向**不同，而**处理数据的方式**可以是相同的。
注意不要认为用什么流读入数据，就需... | true | 2026-07-28T12:37:33Z | ## Java IO 流对象
回顾流的分类有2种：
- 根据**数据流向**分为输入流和输出流
- 根据**数据类型**分为字节流和字符流
所以，本小节将以字节流和字符流作为主要分割点，在其内部再细分为输入流和输出流进行讲解。
### 字节流对象
字节流对象大部分输入流和输出流都是**成双成对地出现**，所以学习的时候可以将输入流和输出流一一对应的流对象关联起来，输入流和输出流只是**数据流向**不同，而**处理数据的方式**可以是相... | zh | |||
bestJavaer_00253 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | 字节流与字符流的转换 | 从任何地方把数据读入到内存都是先以**字节流**形式读取，即使是使用字符流去读取数据，依然成立，因为数据永远是以字节的形式存在于互联网和硬件设备中，字符流是通过**字符集**的映射，才能够将字节转换为字符。
所以 Java 提供了两种转换流：
- InputStreamReader：从**字节流转换为字符流**，将字节数据转换为字符数据读入到内存
- OutputStreamWriter：从**字符流转换为字节流**，将字符数据转换为字节数据写出到指定位置
> 了解了 Java 传统的 BIO 中字符流和字节流的主要成员之后，至少要掌握以下两个关键点：
>
> （1）传统的 BIO 是以`流`为基本单位处理数据的，想象成水流，一点点... | true | 2026-07-28T12:37:33Z | ## 字节流与字符流的转换
从任何地方把数据读入到内存都是先以**字节流**形式读取，即使是使用字符流去读取数据，依然成立，因为数据永远是以字节的形式存在于互联网和硬件设备中，字符流是通过**字符集**的映射，才能够将字节转换为字符。
所以 Java 提供了两种转换流：
- InputStreamReader：从**字节流转换为字符流**，将字节数据转换为字符数据读入到内存
- OutputStreamWriter：从**字符流转换为字节流**，将字符数据转换为字节数据写出到指定位置
> 了解了 Java 传统的 BIO 中字符流和字节流的主要成员之后，至少要掌握以下两个关键点：
>
> （1）传统的 BIO 是以`流`为基... | zh | |||
bestJavaer_00254 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | 新潮的 NIO | 我们来看看 BIO 和 NIO 的区别，BIO 是**面向流**的 IO，它建立的通道都是**单向**的，所以输入和输出流的通道不相同，必须建立2个通道，通道内的都是传输==0101001···==的字节数据。
而在 NIO 中，不再是面向流的 IO 了，而是面向**缓冲区**，它会建立一个**通道（Channel）**，该通道我们可以理解为**铁路**，该铁路上可以运输各种货物，而通道上会有一个**缓冲区（Buffer）**用于存储真正的数据，... | true | 2026-07-28T12:37:33Z | ## 新潮的 NIO
我们来看看 BIO 和 NIO 的区别，BIO 是**面向流**的 IO，它建立的通道都是**单向**的，所以输入和输出流的通道不相同，必须建立2个通道，通道内的都是传输==0101001···==的字节数据。
而在 NIO 中，不再是面向流的 IO 了，而是面向**缓冲区**，它会建立一个**通道（Channel）**，该通道我们可以理解为**铁路**，该铁路上可以运输各种货物，而通道上会有一个**缓冲区（Buffe... | zh | |||
bestJavaer_00255 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | 缓冲区（Buffer） | 缓冲区是**存储数据**的区域，在 Java 中，缓冲区就是数组，为了可以操作不同数据类型的数据，Java 提供了许多不同类型的缓冲区，**除了布尔类型以外**，其它基本数据类型都有对应的缓冲区数组对象。
> 为什么没有布尔类型的缓冲区呢？
>
> 在 Java 中，boolean 类型数据只占用 `1 bit`，而在 IO 传输过程中，都是以字节为单位进行传输的，所以 boolean 的 1 bit 完全可以使用 byte 类型的某一位，或者 ... | true | 2026-07-28T12:37:33Z | ## 缓冲区（Buffer）
缓冲区是**存储数据**的区域，在 Java 中，缓冲区就是数组，为了可以操作不同数据类型的数据，Java 提供了许多不同类型的缓冲区，**除了布尔类型以外**，其它基本数据类型都有对应的缓冲区数组对象。
> 为什么没有布尔类型的缓冲区呢？
>
> 在 Java 中，boolean 类型数据只占用 `1 bit`，而在 IO 传输过程中，都是以字节为单位进行传输的，所以 boolean 的 1 bit 完全可以... | zh | |||
bestJavaer_00256 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | 通道（Channel） | 上面我们介绍过，通道是作为一种连接资源，作用是传输数据，而真正存储数据的是缓冲区，所以介绍完缓冲区后，我们来学习通道这一块。
通道是可以**双向读写**的，传统的 BIO 需要使用输入/输出流表示数据的流向，在 NIO 中可以减少通道资源的消耗。
通道类都保存在 `java.nio.channels` 包下，我们日常用到的几个重要的类有 4 个：
| IO 通道类型 | 具体类 ... | true | 2026-07-28T12:37:33Z | ## 通道（Channel）
上面我们介绍过，通道是作为一种连接资源，作用是传输数据，而真正存储数据的是缓冲区，所以介绍完缓冲区后，我们来学习通道这一块。
通道是可以**双向读写**的，传统的 BIO 需要使用输入/输出流表示数据的流向，在 NIO 中可以减少通道资源的消耗。
通道类都保存在 `java.nio.channels` 包下，我们日常用到的几个重要的类有 4 个：
| IO 通道类型 | ... | zh | |||
bestJavaer_00257 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java IO 体系 | java | 选择器（Selectors） | 选择器是提升 IO 性能的灵魂之一，它底层利用了**多路复用 IO**机制，让选择器可以监听多个 IO 连接，根据 IO 的状态响应到服务器端进行处理。通俗地说：**选择器可以监听多个 IO 连接，而传统的 BIO 每个 IO 连接都需要有一个线程去监听和处理。**
图中很明显的显示了在 BIO 中，每个 Socket 都需要有一个专门的线程去处理每个请求，而在 NIO 中，只需要一个 Selector 即可监听各个 Socket 请求，而且 S... | true | 2026-07-28T12:37:33Z | ## 选择器（Selectors）
选择器是提升 IO 性能的灵魂之一，它底层利用了**多路复用 IO**机制，让选择器可以监听多个 IO 连接，根据 IO 的状态响应到服务器端进行处理。通俗地说：**选择器可以监听多个 IO 连接，而传统的 BIO 每个 IO 连接都需要有一个线程去监听和处理。**
图中很明显的显示了在 BIO 中，每个 Socket 都需要有一个专门的线程去处理每个请求，而在 NIO 中，只需要一个 Selector ... | zh | |||
bestJavaer_00258 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 代理 | java | 静态代理与动态代理 | 你是否会有我一样的疑惑：代理为什么还要分静态和动态的？它们两个有啥不同吗？
很明显，所有人都会有这样的疑惑，我们先来看看它们的相同点：
- 都能够实现代理模式（这不废话吗...）
- 无论是静态代理还是动态代理，代理对象和目标对象都需要实现一个**公共接口**
重点当然是它们的不同之处，动态代理在静态代理的基础上做了改进，极大地提高了程序的**可维护性**和**可扩展性**。我先列出它们俩的不同之处，再详细解释为何静态代理不具备这两个特性：
- 动态代理产生代理对象的时机是**运行时动态生成**，它没有 Java 源文件，**直接生成字节码文件实例化代理对象**；而静态代理的代理对象，在**程序编译时**已经写好 Java 文件了，... | true | 2026-07-28T12:37:33Z | ## 静态代理与动态代理
你是否会有我一样的疑惑：代理为什么还要分静态和动态的？它们两个有啥不同吗？
很明显，所有人都会有这样的疑惑，我们先来看看它们的相同点：
- 都能够实现代理模式（这不废话吗...）
- 无论是静态代理还是动态代理，代理对象和目标对象都需要实现一个**公共接口**
重点当然是它们的不同之处，动态代理在静态代理的基础上做了改进，极大地提高了程序的**可维护性**和**可扩展性**。我先列出它们俩的不同之处，再详细解释为何静态代理不具备这两个特性：
- 动态代理产生代理对象的时机是**运行时动态生成**，它没有 Java 源文件，**直接生成字节码文件实例化代理对象**；而静态代理的代理对象，在**程序编... | zh | |||
bestJavaer_00259 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 代理 | java | 常见的动态代理实现 | 动态代理最重要的当然是**动态**两个字，学习动态代理的过程，最重要的就是理解何为动态，话不多说，马上开整。
我们来明确一点：**动态代理解决的问题是面对新的需求时，不需要修改代理对象的代码，只需要新增接口和真实对象，在客户端调用即可完成新的代理。**
这样做的目的：满足软件工程的开闭原则，提高类的可维护性和可扩展性。
### JDK Proxy
JDK Proxy 是 JDK 提供的一个动态代理机制，它涉及到两个核心类，分别是`Proxy`和`InvocationHandler`，我们先来了解如何使用它们。
以小红代理卖香水的故事为例，香奈儿香水提供商依旧是真实对象，实现了`SellPerfume`接口，这里不再重新写了，重点是*... | true | 2026-07-28T12:37:33Z | ## 常见的动态代理实现
动态代理最重要的当然是**动态**两个字，学习动态代理的过程，最重要的就是理解何为动态，话不多说，马上开整。
我们来明确一点：**动态代理解决的问题是面对新的需求时，不需要修改代理对象的代码，只需要新增接口和真实对象，在客户端调用即可完成新的代理。**
这样做的目的：满足软件工程的开闭原则，提高类的可维护性和可扩展性。
### JDK Proxy
JDK Proxy 是 JDK 提供的一个动态代理机制，它涉及到两个核心类，分别是`Proxy`和`InvocationHandler`，我们先来了解如何使用它们。
以小红代理卖香水的故事为例，香奈儿香水提供商依旧是真实对象，实现了`SellPerfu... | zh | |||
bestJavaer_00260 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 代理 | java | 动态代理的实际应用 | 传统的 OOP 编程符合从上往下的编码关系，却不符合从左往右的编码关系，如果你看不懂，可以参考下面的动图，OOP 满足我们一个方法一个方法从上往下地执行，但是却不能**从左往右嵌入代码**，而 AOP 的出现很好地弥补了这一点，它**允许我们将重复的代码逻辑抽取出来形成一个单独的覆盖层**，在执行代码时可以将该覆盖层毫无知觉的嵌入到原代码逻辑里面去。
### Spring AOP
如下图所示，method1 和 method2 都需要在方法执行前后**记录日志**，实际上会有更多的方法需要记录日志，传统的 OOP 只能够让我们在每个方法前后手动记录日志，大量的`Log.info`存在于方法内部，导致代码阅读性下降，方法内部无法专注于... | true | 2026-07-28T12:37:33Z | ## 动态代理的实际应用
传统的 OOP 编程符合从上往下的编码关系，却不符合从左往右的编码关系，如果你看不懂，可以参考下面的动图，OOP 满足我们一个方法一个方法从上往下地执行，但是却不能**从左往右嵌入代码**，而 AOP 的出现很好地弥补了这一点，它**允许我们将重复的代码逻辑抽取出来形成一个单独的覆盖层**，在执行代码时可以将该覆盖层毫无知觉的嵌入到原代码逻辑里面去。
### Spring AOP
如下图所示，method1 和 method2 都需要在方法执行前后**记录日志**，实际上会有更多的方法需要记录日志，传统的 OOP 只能够让我们在每个方法前后手动记录日志，大量的`Log.info`存在于方法内部，导致代... | zh | |||
bestJavaer_00261 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 谈谈强引用、软引用、弱引用、幻象引用 | java | 初识引用 | 对于刚接触 Java 的 C++ 程序员而言，理解栈和堆的关系可能很不习惯。在 C++ 中，可以使用 new 操作符在堆上创建对象，或者使用自动分配在栈上创建对象。下面的 C++ 语句是合法的，但是 Java 编译器却拒绝这么写代码，会出现 `syntax error` 编译错误。
```java
Integer foo = Integer(1);
```
Java 和 C 不一样，Java 中会把对象都放在堆上，需要 new 操作符来创建对象。本地变量存储在`栈`中，它们持有一个指向堆中对象的`引用(指针)`。下面是一个 Java 方法，该方法具有一个 Integer 变量，该变量从 String 解析值
```java
publ... | true | 2026-07-28T12:37:33Z | ## 初识引用
对于刚接触 Java 的 C++ 程序员而言，理解栈和堆的关系可能很不习惯。在 C++ 中，可以使用 new 操作符在堆上创建对象，或者使用自动分配在栈上创建对象。下面的 C++ 语句是合法的，但是 Java 编译器却拒绝这么写代码，会出现 `syntax error` 编译错误。
```java
Integer foo = Integer(1);
```
Java 和 C 不一样，Java 中会把对象都放在堆上，需要 new 操作符来创建对象。本地变量存储在`栈`中，它们持有一个指向堆中对象的`引用(指针)`。下面是一个 Java 方法，该方法具有一个 Integer 变量，该变量从 String 解析值
... | zh | |||
bestJavaer_00262 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 谈谈强引用、软引用、弱引用、幻象引用 | java | 垃圾收集器 | Java 给你提供了一个 new 操作符来为堆中的对象开辟内存空间，但它没有提供 `delete` 操作符来释放对象空间。当 foo() 方法返回时，如果变量 baz 超过最大内存，但它所指向的对象仍然还在堆中。如果没有垃圾回收器的话，那么程序就会抛出 `OutOfMemoryError` 错误。然而 Java 不会，它会提供垃圾收集器来释放不再引用的对象。
当程序尝试创建新对象并且堆中没有足够的空间时，垃圾收集器就开始工作。当收集器访问堆时，请求线程被挂起，试图查找程序不再主动使用的对象，并回收它们的空间。如果垃圾收集器无法释放足够的内存空间，并且JVM 无法扩展堆，则会出现 `OutOfMemoryError`，你的应用程序通常... | true | 2026-07-28T12:37:33Z | ## 垃圾收集器
Java 给你提供了一个 new 操作符来为堆中的对象开辟内存空间，但它没有提供 `delete` 操作符来释放对象空间。当 foo() 方法返回时，如果变量 baz 超过最大内存，但它所指向的对象仍然还在堆中。如果没有垃圾回收器的话，那么程序就会抛出 `OutOfMemoryError` 错误。然而 Java 不会，它会提供垃圾收集器来释放不再引用的对象。
当程序尝试创建新对象并且堆中没有足够的空间时，垃圾收集器就开始工作。当收集器访问堆时，请求线程被挂起，试图查找程序不再主动使用的对象，并回收它们的空间。如果垃圾收集器无法释放足够的内存空间，并且JVM 无法扩展堆，则会出现 `OutOfMemoryErro... | zh | |||
bestJavaer_00263 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 谈谈强引用、软引用、弱引用、幻象引用 | java | 对象的生命周期 | 综上所述，可以通过下面的流程来对对象的生命周期做一个总结
对象被创建并初始化，对象在运行时被使用，然后离开对象的作用域，对象会变成不可达并会被垃圾收集器回收。图中用红色标明的区域表示对象处于强可达阶段。
JDK1.2 介绍了 `java.lang.ref` 包，对象的生命周期有四个阶段：`强可达(Strongly Reachable)`、`软可达(Soft Reachable)`、`弱可达(Weak Reachable)`、 `... | true | 2026-07-28T12:37:33Z | ## 对象的生命周期
综上所述，可以通过下面的流程来对对象的生命周期做一个总结
对象被创建并初始化，对象在运行时被使用，然后离开对象的作用域，对象会变成不可达并会被垃圾收集器回收。图中用红色标明的区域表示对象处于强可达阶段。
JDK1.2 介绍了 `java.lang.ref` 包，对象的生命周期有四个阶段：`强可达(Strongly Reachable)`、`软可达(Soft Reachable)`、`弱可达(Weak R... | zh | |||
bestJavaer_00264 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java基础 反射篇 | java | 反射的思想及作用 | 有反必有正，就像世间的阴和阳，计算机的0和1一样。天道有轮回，苍天...~~（净会在这瞎bibi）~~
在学习反射之前，先来了解**正射**是什么。我们平常用的最多的 `new` 方式实例化对象的方式就是一种正射的体现。假如我需要实例化一个`HashMap`，代码就会是这样子。
```java
Map<Integer, Integer> map = new HashMap<>();
map.put(1, 1);
```
某一天发现，该段程序不适合用 HashMap 存储键值对，更倾向于用`LinkedHashMap`存储。重新编写代码后变成下面这个样子。
```java
Map<Integer, Integer> map = new... | true | 2026-07-28T12:37:33Z | ## 反射的思想及作用
有反必有正，就像世间的阴和阳，计算机的0和1一样。天道有轮回，苍天...~~（净会在这瞎bibi）~~
在学习反射之前，先来了解**正射**是什么。我们平常用的最多的 `new` 方式实例化对象的方式就是一种正射的体现。假如我需要实例化一个`HashMap`，代码就会是这样子。
```java
Map<Integer, Integer> map = new HashMap<>();
map.put(1, 1);
```
某一天发现，该段程序不适合用 HashMap 存储键值对，更倾向于用`LinkedHashMap`存储。重新编写代码后变成下面这个样子。
```java
Map<Integer, I... | zh | |||
bestJavaer_00265 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java基础 反射篇 | java | 反射的基本使用 | Java 反射的主要组成部分有4个：
- `Class`：任何运行在内存中的所有类都是该 Class 类的实例对象，每个 Class 类对象内部都包含了本来的**所有信息**。记着一句话，通过反射干任何事，先找 Class 准没错！
- `Field`：描述一个类的**属性**，内部包含了该属性的所有信息，例如**数据类型，属性名，访问修饰符**······
- `Constructor`：描述一个类的**构造方法**，内部包含了构造方法的所有信息，例如**参数类型，参数名字，访问修饰符**······
- `Method`：描述一个类的**所有方法**（包括抽象方法），内部包含了该方法的所有信息，与`Constructor`类似，... | true | 2026-07-28T12:37:33Z | ## 反射的基本使用
Java 反射的主要组成部分有4个：
- `Class`：任何运行在内存中的所有类都是该 Class 类的实例对象，每个 Class 类对象内部都包含了本来的**所有信息**。记着一句话，通过反射干任何事，先找 Class 准没错！
- `Field`：描述一个类的**属性**，内部包含了该属性的所有信息，例如**数据类型，属性名，访问修饰符**······
- `Constructor`：描述一个类的**构造方法**，内部包含了构造方法的所有信息，例如**参数类型，参数名字，访问修饰符**······
- `Method`：描述一个类的**所有方法**（包括抽象方法），内部包含了该方法的所有信息，与`Co... | zh | |||
bestJavaer_00266 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java基础 反射篇 | java | 反射的应用场景 | 反射常见的应用场景这里介绍`3`个：
- Spring 实例化对象：当程序启动时，Spring 会读取配置文件`applicationContext.xml`并解析出里面所有的 <bean> 标签实例化到`IOC`容器中。
- 反射 + 工厂模式：通过`反射`消除工厂中的多个分支，如果需要生产新的类，无需关注工厂类，工厂类可以应对各种新增的类，`反射`可以使得程序更加健壮。
- JDBC连接数据库：使用JDBC连接数据库时，指定连接数据库的`驱动类`时用到反射加载驱动类
### Spring 的 IOC 容器
在 Spring 中，经常会编写一个上下文配置文件`applicationContext.xml`，里面就是关于`bean`... | true | 2026-07-28T12:37:33Z | ## 反射的应用场景
反射常见的应用场景这里介绍`3`个：
- Spring 实例化对象：当程序启动时，Spring 会读取配置文件`applicationContext.xml`并解析出里面所有的 <bean> 标签实例化到`IOC`容器中。
- 反射 + 工厂模式：通过`反射`消除工厂中的多个分支，如果需要生产新的类，无需关注工厂类，工厂类可以应对各种新增的类，`反射`可以使得程序更加健壮。
- JDBC连接数据库：使用JDBC连接数据库时，指定连接数据库的`驱动类`时用到反射加载驱动类
### Spring 的 IOC 容器
在 Spring 中，经常会编写一个上下文配置文件`applicationContext.xm... | zh | |||
bestJavaer_00267 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java基础 反射篇 | java | 反射的优势及缺陷 | 反射的**优点**：
- **增加程序的灵活性**：面对需求变更时，可以灵活地实例化不同对象
但是，有得必有失，一项技术不可能只有优点没有缺点，反射也有**两个比较隐晦的缺点**：
- **破坏类的封装性**：可以强制访问 private 修饰的信息
- **性能损耗**：反射相比直接实例化对象、调用方法、访问变量，中间需要非常多的**检查步骤和解析步骤**，JVM无法对它们优化。
### 增加程序的灵活性
这里不再用 SmallPineapple 举例了，我们来看一个更加`贴近开发`的例子：
- 利用反射连接数据库，**涉及到数据库的数据源**。在 SpringBoot 中一切约定大于配置，想要**定制配置**时，使用`appli... | true | 2026-07-28T12:37:33Z | ## 反射的优势及缺陷
反射的**优点**：
- **增加程序的灵活性**：面对需求变更时，可以灵活地实例化不同对象
但是，有得必有失，一项技术不可能只有优点没有缺点，反射也有**两个比较隐晦的缺点**：
- **破坏类的封装性**：可以强制访问 private 修饰的信息
- **性能损耗**：反射相比直接实例化对象、调用方法、访问变量，中间需要非常多的**检查步骤和解析步骤**，JVM无法对它们优化。
### 增加程序的灵活性
这里不再用 SmallPineapple 举例了，我们来看一个更加`贴近开发`的例子：
- 利用反射连接数据库，**涉及到数据库的数据源**。在 SpringBoot 中一切约定大于配置，想... | zh | |||
bestJavaer_00268 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java基础 反射篇 | java | 反射基础篇文末总结 | - 反射的思想：反射就像是**一面镜子**一样，在**运行时**才看到自己是谁，可获取到自己的信息，甚至实例化对象。
- 反射的作用：**在运行时才确定实例化对象，使程序更加健壮**，面对需求变更时，可以最大程度地做到不修改程序源码应对不同的场景，实例化不同类型的对象。
- 反射的应用场景常见的有`3`个：Spring的 IOC 容器，反射+工厂模式 使工厂类更稳定，JDBC连接数据库时加载驱动类
- 反射的`3`个特点：增加程序的灵活性、破坏类的封装性以及性能损耗
就算把方法中的 static ... | true | 2026-07-28T12:37:33Z | ## 初识 static 关键字
### static 修饰变量
`static` 关键字表示的概念是 `全局的、静态的`，用它修饰的变量被称为`静态变量`。
```java
public class TestStatic {
static int i = 10; // 定义了一个静态变量 i
}
```
静态变量也被称为类变量，静态变量是属于这个类所有的。什么意思呢？这其实就是说，static 关键字只能定义在类的 `{}` 中，而不能定义在任何方法中。
* `虚拟机栈` : Java 虚拟机栈是线程私有的数据... | true | 2026-07-28T12:37:33Z | ## static 进阶知识
我们在了解了 static 关键字的用法之后，来看一下 static 深入的用法，也就是由浅入深，慢慢来，前戏要够～
### 关于 static 的所属类
static 所修饰的属性和方法都属于类的，不会属于任何对象；它们的调用方式都是 `类名.属性名/方法名`，而实例变量和局部变量都是属于具体的对象实例。
### static 修饰变量的存储位置
首先，先来认识一下 JVM 的不同存储区域。
* `虚拟机... | zh | |||
bestJavaer_00271 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 深入理解 static 关键字 | java | 类的构造器是否是 static 的 | * static 最简单、最方便记忆的规则就是没有 this 引用。而在类的构造器中，是有隐含的 this 绑定的，因为构造方法是和类绑定的，从这个角度来看，构造器不是静态的。
* 从类的方法这个角度来看，因为 `类.方法名`不需要新创建对象就能够访问，所以从这个角度来看，构造器也不是静态的
* 从 JVM 指令角度去看，我们来看一个例子
```java
public class StaticTest {
public StaticTest(){}
public static void test(){
}
public static void main(String[] args) {
StaticTest.test();
Stat... | true | 2026-07-28T12:37:33Z | ## 类的构造器是否是 static 的
这个问题我相信大部分小伙伴都没有考虑过，在 Java 编程思想中有这么一句话 **类的构造器虽然没有用 static 修饰，但是实际上是 static 方法**，但是并没有给出实际的解释，但是这个问题可以从下面几个方面来回答
* static 最简单、最方便记忆的规则就是没有 this 引用。而在类的构造器中，是有隐含的 this 绑定的，因为构造方法是和类绑定的，从这个角度来看，构造器不是静态的。
* 从类的方法这个角度来看，因为 `类.方法名`不需要新创建对象就能够访问，所以从这个角度来看，构造器也不是静态的
* 从 JVM 指令角度去看，我们来看一个例子
```java
publ... | zh | |||
bestJavaer_00272 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 理解静态绑定与动态绑定 | java | 动态绑定和静态绑定的特点 | #### 静态绑定
静态绑定在编译时期触发，那么它的主要特点是
1、编译期触发，能够提早知道代码错误
2、提高程序运行效率
#### 动态绑定
1、使用动态绑定的前提条件能够提高代码的可用性，使代码更加灵活。
2、多态是设计模式的基础，能够降低耦合性。
 | true | 2026-07-28T12:37:33Z | ## 动态绑定和静态绑定的特点
#### 静态绑定
静态绑定在编译时期触发，那么它的主要特点是
1、编译期触发，能够提早知道代码错误
2、提高程序运行效率
#### 动态绑定
1、使用动态绑定的前提条件能够提高代码的可用性，使代码更加灵活。
2、多态是设计模式的基础，能够降低耦合性。
![image-20210716163433337](https://tva1.sinaimg.cn/large/008i3skNly1gsivl... | zh | |||
bestJavaer_00273 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | String、StringBuffer 和 StringBuilder 的区别 | java | 碎碎念 | 这是一道老生常谈的问题了，字符串是不仅是 Java 中非常重要的一个对象，它在其他语言中也存在。比如 **C++、Visual Basic、C# 等**。字符串使用 String 来表示，字符串一旦被创建出来就不会被修改，当你想修改 StringBuffer 或者是 StringBuilder，出于效率的考量，虽然 String 可以通过 + 来创建多个对象达到字符串拼接的效果，但是这种拼接的效率相比 StringBuffer 和 StringBuilder，那就是心有余而力不足了。本篇文章我们一起来深入了解一下这三个对象。 | true | 2026-07-28T12:37:33Z | ## 碎碎念
这是一道老生常谈的问题了，字符串是不仅是 Java 中非常重要的一个对象，它在其他语言中也存在。比如 **C++、Visual Basic、C# 等**。字符串使用 String 来表示，字符串一旦被创建出来就不会被修改，当你想修改 StringBuffer 或者是 StringBuilder，出于效率的考量，虽然 String 可以通过 + 来创建多个对象达到字符串拼接的效果，但是这种拼接的效率相比 StringBuffer 和 StringBuilder，那就是心有余而力不足了。本篇文章我们一起来深入了解一下这三个对象。 | zh | |||
bestJavaer_00274 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | String、StringBuffer 和 StringBuilder 的区别 | java | 简单认识这三个对象 | ### String
String 表示的就是 Java 中的字符串，我们日常开发用到的使用 `""` 双引号包围的数都是字符串的实例。String 类其实是通过 char 数组来保存字符串的。下面是一个典型的字符串的声明
```java
String s = "abc";
```
上面你创建了一个名为 `abc` 的字符串。
字符串是恒定的，一旦创建出来就不会被修改，怎么理解这句话？我们可以看下 String 源码的声明
告诉我你看到了什么？Stri... | true | 2026-07-28T12:37:33Z | ## 简单认识这三个对象
### String
String 表示的就是 Java 中的字符串，我们日常开发用到的使用 `""` 双引号包围的数都是字符串的实例。String 类其实是通过 char 数组来保存字符串的。下面是一个典型的字符串的声明
```java
String s = "abc";
```
上面你创建了一个名为 `abc` 的字符串。
字符串是恒定的，一旦创建出来就不会被修改，怎么理解这句话？我们可以看下 String 源码的声明
![](https://img2020.cnblogs.com/blog/1515111/202006/1515111-20200606094628294-70991660... | zh | |||
bestJavaer_00275 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | String、StringBuffer 和 StringBuilder 的区别 | java | 深入理解 String、StringBuilder、StringBuffer | 我们上面说到，使用 `+` 连接符时，JVM 会隐式创建 StringBuilder 对象，这种方式在大部分情况下并不会造成效率的损失，不过在进行大量循环拼接字符串时则需要注意。如下这段代码
```java
String s = "aaaa";
for (int i = 0; i < 100000; i++) {
s += "bbb";
}
```
这是一段很普通的代码，只不过对字符串 s 进行了 + 操作，我们通过反编译代码来看一下。
```java
// 经过反编译后
String s = "aaa";
for(int i = 0; i < 10000; i++) {
s = (new StringBuilder()).appe... | true | 2026-07-28T12:37:33Z | ## 深入理解 String、StringBuilder、StringBuffer
我们上面说到，使用 `+` 连接符时，JVM 会隐式创建 StringBuilder 对象，这种方式在大部分情况下并不会造成效率的损失，不过在进行大量循环拼接字符串时则需要注意。如下这段代码
```java
String s = "aaaa";
for (int i = 0; i < 100000; i++) {
s += "bbb";
}
```
这是一段很普通的代码，只不过对字符串 s 进行了 + 操作，我们通过反编译代码来看一下。
```java
// 经过反编译后
String s = "aaa";
for(int i = 0... | zh | |||
bestJavaer_00276 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 中的语法糖，真甜 | java | 语法糖 | 在聊之前我们需要先了解一下 `语法糖` 的概念：`语法糖（Syntactic sugar）`，也叫做糖衣语法，是英国科学家发明的一个术语，通常来说使用语法糖能够增加程序的`可读性`，从而减少程序代码出错的机会，真是又香又甜。
语法糖指的是计算机语言中添加的某种语法，**这种语法对语言的功能并没有影响，但是更方便程序员使用**。因为 Java 代码需要运行在 JVM 中，**JVM 是并不支持语法糖的，语法糖在程序编译阶段就会被还原成简单的基础语法结构，这个过程就是`解语法糖`**。所以在 Java 中，真正支持语法糖的是 Java 编译器，真是换汤不换药，万变不离其宗，关了灯都一样。。。。。。
下面我们就来认识一下 Java 中的这... | true | 2026-07-28T12:37:33Z | ## 语法糖
在聊之前我们需要先了解一下 `语法糖` 的概念：`语法糖（Syntactic sugar）`，也叫做糖衣语法，是英国科学家发明的一个术语，通常来说使用语法糖能够增加程序的`可读性`，从而减少程序代码出错的机会，真是又香又甜。
语法糖指的是计算机语言中添加的某种语法，**这种语法对语言的功能并没有影响，但是更方便程序员使用**。因为 Java 代码需要运行在 JVM 中，**JVM 是并不支持语法糖的，语法糖在程序编译阶段就会被还原成简单的基础语法结构，这个过程就是`解语法糖`**。所以在 Java 中，真正支持语法糖的是 Java 编译器，真是换汤不换药，万变不离其宗，关了灯都一样。。。。。。
下面我们就来认识一... | zh | |||
bestJavaer_00277 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 中的语法糖，真甜 | java | 学习语法糖的意义 | 互联网时代，有很多标新立异的想法和框架层出不穷，但是，我们对于学习来说应该抓住技术的核心。然而，软件工程是一门协作的艺术，对于工程来说如何提高工程质量，如何提高工程效率也是我们要关注的，既然这些语法糖能辅助我们以更好的方式编写备受欢迎的代码，我们程序员为什么要 `抵制` 呢？
语法糖也是一种进步，这就和你写作文似的，大白话能把故事讲明白的它就没有语言优美、酣畅淋漓的把故事讲生动的更令人喜欢。
我们要在敞开怀抱拥抱变化的同时也要掌握其 `屠龙之技`。
(Java2 Platform Standard Edition，java平台标准版）
JavaSE 是 JavaEE 和 JavaME ... | true | 2026-07-28T12:37:33Z | ## Java 概述
### 什么是 Java？
Java 是 Sun Microsystems 于1995 年首次发布的一种`编程语言`和计算平台。编程语言还比较好理解，那么什么是 `计算平台` 呢？
>计算平台是在电脑中运行应用程序（软件）的环境，包括`硬件环境`和`软件环境`。一般系统平台包括一台电脑的硬件体系结构、操作系统、运行时库。
Java 是快速，安全和可靠的。 从笔记本电脑到数据中心，从游戏机到科学超级计算机，从手机到互联网，Java 无处不在！Java 主要分为三个版本：
- JavaSE(J2SE)(Java2 Platform Standard Edition，java平台标准版）
JavaSE 是... | zh | |||
bestJavaer_00279 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | Java 开发环境配置 | 这里给大家推荐几个 JDK 安装和配置的博客：
[Windows 版本 JDK 的下载和安装](https://www.cnblogs.com/renqiqiang/p/6822143.html)
[mac 版本 JDK 的下载和安装](https://www.jianshu.com/p/a85658902f26) | true | 2026-07-28T12:37:33Z | ## Java 开发环境配置
这里给大家推荐几个 JDK 安装和配置的博客：
[Windows 版本 JDK 的下载和安装](https://www.cnblogs.com/renqiqiang/p/6822143.html)
[mac 版本 JDK 的下载和安装](https://www.jianshu.com/p/a85658902f26) | zh | |||
bestJavaer_00280 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | Java 基本语法 | 在配置完 Java 开发环境，并下载 Java 开发工具（Eclipse、IDEA 等）后，就可以编写 Java 程序了，因为这个教程是从头梳理 Java 体系，所以有必要从基础的概念开始谈起。
### 数据类型
在 Java 中，数据类型只有`四类八种`。
* 整数型：byte、short、int、long
byte 也就是字节，1 byte = 8 bits，byte 的默认值是 0 ；
short 占用两个字节，也就是 16 位，1 short = 16 bits，它的默认值也是 0 ；
int 占用四个字节，也就是 32 位，1 int = 32 bits，默认值是 0 ；
long 占用八个字节，也就是 64 位，1 lo... | true | 2026-07-28T12:37:33Z | ## Java 基本语法
在配置完 Java 开发环境，并下载 Java 开发工具（Eclipse、IDEA 等）后，就可以编写 Java 程序了，因为这个教程是从头梳理 Java 体系，所以有必要从基础的概念开始谈起。
### 数据类型
在 Java 中，数据类型只有`四类八种`。
* 整数型：byte、short、int、long
byte 也就是字节，1 byte = 8 bits，byte 的默认值是 0 ；
short 占用两个字节，也就是 16 位，1 short = 16 bits，它的默认值也是 0 ；
int 占用四个字节，也就是 32 位，1 int = 32 bits，默认值是 0 ；
long... | zh | |||
bestJavaer_00281 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | Java 执行控制流程 | Java 中的控制流程其实和 C 一样，在 Java 中，流程控制会涉及到包括 **if-else、while、do-while、for、return、break** 以及选择语句 `switch`。下面以此进行分析。
### 条件语句
条件语句可根据不同的条件执行不同的语句。包括 if 条件语句与 switch 多分支语句。
#### if 条件语句
if 语句可以单独判断表达式的结果，表示表达的执行结果，例如：
```java
int a = 10;
if(a > 10){
return true;
}
return false;
```
#### if...else 条件语句
if 语句还可以与 else 连用，通常表现为 *... | true | 2026-07-28T12:37:33Z | ## Java 执行控制流程
Java 中的控制流程其实和 C 一样，在 Java 中，流程控制会涉及到包括 **if-else、while、do-while、for、return、break** 以及选择语句 `switch`。下面以此进行分析。
### 条件语句
条件语句可根据不同的条件执行不同的语句。包括 if 条件语句与 switch 多分支语句。
#### if 条件语句
if 语句可以单独判断表达式的结果，表示表达的执行结果，例如：
```java
int a = 10;
if(a > 10){
return true;
}
return false;
```
#### if...else 条件语句
... | zh | |||
bestJavaer_00282 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | 面向对象 | > 面向对象是学习 Java 一种非常重要的开发思想，但是面向对象并不是 Java 所特有的思想，这里大家不要搞混了。
下面我们来探讨面向对象的思想，面向对象的思想已经逐步取代了过程化的思想 --- 面向过程，Java 是面向对象的高级编程语言，面向对象语言具有如下特征
* 面向对象是一种常见的思想，比较符合人们的思考习惯；
* 面向对象可以将复杂的业务逻辑简单化，增强代码复用性；
* 面向对象具有抽象、封装、继承、多态等特性。
面向对象的编程语言主要有：C++、Java、C#等。
所以必须熟悉面向对象的思想才能编写出 Java 程序。
### 类也是一种对象
现在我们来认识一个面向对象的新的概念 --- 类，什么是类，它就相当于是... | true | 2026-07-28T12:37:33Z | ## 面向对象
> 面向对象是学习 Java 一种非常重要的开发思想，但是面向对象并不是 Java 所特有的思想，这里大家不要搞混了。
下面我们来探讨面向对象的思想，面向对象的思想已经逐步取代了过程化的思想 --- 面向过程，Java 是面向对象的高级编程语言，面向对象语言具有如下特征
* 面向对象是一种常见的思想，比较符合人们的思考习惯；
* 面向对象可以将复杂的业务逻辑简单化，增强代码复用性；
* 面向对象具有抽象、封装、继承、多态等特性。
面向对象的编程语言主要有：C++、Java、C#等。
所以必须熟悉面向对象的思想才能编写出 Java 程序。
### 类也是一种对象
现在我们来认识一个面向对象的新的概念 ... | zh | |||
bestJavaer_00283 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | 访问控制权限 | 访问控制权限又称为`封装`，它是面向对象三大特性中的一种，我之前在学习过程中经常会忽略封装，心想这不就是一个访问修饰符么，怎么就是三大特性的必要条件了？后来我才知道，**如果你信任的下属对你隐瞒 bug，你是根本不知道的**。
访问控制权限其实最核心就是一点：只对需要的类可见。
Java中成员的访问权限共有四种，分别是 **public、protected、default、private**，它们的可见性如下
### 继承
继承是所有 `OO... | true | 2026-07-28T12:37:33Z | ## 访问控制权限
访问控制权限又称为`封装`，它是面向对象三大特性中的一种，我之前在学习过程中经常会忽略封装，心想这不就是一个访问修饰符么，怎么就是三大特性的必要条件了？后来我才知道，**如果你信任的下属对你隐瞒 bug，你是根本不知道的**。
访问控制权限其实最核心就是一点：只对需要的类可见。
Java中成员的访问权限共有四种，分别是 **public、protected、default、private**，它们的可见性如下
#... | zh | |||
bestJavaer_00284 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | 接口和抽象类 | ### 接口
接口相当于就是对外的一种约定和标准，这里拿操作系统举例子，为什么会有操作系统？就会为了屏蔽软件的复杂性和硬件的简单性之间的差异，为软件提供统一的标准。
在 Java 语言中，接口是由 `interface` 关键字来表示的，比如我们可以向下面这样定义一个接口
```java
public interface CxuanGoodJob {}
```
比如我们定义了一个 CxuanGoodJob 的接口，然后你就可以在其内部定义 cxuan 做的好的那些事情，比如 cxuan 写的文章不错。
```java
public interface CxuanGoodJob { void writeWell();}
```
... | true | 2026-07-28T12:37:33Z | ## 接口和抽象类
### 接口
接口相当于就是对外的一种约定和标准，这里拿操作系统举例子，为什么会有操作系统？就会为了屏蔽软件的复杂性和硬件的简单性之间的差异，为软件提供统一的标准。
在 Java 语言中，接口是由 `interface` 关键字来表示的，比如我们可以向下面这样定义一个接口
```java
public interface CxuanGoodJob {}
```
比如我们定义了一个 CxuanGoodJob 的接口，然后你就可以在其内部定义 cxuan 做的好的那些事情，比如 cxuan 写的文章不错。
```java
public interface CxuanGoodJob { void wr... | zh | |||
bestJavaer_00285 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | 异常 | 异常是程序经常会出现的，发现错误的最佳时机是在编译阶段，也就是你试图在运行程序之前。但是，在编译期间并不能找到所有的错误，有一些 `NullPointerException` 和 `ClassNotFoundException` 异常在编译期找不到，这些异常是 RuntimeException 运行时异常，这些异常往往在运行时才能被发现。
我们写 Java 程序经常会出现两种问题，一种是 java.lang.Exception ，一种是 java.lang.Error，都用来表示出现了异常情况，下面就针对这两种概念进行理解。
### 认识 Exception
`Exception` 位于 `java.lang` 包下，它是一种顶级接... | true | 2026-07-28T12:37:33Z | ## 异常
异常是程序经常会出现的，发现错误的最佳时机是在编译阶段，也就是你试图在运行程序之前。但是，在编译期间并不能找到所有的错误，有一些 `NullPointerException` 和 `ClassNotFoundException` 异常在编译期找不到，这些异常是 RuntimeException 运行时异常，这些异常往往在运行时才能被发现。
我们写 Java 程序经常会出现两种问题，一种是 java.lang.Exception ，一种是 java.lang.Error，都用来表示出现了异常情况，下面就针对这两种概念进行理解。
### 认识 Exception
`Exception` 位于 `java.lang` ... | zh | |||
bestJavaer_00286 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | 内部类 | 距今为止，我们了解的都是普通类的定义，那就是直接在 IDEA 中直接新建一个 class 。
新建完成后，你就会拥有一个 class 文件的定义，这种操作太简单了，时间长了就会枯燥，我们年轻人多需要更新潮和骚气的写法，好吧，既然你提到了那就使用 `内部类`吧，这是一种有用而且骚气的定义类的方式，内部类的定义非常简单：**可以将一个类的定义放在另一个类的内部，这就是内部类**。
内部类是一种非常有用的特性，定义在类内部的类，持有外部类的引用，但... | true | 2026-07-28T12:37:33Z | ## 内部类
距今为止，我们了解的都是普通类的定义，那就是直接在 IDEA 中直接新建一个 class 。
新建完成后，你就会拥有一个 class 文件的定义，这种操作太简单了，时间长了就会枯燥，我们年轻人多需要更新潮和骚气的写法，好吧，既然你提到了那就使用 `内部类`吧，这是一种有用而且骚气的定义类的方式，内部类的定义非常简单：**可以将一个类的定义放在另一个类的内部，这就是内部类**。
内部类是一种非常有用的特性，定义在类内部的类... | zh | |||
bestJavaer_00287 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | 集合 | 集合在我们的日常开发中所使用的次数简直太多了，你已经把它们都用的熟透了，但是作为一名合格的程序员，你不仅要了解它的基本用法，你还要了解它的源码；存在即合理，你还要了解它是如何设计和实现的，你还要了解它的衍生过程。
这篇博客就来详细介绍一下 Collection 这个庞大集合框架的家族体系和成员，让你了解它的设计与实现。
**是时候祭出这张神图了**
首先来介绍的就是列表爷爷辈儿的接口- **Iterator**
### Iterable 接口... | true | 2026-07-28T12:37:33Z | ## 集合
集合在我们的日常开发中所使用的次数简直太多了，你已经把它们都用的熟透了，但是作为一名合格的程序员，你不仅要了解它的基本用法，你还要了解它的源码；存在即合理，你还要了解它是如何设计和实现的，你还要了解它的衍生过程。
这篇博客就来详细介绍一下 Collection 这个庞大集合框架的家族体系和成员，让你了解它的设计与实现。
**是时候祭出这张神图了**
首先来介绍的就是列表爷爷辈儿的接口- **Iterator**
###... | zh | |||
bestJavaer_00288 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | 泛型 | 在 Jdk1.5 中，提出了一种新的概念：`泛型`，那么什么是泛型呢？
泛型其实就是一种参数化的集合，它限制了你添加进集合的类型。泛型的本质就是一种参数化类型。多态也可以看作是泛型的机制。一个类继承了父类，那么就能通过它的父类找到对应的子类，但是不能通过其他类来找到具体要找的这个类。泛型的设计之处就是希望对象或方法具有最广泛的表达能力。
下面来看一个例子说明没有泛型的用法
```java
List arrayList = new ArrayList();
arrayList.add("cxuan");
arrayList.add(100);
for(int i = 0; i< arrayList.size();i++){
Strin... | true | 2026-07-28T12:37:33Z | ## 泛型
在 Jdk1.5 中，提出了一种新的概念：`泛型`，那么什么是泛型呢？
泛型其实就是一种参数化的集合，它限制了你添加进集合的类型。泛型的本质就是一种参数化类型。多态也可以看作是泛型的机制。一个类继承了父类，那么就能通过它的父类找到对应的子类，但是不能通过其他类来找到具体要找的这个类。泛型的设计之处就是希望对象或方法具有最广泛的表达能力。
下面来看一个例子说明没有泛型的用法
```java
List arrayList = new ArrayList();
arrayList.add("cxuan");
arrayList.add(100);
for(int i = 0; i< arrayList.size();... | zh | |||
bestJavaer_00289 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | 反射 | 反射是 Java 中一个非常重要同时也是一个高级特性，基本上 Spring 等一系列框架都是基于反射的思想写成的。我们首先来认识一下什么反射。
**Java 反射机制是在程序的运行过程中，对于任何一个类，都能够知道它的所有属性和方法；对于任意一个对象，都能够知道调用它的任意属性和方法，这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制**。
要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是 Class 类中的方法，所以先要获取到每一个字节码文件对应的 Class 类型的对象.
所谓反射其实是获取类的**字节码**文件，也就是. class 文件，那么我们就可以通过 Class 这个对象进行获... | true | 2026-07-28T12:37:33Z | ## 反射
反射是 Java 中一个非常重要同时也是一个高级特性，基本上 Spring 等一系列框架都是基于反射的思想写成的。我们首先来认识一下什么反射。
**Java 反射机制是在程序的运行过程中，对于任何一个类，都能够知道它的所有属性和方法；对于任意一个对象，都能够知道调用它的任意属性和方法，这种动态获取信息以及动态调用对象方法的功能称为 Java 语言的反射机制**。
要想解剖一个类，必须先要获取到该类的字节码文件对象。而解剖使用的就是 Class 类中的方法，所以先要获取到每一个字节码文件对应的 Class 类型的对象.
所谓反射其实是获取类的**字节码**文件，也就是. class 文件，那么我们就可以通过 Cla... | zh | |||
bestJavaer_00290 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | 枚举 | 枚举可能是我们使用次数比较少的特性，在 Java 中，枚举使用 `enum` 关键字来表示，枚举其实是一项非常有用的特性，你可以把它理解为具有特定性质的类。enum 不仅仅 Java 有，C 和 C++ 也有枚举的概念。下面是一个枚举的例子。
```java
public enum Family { FATHER, MOTHER, SON, Daughter;}
```
上面我们创建了一个 `Family`的枚举类，它具有 4 个值，由于枚举类型都是常量，所以都用大写字母来表示。那么 enum 创建出来了，该如何引用呢？
```java
public class EnumUse { public sta... | true | 2026-07-28T12:37:33Z | ## 枚举
枚举可能是我们使用次数比较少的特性，在 Java 中，枚举使用 `enum` 关键字来表示，枚举其实是一项非常有用的特性，你可以把它理解为具有特定性质的类。enum 不仅仅 Java 有，C 和 C++ 也有枚举的概念。下面是一个枚举的例子。
```java
public enum Family { FATHER, MOTHER, SON, Daughter;}
```
上面我们创建了一个 `Family`的枚举类，它具有 4 个值，由于枚举类型都是常量，所以都用大写字母来表示。那么 enum 创建出来了，该如何引用呢？
```java
public class EnumUse { ... | zh | |||
bestJavaer_00291 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | Java 基础核心总结 | java | I/O | 创建一个良好的 I/O 程序是非常复杂的。JDK 开发人员编写了大量的类只为了能够创建一个良好的工具包，想必编写 I/O 工具包很费劲吧。
IO 类设计出来，肯定是为了解决 IO 相关操作的，最常见的 I/O 读写就是网络、磁盘等。在 Java 中，对文件的操作是一个典型的 I/O 操作。下面我们就对 I/O 进行一个分类。
I/O 还可以根据操作对象来进行区分：主要分为
I/O 还可以根据操作对象来进行区分：主要分为
### 大小写敏感
首先，null 是 Java 中的`关键字`，像是 **public、static、final。**它是大小写敏感的，你不能将 nu... | true | 2026-07-28T12:37:33Z | ## 关于 null 的几种处理方式
对于 Java 程序员来说，空指针一直是恼人的问题，我们在开发中经常会受到 NullPointerException 的蹂躏和壁咚。Java 的发明者也承认这是一个巨大的设计错误。
那么关于 null ，你应该知道下面这几件事情来有效的了解 null ，从而避免很多由 null 引起的错误。
### 大小写敏感
首先，null 是 Java 中的`关键字`，像是 **public、static、... | zh | |||
bestJavaer_00294 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 深入理解 Java 变量 | java | 变量汇总 | 所以，到底有哪些变量的概念呢？距今为止，目前已知的变量主要有
* 实例变量
* 全局变量
* 静态变量
* 类变量
* 局部变量
* 成员变量
* 常量
下面我们就采用各个击破的方式来认识每个概念
### 实例变量
实例变量又被称为`Instance variables`。不使用 `static` 关键字定义，并且在任何方法、构造方法、块之外的变量都是`实例变量`。实例变量都是基于特定实例的，实例变量不会在实例之间共享，也就是说，每一个对象的实例都有自己的一个实例变量。下面是实例变量的一个例子
```java
class Fruits {
public String fruitName; // 具有公共访问权限的 fruitName... | true | 2026-07-28T12:37:33Z | ## 变量汇总
所以，到底有哪些变量的概念呢？距今为止，目前已知的变量主要有
* 实例变量
* 全局变量
* 静态变量
* 类变量
* 局部变量
* 成员变量
* 常量
下面我们就采用各个击破的方式来认识每个概念
### 实例变量
实例变量又被称为`Instance variables`。不使用 `static` 关键字定义，并且在任何方法、构造方法、块之外的变量都是`实例变量`。实例变量都是基于特定实例的，实例变量不会在实例之间共享，也就是说，每一个对象的实例都有自己的一个实例变量。下面是实例变量的一个例子
```java
class Fruits {
public String fruitName; // ... | zh | |||
bestJavaer_00295 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 深入理解 Java 变量 | java | 验证过程 | 为了验证这个结论，我们求助于了 `stackoverflow` 网站
我们搜索 **java member variable and instance variable** 就帮我们定为到了这个标题
大致意思是：什么是成员变量？成员变量和实例变量是否相同呢？我们下面有个回答
我们搜索 **java member variable and instance variable** 就帮我们定为到了这个标题
大致意思是：什么是成员变量？成员变量和实例变量是否相同呢？我们下面有个回答
我写了一篇文章为了给你讲清楚，现在你应该知道 Java 中到底有哪些变量了吧。
如果你用 static 来定义变量，只能是类变量、或者说静态变量、而且其定义位置只能在类中，方法或代码块外，变量的副本只有一个。
如果你不用 static 来声明变量，那么就会有三种变量的叫法
* 定义在构造方法、代码块、方法`外`的变量被称为实例变量，实例变量的副本数量和实例的数量一样。
* 定义在方法、构造方法、代码块`内`的变量被称为局部变量；
* 定义在方法参... | true | 2026-07-28T12:37:33Z | 相近问题也见于: bestJavaer | ## bilibili
所以
我写了一篇文章为了给你讲清楚，现在你应该知道 Java 中到底有哪些变量了吧。
如果你用 static 来定义变量，只能是类变量、或者说静态变量、而且其定义位置只能在类中，方法或代码块外，变量的副本只有一个。
如果你不用 static 来声明变量，那么就会有三种变量的叫法
* 定义在构造方法、代码块、方法`外`的变量被称为实例变量，实例变量的副本数量和实例的数量一样。
* 定义在方法、构造方法、代码块`内`的变量被... | zh | ||
bestJavaer_00297 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | 学习 Java 网站推荐给你 | java | 推荐几个非常不错的 Java 学习网站 | ### LearnJava 在线
这是一个非常不错的学习 Java 的在线网站，纯免费。这是一个个人项目，旨在通过简单有效的在浏览器中进行练习让你快速掌握 Java 编程语言。通过直接从网络浏览器运行实际代码，你无需在本地安装和执行代码就可以尝试编码，这无疑提高了编程效率和上手效率。
你可以根据目录进行练习，有基础部分和高级部分，首先有例子代码，告诉你需要注意的事项以及详细的讲解，旨在把你教会后再让你进行练习。
下面就是练习部分，练习部分没有固... | true | 2026-07-28T12:37:33Z | ## 推荐几个非常不错的 Java 学习网站
### LearnJava 在线
这是一个非常不错的学习 Java 的在线网站，纯免费。这是一个个人项目，旨在通过简单有效的在浏览器中进行练习让你快速掌握 Java 编程语言。通过直接从网络浏览器运行实际代码，你无需在本地安装和执行代码就可以尝试编码，这无疑提高了编程效率和上手效率。
你可以根据目录进行练习，有基础部分和高级部分，首先有例子代码，告诉你需要注意的事项以及详细的讲解，旨在把你教会后再让你进行练习。
`，所谓的`AQS`即是抽象的队列式的同步器，内部定义了很多锁相关的方法，我们熟知的`ReentrantLock`、`ReentrantReadWriteLock`、`CountDownLatch`、`Semaphore`等都是基于`AQS`来实现的。
我们先看下`AQS`相关的`UML`图：
思维导图：
* [前言](#前言)
* [AQS实现原理](#aqs实现原理)
* [目录结构](#目录结构)
* [场景分析](#场景分析)
* [线程一加锁成功](#线程一加锁成功)
* [线程二抢占锁失败](#线程二抢占锁失败)
* [线程三抢占锁失败](#线程三抢占锁失败)
* [线程一释放锁](#线程一释放锁)
* [线程二唤醒继续加锁](#线程二唤醒继续加锁)
* [线程二释放锁/线程三加锁](#线程二释放... | zh | |||
bestJavaer_00299 | bestJavaer | crisxuan/bestJavaer | https://github.com/crisxuan/bestJavaer | AtomicInteger 的用法和实现原理 | java-concurrency | 了解 AtomicInteger | `AtomicInteger` 是 JDK 1.5 新添加的工具类，我们首先来看一下它的继承关系
<img src="https://s1.ax1x.com/2020/09/20/wosPYV.png" alt="AtomicInteger01" border="0">
与 int 的包装类 Integer 一样，都是继承于 `Number` 类的。
<img src="https://s1.ax1x.com/2020/09/20/wos4pT.png" alt="AtomicInteger02" border="0">
这个 Number 类是基本数据类型的包装类，一般和数据类型有关的对象都会继承于 Number 类。
它的继承体... | true | 2026-07-28T12:37:33Z | 相近问题也见于: bestJavaer | ## 了解 AtomicInteger
`AtomicInteger` 是 JDK 1.5 新添加的工具类，我们首先来看一下它的继承关系
<img src="https://s1.ax1x.com/2020/09/20/wosPYV.png" alt="AtomicInteger01" border="0">
与 int 的包装类 Integer 一样，都是继承于 `Number` 类的。
<img src="https://s1.ax1x.com/2020/09/20/wos4pT.png" alt="AtomicInteger02" border="0">
这个 Number 类是基本数据类型的包装类，一般和数据类型有... | zh |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.