From 3c52b167808996517e910cd1e0e02ab866224626 Mon Sep 17 00:00:00 2001
From: ygf
Date: Wed, 9 Sep 2020 16:12:10 +0800
Subject: [PATCH 01/11] =?UTF-8?q?=E6=96=87=E6=9C=AC=E6=8F=8F=E8=BF=B0?=
=?UTF-8?q?=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../Java\345\206\205\345\255\230\345\214\272\345\237\237.md" | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git "a/docs/java/jvm/Java\345\206\205\345\255\230\345\214\272\345\237\237.md" "b/docs/java/jvm/Java\345\206\205\345\255\230\345\214\272\345\237\237.md"
index 0cae9f0a7f8..a4715a87d60 100644
--- "a/docs/java/jvm/Java\345\206\205\345\255\230\345\214\272\345\237\237.md"
+++ "b/docs/java/jvm/Java\345\206\205\345\255\230\345\214\272\345\237\237.md"
@@ -214,8 +214,8 @@ JDK 1.8 的时候,方法区(HotSpot 的永久代)被彻底移除了(JDK1
#### 2.5.3 为什么要将永久代 (PermGen) 替换为元空间 (MetaSpace) 呢?
-1. 整个永久代有一个 JVM 本身设置固定大小上限,无法进行调整,而元空间使用的是直接内存,受本机可用内存的限制,虽然元空间仍旧可能溢出,但是比原来出现的几率会更小。
->当你元空间溢出时会得到如下错误: `java.lang.OutOfMemoryError: MetaSpace`
+1. 整个永久代有一个 JVM 本身设置的固定大小上限,无法进行调整,而元空间使用的是直接内存,受本机可用内存的限制,虽然元空间仍旧可能溢出,但是比原来出现的几率会更小。
+>当元空间溢出时会得到如下错误: `java.lang.OutOfMemoryError: MetaSpace`
你可以使用 `-XX:MaxMetaspaceSize` 标志设置最大元空间大小,默认值为 unlimited,这意味着它只受系统内存的限制。`-XX:MetaspaceSize` 调整标志定义元空间的初始大小如果未指定此标志,则 Metaspace 将根据运行时的应用程序需求动态地重新调整大小。
From 2f236e4e70a5a8392b981bb080b9bb0826af2097 Mon Sep 17 00:00:00 2001
From: ygf
Date: Fri, 18 Sep 2020 14:20:47 +0800
Subject: [PATCH 02/11] =?UTF-8?q?=E9=94=99=E5=88=AB=E5=AD=97=E7=AD=89?=
=?UTF-8?q?=E6=96=87=E6=9C=AC=E4=BF=AE=E6=94=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
docs/java/What's New in JDK8/Java8Tutorial.md | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/docs/java/What's New in JDK8/Java8Tutorial.md b/docs/java/What's New in JDK8/Java8Tutorial.md
index 8cf809f75c8..c058dff2312 100644
--- a/docs/java/What's New in JDK8/Java8Tutorial.md
+++ b/docs/java/What's New in JDK8/Java8Tutorial.md
@@ -283,7 +283,7 @@ Formula formula = (a) -> sqrt(a * 100);
### 内置函数式接口(Built-in Functional Interfaces)
-JDK 1.8 API包含许多内置函数式接口。 其中一些借口在老版本的 Java 中是比较常见的比如: `Comparator` 或`Runnable`,这些接口都增加了`@FunctionalInterface`注解以便能用在 lambda 表达式上。
+JDK 1.8 API包含许多内置函数式接口。 其中一些接口在老版本的 Java 中是比较常见的比如: `Comparator` 或`Runnable`,这些接口都增加了`@FunctionalInterface`注解以便能用在 lambda 表达式上。
但是 Java 8 API 同样还提供了很多全新的函数式接口来让你的编程工作更加方便,有一些接口是来自 [Google Guava](https://code.google.com/p/guava-libraries/) 库里的,即便你对这些很熟悉了,还是有必要看看这些是如何扩展到lambda上使用的。
@@ -441,7 +441,7 @@ optional.ifPresent((s) -> System.out.println(s.charAt(0))); // "b"
`java.util.Stream` 表示能应用在一组元素上一次执行的操作序列。Stream 操作分为中间操作或者最终操作两种,最终操作返回一特定类型的计算结果,而中间操作返回Stream本身,这样你就可以将多个操作依次串起来。Stream 的创建需要指定一个数据源,比如` java.util.Collection` 的子类,List 或者 Set, Map 不支持。Stream 的操作可以串行执行或者并行执行。
-首先看看Stream是怎么用,首先创建实例代码的用到的数据List:
+首先看看Stream是怎么用,首先创建实例代码需要用到的数据List:
```java
List stringList = new ArrayList<>();
@@ -552,7 +552,7 @@ Stream提供了多种匹配操作,允许检测指定的Predicate是否匹配
### Reduce(规约)
-这是一个 **最终操作** ,允许通过指定的函数来讲stream中的多个元素规约为一个元素,规约后的结果是通过Optional 接口表示的:
+这是一个 **最终操作** ,允许通过指定的函数来将stream中的多个元素规约为一个元素,规约后的结果是通过Optional 接口表示的:
```java
//测试 Reduce (规约)操作
@@ -705,7 +705,7 @@ map.merge(9, "concat", (value, newValue) -> value.concat(newValue));
map.get(9); // val9concat
```
-Merge 做的事情是如果键名不存在则插入,否则则对原键对应的值做合并操作并重新插入到map中。
+Merge 做的事情是如果键名不存在则插入,否则对原键对应的值做合并操作并重新插入到map中。
## Date API(日期相关API)
From e8aaa1f63138073fe26a2fcdd91d4edb9ed5d6f9 Mon Sep 17 00:00:00 2001
From: pengchen211
Date: Sun, 11 Apr 2021 14:24:28 +0800
Subject: [PATCH 03/11] =?UTF-8?q?=E5=88=A0=E9=99=A4=E9=87=8D=E5=A4=8D?=
=?UTF-8?q?=E7=9A=84=E5=B9=B6=E5=8F=91=E5=B7=A5=E5=85=B7=E7=B1=BB=E7=A4=BA?=
=?UTF-8?q?=E4=BE=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git "a/docs/java/multi-thread/2020\346\234\200\346\226\260Java\345\271\266\345\217\221\350\277\233\351\230\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md" "b/docs/java/multi-thread/2020\346\234\200\346\226\260Java\345\271\266\345\217\221\350\277\233\351\230\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md"
index c39f9b0f013..b1db21c648f 100644
--- "a/docs/java/multi-thread/2020\346\234\200\346\226\260Java\345\271\266\345\217\221\350\277\233\351\230\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md"
+++ "b/docs/java/multi-thread/2020\346\234\200\346\226\260Java\345\271\266\345\217\221\350\277\233\351\230\266\345\270\270\350\247\201\351\235\242\350\257\225\351\242\230\346\200\273\347\273\223.md"
@@ -968,7 +968,7 @@ protected final boolean compareAndSetState(int expect, int update) {
- **Exclusive**(独占):只有一个线程能执行,如 `ReentrantLock`。又可分为公平锁和非公平锁:
- 公平锁:按照线程在队列中的排队顺序,先到者先拿到锁
- 非公平锁:当线程要获取锁时,无视队列顺序直接去抢锁,谁抢到就是谁的
-- **Share**(共享):多个线程可同时执行,如` CountDownLatch`、`Semaphore`、`CountDownLatch`、 `CyclicBarrier`、`ReadWriteLock` 我们都会在后面讲到。
+- **Share**(共享):多个线程可同时执行,如` CountDownLatch`、`Semaphore`、 `CyclicBarrier`、`ReadWriteLock` 我们都会在后面讲到。
`ReentrantReadWriteLock` 可以看成是组合式,因为 `ReentrantReadWriteLock` 也就是读写锁允许多个线程同时对某一资源进行读。
From f6a41b9696787a89f179499e8004b7bc70c72be8 Mon Sep 17 00:00:00 2001
From: vcjmhg
Date: Wed, 14 Apr 2021 15:45:17 +0800
Subject: [PATCH 04/11] =?UTF-8?q?=E6=AD=A4=E5=A4=84=E7=9A=84=E6=AD=BB?=
=?UTF-8?q?=E9=94=81=E6=94=B9=E6=88=90=E8=BF=9B=E7=A8=8B=E9=98=BB=E5=A1=9E?=
=?UTF-8?q?=E6=98=AF=E5=90=A6=E4=BC=9A=E6=9B=B4=E5=A5=BD=E5=91=A2=EF=BC=9F?=
=?UTF-8?q?=EF=BC=9F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
此处按照周志明老师《深入理解JVM虚拟机》第三版第七章虚拟机类的加载机制P279页的描述,此处可能会有的问题如果`()`方法中有耗时很长的操作,其他进程由于无法获得锁会进入阻塞队列中一直等待。而死锁的定义是**指两个或两个以上的进程在执行过程中,由于竞争资源或者由于彼此通信而造成的一种阻塞的现象,若无外力作用,它们都将无法推进下去。** 而这里如果只是耗时时间过长的话并不会进入死锁,而是长时间处于阻塞队列中,耗时操作执行完成后,其他进程还是会正常执行下去。
所以这里使用进程阻塞是否会更好呢??
---
...\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md" | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git "a/docs/java/jvm/\347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md" "b/docs/java/jvm/\347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md"
index cd04e42af54..e3369879b0d 100644
--- "a/docs/java/jvm/\347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md"
+++ "b/docs/java/jvm/\347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md"
@@ -70,7 +70,7 @@ Class 文件需要加载到虚拟机中之后才能运行和使用,那么虚
初始化是类加载的最后一步,也是真正执行类中定义的 Java 程序代码(字节码),初始化阶段是执行初始化方法 ` ()`方法的过程。
-对于` ()` 方法的调用,虚拟机会自己确保其在多线程环境中的安全性。因为 ` ()` 方法是带锁线程安全,所以在多线程环境下进行类初始化的话可能会引起死锁,并且这种死锁很难被发现。
+对于` ()` 方法的调用,虚拟机会自己确保其在多线程环境中的安全性。因为 ` ()` 方法是带锁线程安全,所以在多线程环境下进行类初始化的话可能会引起多个进程阻塞,并且这种阻塞很难被发现。
对于初始化阶段,虚拟机严格规范了有且只有5种情况下,必须对类进行初始化(只有主动去使用类才会初始化类):
From e410eb104a487520ff67295fff276b28c165f078 Mon Sep 17 00:00:00 2001
From: lyrl
Date: Thu, 22 Apr 2021 10:17:33 +0800
Subject: [PATCH 05/11] escape
---
...07\345\260\261\345\244\237\344\272\206.md" | 32 +++++++++----------
1 file changed, 16 insertions(+), 16 deletions(-)
diff --git "a/docs/system-design/distributed-system/message-queue/RabbitMQ\345\205\245\351\227\250\347\234\213\350\277\231\344\270\200\347\257\207\345\260\261\345\244\237\344\272\206.md" "b/docs/system-design/distributed-system/message-queue/RabbitMQ\345\205\245\351\227\250\347\234\213\350\277\231\344\270\200\347\257\207\345\260\261\345\244\237\344\272\206.md"
index 79f24fdcc30..83a1ed80525 100644
--- "a/docs/system-design/distributed-system/message-queue/RabbitMQ\345\205\245\351\227\250\347\234\213\350\277\231\344\270\200\347\257\207\345\260\261\345\244\237\344\272\206.md"
+++ "b/docs/system-design/distributed-system/message-queue/RabbitMQ\345\205\245\351\227\250\347\234\213\350\277\231\344\270\200\347\257\207\345\260\261\345\244\237\344\272\206.md"
@@ -1,21 +1,21 @@
- [一文搞懂 RabbitMQ 的重要概念以及安装](#一文搞懂-rabbitmq-的重要概念以及安装)
- - [一 RabbitMQ 介绍](#一-rabbitmq-介绍)
- - [1.1 RabbitMQ 简介](#11-rabbitmq-简介)
- - [1.2 RabbitMQ 核心概念](#12-rabbitmq-核心概念)
- - [1.2.1 Producer(生产者) 和 Consumer(消费者)](#121-producer生产者-和-consumer消费者)
- - [1.2.2 Exchange(交换器)](#122-exchange交换器)
- - [1.2.3 Queue(消息队列)](#123-queue消息队列)
- - [1.2.4 Broker(消息中间件的服务节点)](#124-broker消息中间件的服务节点)
- - [1.2.5 Exchange Types(交换器类型)](#125-exchange-types交换器类型)
- - [① fanout](#①-fanout)
- - [② direct](#②-direct)
- - [③ topic](#③-topic)
- - [④ headers(不推荐)](#④-headers不推荐)
- - [二 安装 RabbitMq](#二-安装-rabbitmq)
- - [2.1 安装 erlang](#21-安装-erlang)
- - [2.2 安装 RabbitMQ](#22-安装-rabbitmq)
+ - [一 RabbitMQ 介绍](#一-rabbitmq-介绍)
+ - [1.1 RabbitMQ 简介](#11-rabbitmq-简介)
+ - [1.2 RabbitMQ 核心概念](#12-rabbitmq-核心概念)
+ - [1.2.1 Producer(生产者) 和 Consumer(消费者)](#121-producer生产者-和-consumer消费者)
+ - [1.2.2 Exchange(交换器)](#122-exchange交换器)
+ - [1.2.3 Queue(消息队列)](#123-queue消息队列)
+ - [1.2.4 Broker(消息中间件的服务节点)](#124-broker消息中间件的服务节点)
+ - [1.2.5 Exchange Types(交换器类型)](#125-exchange-types交换器类型)
+ - [① fanout](#-fanout)
+ - [② direct](#-direct)
+ - [③ topic](#-topic)
+ - [④ headers(不推荐)](#-headers不推荐)
+ - [二 安装 RabbitMq](#二-安装-rabbitmq)
+ - [2.1 安装 erlang](#21-安装-erlang)
+ - [2.2 安装 RabbitMQ](#22-安装-rabbitmq)
@@ -123,7 +123,7 @@ direct 类型常用在处理有优先级的任务,根据任务的优先级把
- RoutingKey 为一个点号“.”分隔的字符串(被点号“.”分隔开的每一段独立的字符串称为一个单词),如 “com.rabbitmq.client”、“java.util.concurrent”、“com.hidden.client”;
- BindingKey 和 RoutingKey 一样也是点号“.”分隔的字符串;
-- BindingKey 中可以存在两种特殊字符串“*”和“#”,用于做模糊匹配,其中“*”用于匹配一个单词,“#”用于匹配多个单词(可以是零个)。
+- BindingKey 中可以存在两种特殊字符串“\*”和“#”,用于做模糊匹配,其中“\*”用于匹配一个单词,“#”用于匹配多个单词(可以是零个)。

From f521cf869883c3c6bf40cdf2924a2ed54b20f4b0 Mon Sep 17 00:00:00 2001
From: sunguoliang
Date: Fri, 23 Apr 2021 09:40:32 +0800
Subject: [PATCH 06/11] =?UTF-8?q?=E9=9D=99=E6=80=81=E6=96=B9=E6=B3=95?=
=?UTF-8?q?=E8=B0=83=E7=94=A8=E9=9D=9E=E9=9D=99=E6=80=81=E6=88=90=E5=91=98?=
=?UTF-8?q?=E8=A1=A8=E8=BF=B0=E4=B8=8D=E5=87=86=E7=A1=AE?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../Java\345\237\272\347\241\200\347\237\245\350\257\206.md" | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git "a/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 86e233be265..2aea1f50f2e 100644
--- "a/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -790,7 +790,7 @@ public void f5(int a) {
### 在一个静态方法内调用一个非静态成员为什么是非法的?
-由于静态方法可以不通过对象进行调用,因此在静态方法里,不能调用其他非静态变量,也不可以访问非静态变量成员。
+这个需要结合 JVM 的相关知识,静态方法是属于类的,在类加载的时候就会分配内存,可以通过类名直接访问。而非静态成员属于实例对象,只有在对象实例化之后才存在,然后通过类的实例对象去访问。在类的非静态成员不存在的时候静态成员就已经存在了,此时调用在内存中还不存在的非静态成员,属于非法操作。
### 静态方法和实例方法有何不同?
From 6f20b1d4252e1b32adff8c1fd0b0c7a30407ec7e Mon Sep 17 00:00:00 2001
From: zhangkai
Date: Fri, 23 Apr 2021 12:10:44 +0800
Subject: [PATCH 07/11] =?UTF-8?q?fix:=20Dao=E6=8E=A5=E5=8F=A3=E4=B8=AD?=
=?UTF-8?q?=E6=96=B9=E6=B3=95=E9=87=8D=E8=BD=BD=E7=9A=84=E8=A1=A5=E5=85=85?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../framework/mybatis/mybatis-interview.md | 75 +++++++++++++++++++
1 file changed, 75 insertions(+)
diff --git a/docs/system-design/framework/mybatis/mybatis-interview.md b/docs/system-design/framework/mybatis/mybatis-interview.md
index 01023d3cc55..9b68d75e8a7 100644
--- a/docs/system-design/framework/mybatis/mybatis-interview.md
+++ b/docs/system-design/framework/mybatis/mybatis-interview.md
@@ -68,6 +68,81 @@ public interface StuMapper {
Dao 接口的工作原理是 JDK 动态代理,MyBatis 运行时会使用 JDK 动态代理为 Dao 接口生成代理 proxy 对象,代理对象 proxy 会拦截接口方法,转而执行`MappedStatement`所代表的 sql,然后将 sql 执行结果返回。
+##### ==补充:==
+
+Dao接口方法可以重载,但是需要满足以下条件:
+
+1. 仅有一个无参方法和一个有参方法
+2. 多个有参方法时,参数数量必须一致。且使用相同的 `@Param` ,或者使用 `param1` 这种
+
+测试如下:
+
+`PersonDao.java`
+
+```java
+Person queryById();
+
+Person queryById(@Param("id") Long id);
+
+Person queryById(@Param("id") Long id, @Param("name") String name);
+```
+
+`PersonMapper.xml`
+
+```xml
+
+```
+
+`org.apache.ibatis.scripting.xmltags.DynamicContext.ContextAccessor#getProperty`方法用于获取``标签中的条件值
+
+```java
+public Object getProperty(Map context, Object target, Object name) {
+ Map map = (Map) target;
+
+ Object result = map.get(name);
+ if (map.containsKey(name) || result != null) {
+ return result;
+ }
+
+ Object parameterObject = map.get(PARAMETER_OBJECT_KEY);
+ if (parameterObject instanceof Map) {
+ return ((Map)parameterObject).get(name);
+ }
+
+ return null;
+}
+```
+
+`parameterObject`为map,存放的是Dao接口中参数相关信息。
+
+`((Map)parameterObject).get(name)`方法如下
+
+```java
+public V get(Object key) {
+ if (!super.containsKey(key)) {
+ throw new BindingException("Parameter '" + key + "' not found. Available parameters are " + keySet());
+ }
+ return super.get(key);
+}
+```
+
+1. `queryById()`方法执行时,`parameterObject`为null,`getProperty`方法返回null值,``标签获取的所有条件值都为null,所有条件不成立,动态sql可以正常执行。
+2. `queryById(1L)`方法执行时,`parameterObject`为map,包含了`id`和`param1`两个key值。当获取``标签中`name`的属性值时,进入`((Map)parameterObject).get(name)`方法中,map中key不包含`name`,所以抛出异常。
+3. `queryById(1L,"1")`方法执行时,`parameterObject`中包含`id`,`param1`,`name`,`param2`四个key值,`id`和`name`属性都可以获取到,动态sql正常执行。
+
#### 4、MyBatis 是如何进行分页的?分页插件的原理是什么?
注:我出的。
From c869b54f5eca5c5e7992ebe786543c48dffb318d Mon Sep 17 00:00:00 2001
From: guide
Date: Sun, 25 Apr 2021 10:47:44 +0800
Subject: [PATCH 08/11] =?UTF-8?q?Update=20Java=E5=9F=BA=E7=A1=80=E7=9F=A5?=
=?UTF-8?q?=E8=AF=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...72\347\241\200\347\237\245\350\257\206.md" | 138 ++----------------
1 file changed, 9 insertions(+), 129 deletions(-)
diff --git "a/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 2aea1f50f2e..94893cb57ed 100644
--- "a/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -64,70 +64,10 @@
- [Java 中 IO 流分为几种?](#java-中-io-流分为几种)
- [既然有了字节流,为什么还要有字符流?](#既然有了字节流为什么还要有字符流)
- [4. 参考](#4-参考)
- - [Java 语言有哪些特点?](#java-语言有哪些特点-1)
- - [JVM vs JDK vs JRE](#jvm-vs-jdk-vs-jre-1)
- - [JVM](#jvm-1)
- - [JDK 和 JRE](#jdk-和-jre-1)
- - [为什么说 Java 语言“编译与解释并存”?](#为什么说-java-语言编译与解释并存-1)
- - [Oracle JDK 和 OpenJDK 的对比](#oracle-jdk-和-openjdk-的对比-1)
- - [Java 和 C++的区别?](#java-和-c的区别-1)
- - [import java 和 javax 有什么区别?](#import-java-和-javax-有什么区别-1)
-- [基本语法](#基本语法-1)
- - [字符型常量和字符串常量的区别?](#字符型常量和字符串常量的区别-1)
- - [注释](#注释-1)
- - [标识符和关键字的区别是什么?](#标识符和关键字的区别是什么-1)
- - [Java 中有哪些常见的关键字?](#java-中有哪些常见的关键字-1)
- - [自增自减运算符](#自增自减运算符-1)
- - [continue、break、和 return 的区别是什么?](#continue-break-和-return-的区别是什么-1)
- - [Java 泛型了解么?什么是类型擦除?介绍一下常用的通配符?](#java-泛型了解么什么是类型擦除介绍一下常用的通配符-1)
- - [==和 equals 的区别](#和-equals-的区别-1)
- - [hashCode()与 equals()](#hashcode与-equals-1)
-- [基本数据类型](#基本数据类型-1)
- - [Java 中的几种基本数据类型是什么?对应的包装类型是什么?各自占用多少字节呢?](#java-中的几种基本数据类型是什么对应的包装类型是什么各自占用多少字节呢-1)
- - [自动装箱与拆箱](#自动装箱与拆箱-1)
- - [8 种基本类型的包装类和常量池](#8-种基本类型的包装类和常量池-1)
-- [方法(函数)](#方法函数-1)
- - [什么是方法的返回值?](#什么是方法的返回值-1)
- - [方法有哪几种类型?](#方法有哪几种类型-1)
- - [在一个静态方法内调用一个非静态成员为什么是非法的?](#在一个静态方法内调用一个非静态成员为什么是非法的-1)
- - [静态方法和实例方法有何不同?](#静态方法和实例方法有何不同-1)
- - [为什么 Java 中只有值传递?](#为什么-java-中只有值传递-1)
- - [重载和重写的区别](#重载和重写的区别-1)
- - [重载](#重载-1)
- - [重写](#重写-1)
- - [深拷贝 vs 浅拷贝](#深拷贝-vs-浅拷贝-1)
-- [Java 面向对象](#java-面向对象-1)
- - [面向对象和面向过程的区别](#面向对象和面向过程的区别-1)
- - [成员变量与局部变量的区别有哪些?](#成员变量与局部变量的区别有哪些-1)
- - [创建一个对象用什么运算符?对象实体与对象引用有何不同?](#创建一个对象用什么运算符对象实体与对象引用有何不同-1)
- - [对象的相等与指向他们的引用相等,两者有什么不同?](#对象的相等与指向他们的引用相等两者有什么不同-1)
- - [一个类的构造方法的作用是什么? 若一个类没有声明构造方法,该程序能正确执行吗? 为什么?](#一个类的构造方法的作用是什么-若一个类没有声明构造方法该程序能正确执行吗-为什么-1)
- - [构造方法有哪些特点?是否可被 override?](#构造方法有哪些特点是否可被-override-1)
- - [面向对象三大特征](#面向对象三大特征-1)
- - [封装](#封装-1)
- - [继承](#继承-1)
- - [多态](#多态-1)
- - [String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?](#string-stringbuffer-和-stringbuilder-的区别是什么-string-为什么是不可变的-1)
- - [Object 类的常见方法总结](#object-类的常见方法总结-1)
-- [反射](#反射-1)
- - [何为反射?](#何为反射-1)
- - [反射机制优缺点](#反射机制优缺点-1)
- - [反射的应用场景](#反射的应用场景-1)
-- [异常](#异常-1)
- - [Java 异常类层次结构图](#java-异常类层次结构图-1)
- - [Throwable 类常用方法](#throwable-类常用方法-1)
- - [try-catch-finally](#try-catch-finally-1)
- - [使用 `try-with-resources` 来代替`try-catch-finally`](#使用-try-with-resources-来代替try-catch-finally-1)
-- [I\O 流](#io-流-1)
- - [什么是序列化?什么是反序列化?](#什么是序列化什么是反序列化-1)
- - [Java 序列化中如果有些字段不想进行序列化,怎么办?](#java-序列化中如果有些字段不想进行序列化怎么办-1)
- - [获取用键盘输入常用的两种方法](#获取用键盘输入常用的两种方法-1)
- - [Java 中 IO 流分为几种?](#java-中-io-流分为几种-1)
- - [既然有了字节流,为什么还要有字符流?](#既然有了字节流为什么还要有字符流-1)
-- [4. 参考](#4-参考-1)
+<<<<<<< HEAD
## 基础概念与常识
### Java 语言有哪些特点?
@@ -1387,81 +1327,21 @@ try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new F
- **序列化**: 将数据结构或对象转换成二进制字节流的过程
- **反序列化**:将在序列化过程中所生成的二进制字节流的过程转换成数据结构或者对象的过程
+=======
+这篇文章
+>>>>>>> Update Java基础知识.md
-对于 Java 这种面向对象编程语言来说,我们序列化的都是对象(Object)也就是实例化后的类(Class),但是在 C++这种半面向对象的语言中,struct(结构体)定义的是数据结构类型,而 class 对应的是对象类型。
-
-维基百科是如是介绍序列化的:
-
-> **序列化**(serialization)在计算机科学的数据处理中,是指将数据结构或对象状态转换成可取用格式(例如存成文件,存于缓冲,或经由网络中发送),以留待后续在相同或另一台计算机环境中,能恢复原先状态的过程。依照序列化格式重新获取字节的结果时,可以利用它来产生与原始对象相同语义的副本。对于许多对象,像是使用大量引用的复杂对象,这种序列化重建的过程并不容易。面向对象中的对象序列化,并不概括之前原始对象所关系的函数。这种过程也称为对象编组(marshalling)。从一系列字节提取数据结构的反向操作,是反序列化(也称为解编组、deserialization、unmarshalling)。
-
-综上:**序列化的主要目的是通过网络传输对象或者说是将对象存储到文件系统、数据库、内存中。**
-
-
-
-https://www.corejavaguru.com/java/serialization/interview-questions-1
-
-### Java 序列化中如果有些字段不想进行序列化,怎么办?
-
-`对于不想进行序列化的变量,使用`transient`关键字修饰。`
-
-`transient` 关键字的作用是:阻止实例中那些用此关键字修饰的的变量序列化;当对象被反序列化时,被 `transient` 修饰的变量值不会被持久化和恢复。`transient` 只能修饰变量,不能修饰类和方法。
-
-### 获取用键盘输入常用的两种方法
-
-方法 1:通过 `Scanner`
-
-```java
-Scanner input = new Scanner(System.in);
-String s = input.nextLine();
-input.close();
-```
-
-方法 2:通过 `BufferedReader`
-
-```java
-BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
-String s = input.readLine();
-```
-### Java 中 IO 流分为几种?
-
-- 按照流的流向分,可以分为输入流和输出流;
-- 按照操作单元划分,可以划分为字节流和字符流;
-- 按照流的角色划分为节点流和处理流。
-
-Java Io 流共涉及 40 多个类,这些类看上去很杂乱,但实际上很有规则,而且彼此之间存在非常紧密的联系, Java I0 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。
-
-- InputStream/Reader: 所有的输入流的基类,前者是字节输入流,后者是字符输入流。
-- OutputStream/Writer: 所有输出流的基类,前者是字节输出流,后者是字符输出流。
-
-按操作方式分类结构图:
-
-
-
-按操作对象分类结构图:
-
-
-
-### 既然有了字节流,为什么还要有字符流?
-
-问题本质想问:**不管是文件读写还是网络发送接收,信息的最小存储单元都是字节,那为什么 I/O 流操作要分为字节流操作和字符流操作呢?**
-
-回答:字符流是由 Java 虚拟机将字节转换得到的,问题就出在这个过程还算是非常耗时,并且,如果我们不知道编码类型就很容易出现乱码问题。所以, I/O 流就干脆提供了一个直接操作字符的接口,方便我们平时对字符进行流操作。如果音频文件、图片等媒体文件用字节流比较好,如果涉及到字符的话使用字符流比较好。
-
-## 4. 参考
-
-- https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre
-- https://www.educba.com/oracle-vs-openjdk/
-- https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk?answertab=active#tab-top## 基础概念与常识
+## 基础概念与常识
### Java 语言有哪些特点?
1. 简单易学;
2. 面向对象(封装,继承,多态);
3. 平台无关性( Java 虚拟机实现平台无关性);
-4. 可靠性;
-5. 安全性;
-6. 支持多线程( C++ 语言没有内置的多线程机制,因此必须调用操作系统的多线程功能来进行多线程程序设计,而 Java 语言却提供了多线程支持);
+4. 支持多线程( C++ 语言没有内置的多线程机制,因此必须调用操作系统的多线程功能来进行多线程程序设计,而 Java 语言却提供了多线程支持);
+5. 可靠性;
+6. 安全性;
7. 支持网络编程并且很方便( Java 语言诞生本身就是为简化网络编程设计的,因此 Java 语言不仅支持网络编程而且很方便);
8. 编译与解释并存;
@@ -2776,4 +2656,4 @@ Java Io 流共涉及 40 多个类,这些类看上去很杂乱,但实际上
- https://stackoverflow.com/questions/1906445/what-is-the-difference-between-jdk-and-jre
- https://www.educba.com/oracle-vs-openjdk/
-- https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk?answertab=active#tab-top
\ No newline at end of file
+- https://stackoverflow.com/questions/22358071/differences-between-oracle-jdk-and-openjdk?answertab=active#tab-top## 基础概念与常识
\ No newline at end of file
From c3212de2475a295aba6ca37a1302d77ffa6c823c Mon Sep 17 00:00:00 2001
From: guide
Date: Sun, 25 Apr 2021 10:49:32 +0800
Subject: [PATCH 09/11] =?UTF-8?q?Update=20Java=E5=9F=BA=E7=A1=80=E7=9F=A5?=
=?UTF-8?q?=E8=AF=86.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...72\347\241\200\347\237\245\350\257\206.md" | 1267 +----------------
1 file changed, 1 insertion(+), 1266 deletions(-)
diff --git "a/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md" "b/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
index 94893cb57ed..14cc3d83da7 100644
--- "a/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
+++ "b/docs/java/basis/Java\345\237\272\347\241\200\347\237\245\350\257\206.md"
@@ -67,1271 +67,6 @@
-<<<<<<< HEAD
-## 基础概念与常识
-
-### Java 语言有哪些特点?
-
-1. 简单易学;
-2. 面向对象(封装,继承,多态);
-3. 平台无关性( Java 虚拟机实现平台无关性);
-4. 可靠性;
-5. 安全性;
-6. 支持多线程( C++ 语言没有内置的多线程机制,因此必须调用操作系统的多线程功能来进行多线程程序设计,而 Java 语言却提供了多线程支持);
-7. 支持网络编程并且很方便( Java 语言诞生本身就是为简化网络编程设计的,因此 Java 语言不仅支持网络编程而且很方便);
-8. 编译与解释并存;
-
-> 修正(参见: [issue#544](https://github.com/Snailclimb/JavaGuide/issues/544)):C++11 开始(2011 年的时候),C++就引入了多线程库,在 windows、linux、macos 都可以使用`std::thread`和`std::async`来创建线程。参考链接:http://www.cplusplus.com/reference/thread/thread/?kw=thread
-
-### JVM vs JDK vs JRE
-
-#### JVM
-
-Java 虚拟机(JVM)是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现(Windows,Linux,macOS),目的是使用相同的字节码,它们都会给出相同的结果。
-
-**什么是字节码?采用字节码的好处是什么?**
-
-> 在 Java 中,JVM 可以理解的代码就叫做`字节码`(即扩展名为 `.class` 的文件),它不面向任何特定的处理器,只面向虚拟机。Java 语言通过字节码的方式,在一定程度上解决了传统解释型语言执行效率低的问题,同时又保留了解释型语言可移植的特点。所以 Java 程序运行时比较高效,而且,由于字节码并不针对一种特定的机器,因此,Java 程序无须重新编译便可在多种不同操作系统的计算机上运行。
-
-**Java 程序从源代码到运行一般有下面 3 步:**
-
-
-
-我们需要格外注意的是 .class->机器码 这一步。在这一步 JVM 类加载器首先加载字节码文件,然后通过解释器逐行解释执行,这种方式的执行速度会相对比较慢。而且,有些方法和代码块是经常需要被调用的(也就是所谓的热点代码),所以后面引进了 JIT 编译器,而 JIT 属于运行时编译。当 JIT 编译器完成第一次编译后,其会将字节码对应的机器码保存下来,下次可以直接使用。而我们知道,机器码的运行效率肯定是高于 Java 解释器的。这也解释了我们为什么经常会说 Java 是编译与解释共存的语言。
-
-> HotSpot 采用了惰性评估(Lazy Evaluation)的做法,根据二八定律,消耗大部分系统资源的只有那一小部分的代码(热点代码),而这也就是 JIT 所需要编译的部分。JVM 会根据代码每次被执行的情况收集信息并相应地做出一些优化,因此执行的次数越多,它的速度就越快。JDK 9 引入了一种新的编译模式 AOT(Ahead of Time Compilation),它是直接将字节码编译成机器码,这样就避免了 JIT 预热等各方面的开销。JDK 支持分层编译和 AOT 协作使用。但是 ,AOT 编译器的编译质量是肯定比不上 JIT 编译器的。
-
-**总结:**
-
-Java 虚拟机(JVM)是运行 Java 字节码的虚拟机。JVM 有针对不同系统的特定实现(Windows,Linux,macOS),目的是使用相同的字节码,它们都会给出相同的结果。字节码和不同系统的 JVM 实现是 Java 语言“一次编译,随处可以运行”的关键所在。
-
-#### JDK 和 JRE
-
-JDK 是 Java Development Kit 缩写,它是功能齐全的 Java SDK。它拥有 JRE 所拥有的一切,还有编译器(javac)和工具(如 javadoc 和 jdb)。它能够创建和编译程序。
-
-JRE 是 Java 运行时环境。它是运行已编译 Java 程序所需的所有内容的集合,包括 Java 虚拟机(JVM),Java 类库,java 命令和其他的一些基础构件。但是,它不能用于创建新程序。
-
-如果你只是为了运行一下 Java 程序的话,那么你只需要安装 JRE 就可以了。如果你需要进行一些 Java 编程方面的工作,那么你就需要安装 JDK 了。但是,这不是绝对的。有时,即使您不打算在计算机上进行任何 Java 开发,仍然需要安装 JDK。例如,如果要使用 JSP 部署 Web 应用程序,那么从技术上讲,您只是在应用程序服务器中运行 Java 程序。那你为什么需要 JDK 呢?因为应用程序服务器会将 JSP 转换为 Java servlet,并且需要使用 JDK 来编译 servlet。
-
-### 为什么说 Java 语言“编译与解释并存”?
-
-高级编程语言按照程序的执行方式分为编译型和解释型两种。简单来说,编译型语言是指编译器针对特定的操作系统将源代码一次性翻译成可被该平台执行的机器码;解释型语言是指解释器对源程序逐行解释成特定平台的机器码并立即执行。比如,你想阅读一本英文名著,你可以找一个英文翻译人员帮助你阅读,
-有两种选择方式,你可以先等翻译人员将全本的英文名著(也就是源码)都翻译成汉语,再去阅读,也可以让翻译人员翻译一段,你在旁边阅读一段,慢慢把书读完。
-
-Java 语言既具有编译型语言的特征,也具有解释型语言的特征,因为 Java 程序要经过先编译,后解释两个步骤,由 Java 编写的程序需要先经过编译步骤,生成字节码(`\*.class` 文件),这种字节码必须由 Java 解释器来解释执行。因此,我们可以认为 Java 语言编译与解释并存。
-
-### Oracle JDK 和 OpenJDK 的对比
-
-可能在看这个问题之前很多人和我一样并没有接触和使用过 OpenJDK 。那么 Oracle 和 OpenJDK 之间是否存在重大差异?下面我通过收集到的一些资料,为你解答这个被很多人忽视的问题。
-
-对于 Java 7,没什么关键的地方。OpenJDK 项目主要基于 Sun 捐赠的 HotSpot 源代码。此外,OpenJDK 被选为 Java 7 的参考实现,由 Oracle 工程师维护。关于 JVM,JDK,JRE 和 OpenJDK 之间的区别,Oracle 博客帖子在 2012 年有一个更详细的答案:
-
-> 问:OpenJDK 存储库中的源代码与用于构建 Oracle JDK 的代码之间有什么区别?
->
-> 答:非常接近 - 我们的 Oracle JDK 版本构建过程基于 OpenJDK 7 构建,只添加了几个部分,例如部署代码,其中包括 Oracle 的 Java 插件和 Java WebStart 的实现,以及一些封闭的源代码派对组件,如图形光栅化器,一些开源的第三方组件,如 Rhino,以及一些零碎的东西,如附加文档或第三方字体。展望未来,我们的目的是开源 Oracle JDK 的所有部分,除了我们考虑商业功能的部分。
-
-**总结:**
-
-1. Oracle JDK 大概每 6 个月发一次主要版本,而 OpenJDK 版本大概每三个月发布一次。但这不是固定的,我觉得了解这个没啥用处。详情参见:[https://blogs.oracle.com/java-platform-group/update-and-faq-on-the-java-se-release-cadence](https://blogs.oracle.com/java-platform-group/update-and-faq-on-the-java-se-release-cadence) 。
-2. OpenJDK 是一个参考模型并且是完全开源的,而 Oracle JDK 是 OpenJDK 的一个实现,并不是完全开源的;
-3. Oracle JDK 比 OpenJDK 更稳定。OpenJDK 和 Oracle JDK 的代码几乎相同,但 Oracle JDK 有更多的类和一些错误修复。因此,如果您想开发企业/商业软件,我建议您选择 Oracle JDK,因为它经过了彻底的测试和稳定。某些情况下,有些人提到在使用 OpenJDK 可能会遇到了许多应用程序崩溃的问题,但是,只需切换到 Oracle JDK 就可以解决问题;
-4. 在响应性和 JVM 性能方面,Oracle JDK 与 OpenJDK 相比提供了更好的性能;
-5. Oracle JDK 不会为即将发布的版本提供长期支持,用户每次都必须通过更新到最新版本获得支持来获取最新版本;
-6. Oracle JDK 根据二进制代码许可协议获得许可,而 OpenJDK 根据 GPL v2 许可获得许可。
-
-### Java 和 C++的区别?
-
-我知道很多人没学过 C++,但是面试官就是没事喜欢拿咱们 Java 和 C++ 比呀!没办法!!!就算没学过 C++,也要记下来!
-
-- 都是面向对象的语言,都支持封装、继承和多态
-- Java 不提供指针来直接访问内存,程序内存更加安全
-- Java 的类是单继承的,C++ 支持多重继承;虽然 Java 的类不可以多继承,但是接口可以多继承。
-- Java 有自动内存管理垃圾回收机制(GC),不需要程序员手动释放无用内存。
-- C ++同时支持方法重载和操作符重载,但是 Java 只支持方法重载(操作符重载增加了复杂性,这与 Java 最初的设计思想不符)。
-- ......
-
-### import java 和 javax 有什么区别?
-
-刚开始的时候 JavaAPI 所必需的包是 java 开头的包,javax 当时只是扩展 API 包来使用。然而随着时间的推移,javax 逐渐地扩展成为 Java API 的组成部分。但是,将扩展从 javax 包移动到 java 包确实太麻烦了,最终会破坏一堆现有的代码。因此,最终决定 javax 包将成为标准 API 的一部分。
-
-所以,实际上 java 和 javax 没有区别。这都是一个名字。
-
-## 基本语法
-
-### 字符型常量和字符串常量的区别?
-
-1. **形式** : 字符常量是单引号引起的一个字符,字符串常量是双引号引起的 0 个或若干个字符
-2. **含义** : 字符常量相当于一个整型值( ASCII 值),可以参加表达式运算; 字符串常量代表一个地址值(该字符串在内存中存放位置)
-3. **占内存大小** : 字符常量只占 2 个字节; 字符串常量占若干个字节 (**注意: char 在 Java 中占两个字节**),
-
- > 字符封装类 `Character` 有一个成员常量 `Character.SIZE` 值为 16,单位是`bits`,该值除以 8(`1byte=8bits`)后就可以得到 2 个字节
-
-> java 编程思想第四版:2.2.2 节
-> 
-
-### 注释
-
-Java 中的注释有三种:
-
-1. 单行注释
-
-2. 多行注释
-
-3. 文档注释。
-
-在我们编写代码的时候,如果代码量比较少,我们自己或者团队其他成员还可以很轻易地看懂代码,但是当项目结构一旦复杂起来,我们就需要用到注释了。注释并不会执行(编译器在编译代码之前会把代码中的所有注释抹掉,字节码中不保留注释),是我们程序员写给自己看的,注释是你的代码说明书,能够帮助看代码的人快速地理清代码之间的逻辑关系。因此,在写程序的时候随手加上注释是一个非常好的习惯。
-
-《Clean Code》这本书明确指出:
-
-> **代码的注释不是越详细越好。实际上好的代码本身就是注释,我们要尽量规范和美化自己的代码来减少不必要的注释。**
->
-> **若编程语言足够有表达力,就不需要注释,尽量通过代码来阐述。**
->
-> 举个例子:
->
-> 去掉下面复杂的注释,只需要创建一个与注释所言同一事物的函数即可
->
-> ```java
-> // check to see if the employee is eligible for full benefits
-> if ((employee.flags & HOURLY_FLAG) && (employee.age > 65))
-> ```
->
-> 应替换为
->
-> ```java
-> if (employee.isEligibleForFullBenefits())
-> ```
-
-### 标识符和关键字的区别是什么?
-
-在我们编写程序的时候,需要大量地为程序、类、变量、方法等取名字,于是就有了标识符,简单来说,标识符就是一个名字。但是有一些标识符,Java 语言已经赋予了其特殊的含义,只能用于特定的地方,这种特殊的标识符就是关键字。因此,关键字是被赋予特殊含义的标识符。比如,在我们的日常生活中 ,“警察局”这个名字已经被赋予了特殊的含义,所以如果你开一家店,店的名字不能叫“警察局”,“警察局”就是我们日常生活中的关键字。
-
-### Java 中有哪些常见的关键字?
-
-| 访问控制 | private | protected | public | | | | |
-| -------------------- | -------- | ---------- | -------- | ------------ | ---------- | --------- | ------ |
-| 类,方法和变量修饰符 | abstract | class | extends | final | implements | interface | native |
-| | new | static | strictfp | synchronized | transient | volatile | |
-| 程序控制 | break | continue | return | do | while | if | else |
-| | for | instanceof | switch | case | default | | |
-| 错误处理 | try | catch | throw | throws | finally | | |
-| 包相关 | import | package | | | | | |
-| 基本类型 | boolean | byte | char | double | float | int | long |
-| | short | null | true | false | | | |
-| 变量引用 | super | this | void | | | | |
-| 保留字 | goto | const | | | | | |
-
-### 自增自减运算符
-
-在写代码的过程中,常见的一种情况是需要某个整数类型变量增加 1 或减少 1,Java 提供了一种特殊的运算符,用于这种表达式,叫做自增运算符(++)和自减运算符(--)。
-
-++和--运算符可以放在变量之前,也可以放在变量之后,当运算符放在变量之前时(前缀),先自增/减,再赋值;当运算符放在变量之后时(后缀),先赋值,再自增/减。例如,当 `b = ++a` 时,先自增(自己增加 1),再赋值(赋值给 b);当 `b = a++` 时,先赋值(赋值给 b),再自增(自己增加 1)。也就是,++a 输出的是 a+1 的值,a++输出的是 a 值。用一句口诀就是:“符号在前就先加/减,符号在后就后加/减”。
-
-### continue、break、和 return 的区别是什么?
-
-在循环结构中,当循环条件不满足或者循环次数达到要求时,循环会正常结束。但是,有时候可能需要在循环的过程中,当发生了某种条件之后 ,提前终止循环,这就需要用到下面几个关键词:
-
-1. continue :指跳出当前的这一次循环,继续下一次循环。
-2. break :指跳出整个循环体,继续执行循环下面的语句。
-
-return 用于跳出所在方法,结束该方法的运行。return 一般有两种用法:
-
-1. `return;` :直接使用 return 结束方法执行,用于没有返回值函数的方法
-2. `return value;` :return 一个特定值,用于有返回值函数的方法
-
-### Java 泛型了解么?什么是类型擦除?介绍一下常用的通配符?
-
-Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制,该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
-
-Java 的泛型是伪泛型,这是因为 Java 在编译期间,所有的泛型信息都会被擦掉,这也就是通常所说类型擦除 。
-
-```java
-List list = new ArrayList<>();
-
-list.add(12);
-//这里直接添加会报错
-list.add("a");
-Class extends List> clazz = list.getClass();
-Method add = clazz.getDeclaredMethod("add", Object.class);
-//但是通过反射添加,是可以的
-add.invoke(list, "kl");
-
-System.out.println(list);
-```
-
-泛型一般有三种使用方式:泛型类、泛型接口、泛型方法。
-
-**1.泛型类**:
-
-```java
-//此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
-//在实例化泛型类时,必须指定T的具体类型
-public class Generic{
-
- private T key;
-
- public Generic(T key) {
- this.key = key;
- }
-
- public T getKey(){
- return key;
- }
-}
-```
-
-如何实例化泛型类:
-
-```java
-Generic genericInteger = new Generic(123456);
-```
-
-**2.泛型接口** :
-
-```java
-public interface Generator {
- public T method();
-}
-```
-
-实现泛型接口,不指定类型:
-
-```java
-class GeneratorImpl implements Generator{
- @Override
- public T method() {
- return null;
- }
-}
-```
-
-实现泛型接口,指定类型:
-
-```java
-class GeneratorImpl implements Generator{
- @Override
- public String method() {
- return "hello";
- }
-}
-```
-
-**3.泛型方法** :
-
-```java
- public static < E > void printArray( E[] inputArray )
- {
- for ( E element : inputArray ){
- System.out.printf( "%s ", element );
- }
- System.out.println();
- }
-```
-
-使用:
-
-```java
-// 创建不同类型数组: Integer, Double 和 Character
-Integer[] intArray = { 1, 2, 3 };
-String[] stringArray = { "Hello", "World" };
-printArray( intArray );
-printArray( stringArray );
-```
-
-**常用的通配符为: T,E,K,V,?**
-
-- ? 表示不确定的 java 类型
-- T (type) 表示具体的一个 java 类型
-- K V (key value) 分别代表 java 键值中的 Key Value
-- E (element) 代表 Element
-
-### ==和 equals 的区别
-
-对于基本数据类型来说,==比较的是值。对于引用数据类型来说,==比较的是对象的内存地址。
-
-> 因为 Java 只有值传递,所以,对于 == 来说,不管是比较基本数据类型,还是引用数据类型的变量,其本质比较的都是值,只是引用类型变量存的值是对象的地址。
-
-**`equals()`** 作用不能用于判断基本数据类型的变量,只能用来判断两个对象是否相等。`equals()`方法存在于`Object`类中,而`Object`类是所有类的直接或间接父类。
-
-`Object` 类 `equals()` 方法:
-
-```java
-public boolean equals(Object obj) {
- return (this == obj);
-}
-```
-
-`equals()` 方法存在两种使用情况:
-
-- **类没有覆盖 `equals()`方法** :通过`equals()`比较该类的两个对象时,等价于通过“==”比较这两个对象,使用的默认是 `Object`类`equals()`方法。
-- **类覆盖了 `equals()`方法** :一般我们都覆盖 `equals()`方法来比较两个对象中的属性是否相等;若它们的属性相等,则返回 true(即,认为这两个对象相等)。
-
-**举个例子:**
-
-```java
-public class test1 {
- public static void main(String[] args) {
- String a = new String("ab"); // a 为一个引用
- String b = new String("ab"); // b为另一个引用,对象的内容一样
- String aa = "ab"; // 放在常量池中
- String bb = "ab"; // 从常量池中查找
- if (aa == bb) // true
- System.out.println("aa==bb");
- if (a == b) // false,非同一对象
- System.out.println("a==b");
- if (a.equals(b)) // true
- System.out.println("aEQb");
- if (42 == 42.0) { // true
- System.out.println("true");
- }
- }
-}
-```
-
-**说明:**
-
-- `String` 中的 `equals` 方法是被重写过的,因为 `Object` 的 `equals` 方法是比较的对象的内存地址,而 `String` 的 `equals` 方法比较的是对象的值。
-- 当创建 `String` 类型的对象时,虚拟机会在常量池中查找有没有已经存在的值和要创建的值相同的对象,如果有就把它赋给当前引用。如果没有就在常量池中重新创建一个 `String` 对象。
-
-`String`类`equals()`方法:
-
-```java
-public boolean equals(Object anObject) {
- if (this == anObject) {
- return true;
- }
- if (anObject instanceof String) {
- String anotherString = (String)anObject;
- int n = value.length;
- if (n == anotherString.value.length) {
- char v1[] = value;
- char v2[] = anotherString.value;
- int i = 0;
- while (n-- != 0) {
- if (v1[i] != v2[i])
- return false;
- i++;
- }
- return true;
- }
- }
- return false;
-}
-```
-
-### hashCode()与 equals()
-
-面试官可能会问你:“你重写过 `hashcode` 和 `equals`么,为什么重写 `equals` 时必须重写 `hashCode` 方法?”
-
-**1)hashCode()介绍:**
-
-`hashCode()` 的作用是获取哈希码,也称为散列码;它实际上是返回一个 int 整数。这个哈希码的作用是确定该对象在哈希表中的索引位置。`hashCode()`定义在 JDK 的 `Object` 类中,这就意味着 Java 中的任何类都包含有 `hashCode()` 函数。另外需要注意的是: `Object` 的 hashcode 方法是本地方法,也就是用 c 语言或 c++ 实现的,该方法通常用来将对象的 内存地址 转换为整数之后返回。
-
-```java
-public native int hashCode();
-```
-
-散列表存储的是键值对(key-value),它的特点是:能根据“键”快速的检索出对应的“值”。这其中就利用到了散列码!(可以快速找到所需要的对象)
-
-**2)为什么要有 hashCode?**
-
-我们以“`HashSet` 如何检查重复”为例子来说明为什么要有 hashCode?
-
-当你把对象加入 `HashSet` 时,`HashSet` 会先计算对象的 hashcode 值来判断对象加入的位置,同时也会与其他已经加入的对象的 hashcode 值作比较,如果没有相符的 hashcode,`HashSet` 会假设对象没有重复出现。但是如果发现有相同 hashcode 值的对象,这时会调用 `equals()` 方法来检查 hashcode 相等的对象是否真的相同。如果两者相同,`HashSet` 就不会让其加入操作成功。如果不同的话,就会重新散列到其他位置。(摘自我的 Java 启蒙书《Head First Java》第二版)。这样我们就大大减少了 equals 的次数,相应就大大提高了执行速度。
-
-**3)为什么重写 `equals` 时必须重写 `hashCode` 方法?**
-
-如果两个对象相等,则 hashcode 一定也是相同的。两个对象相等,对两个对象分别调用 equals 方法都返回 true。但是,两个对象有相同的 hashcode 值,它们也不一定是相等的 。**因此,equals 方法被覆盖过,则 `hashCode` 方法也必须被覆盖。**
-
-> `hashCode()`的默认行为是对堆上的对象产生独特值。如果没有重写 `hashCode()`,则该 class 的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)
-
-**4)为什么两个对象有相同的 hashcode 值,它们也不一定是相等的?**
-
-在这里解释一位小伙伴的问题。以下内容摘自《Head Fisrt Java》。
-
-因为 `hashCode()` 所使用的杂凑算法也许刚好会让多个对象传回相同的杂凑值。越糟糕的杂凑算法越容易碰撞,但这也与数据值域分布的特性有关(所谓碰撞也就是指的是不同的对象得到相同的 `hashCode`。
-
-我们刚刚也提到了 `HashSet`,如果 `HashSet` 在对比的时候,同样的 hashcode 有多个对象,它会使用 `equals()` 来判断是否真的相同。也就是说 `hashcode` 只是用来缩小查找成本。
-
-更多关于 `hashcode()` 和 `equals()` 的内容可以查看:[Java hashCode() 和 equals()的若干问题解答](https://www.cnblogs.com/skywang12345/p/3324958.html)
-
-## 基本数据类型
-
-### Java 中的几种基本数据类型是什么?对应的包装类型是什么?各自占用多少字节呢?
-
-Java 中有 8 种基本数据类型,分别为:
-
-1. 6 种数字类型 :`byte`、`short`、`int`、`long`、`float`、`double`
-2. 1 种字符类型:`char`
-3. 1 种布尔型:`boolean`。
-
-这 8 种基本数据类型的默认值以及所占空间的大小如下:
-
-| 基本类型 | 位数 | 字节 | 默认值 |
-| :-------- | :--- | :--- | :------ |
-| `int` | 32 | 4 | 0 |
-| `short` | 16 | 2 | 0 |
-| `long` | 64 | 8 | 0L |
-| `byte` | 8 | 1 | 0 |
-| `char` | 16 | 2 | 'u0000' |
-| `float` | 32 | 4 | 0f |
-| `double` | 64 | 8 | 0d |
-| `boolean` | 1 | | false |
-
-另外,对于 `boolean`,官方文档未明确定义,它依赖于 JVM 厂商的具体实现。逻辑上理解是占用 1 位,但是实际中会考虑计算机高效存储因素。
-
-**注意:**
-
-1. Java 里使用 `long` 类型的数据一定要在数值后面加上 **L**,否则将作为整型解析。
-2. `char a = 'h'`char :单引号,`String a = "hello"` :双引号。
-
-这八种基本类型都有对应的包装类分别为:`Byte`、`Short`、`Integer`、`Long`、`Float`、`Double`、`Character`、`Boolean` 。
-
-包装类型不赋值就是 `Null` ,而基本类型有默认值且不是 `Null`。
-
-另外,这个问题建议还可以先从 JVM 层面来分析。
-
-基本数据类型直接存放在 Java 虚拟机栈中的局部变量表中,而包装类型属于对象类型,我们知道对象实例都存在于堆中。相比于对象类型, 基本数据类型占用的空间非常小。
-
-> 《深入理解 Java 虚拟机》 :局部变量表主要存放了编译期可知的基本数据类型**(boolean、byte、char、short、int、float、long、double)**、**对象引用**(reference 类型,它不同于对象本身,可能是一个指向对象起始地址的引用指针,也可能是指向一个代表对象的句柄或其他与此对象相关的位置)。
-
-### 自动装箱与拆箱
-
-- **装箱**:将基本类型用它们对应的引用类型包装起来;
-- **拆箱**:将包装类型转换为基本数据类型;
-
-举例:
-
-```java
-Integer i = 10; //装箱
-int n = i; //拆箱
-```
-
-上面这两行代码对应的字节码为:
-
-```java
- L1
-
- LINENUMBER 8 L1
-
- ALOAD 0
-
- BIPUSH 10
-
- INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
-
- PUTFIELD AutoBoxTest.i : Ljava/lang/Integer;
-
- L2
-
- LINENUMBER 9 L2
-
- ALOAD 0
-
- ALOAD 0
-
- GETFIELD AutoBoxTest.i : Ljava/lang/Integer;
-
- INVOKEVIRTUAL java/lang/Integer.intValue ()I
-
- PUTFIELD AutoBoxTest.n : I
-
- RETURN
-```
-
-从字节码中,我们发现装箱其实就是调用了 包装类的`valueOf()`方法,拆箱其实就是调用了 `xxxValue()`方法。
-
-因此,
-
-- `Integer i = 10` 等价于 `Integer i = Integer.valueOf(10)`
-- `int n = i` 等价于 `int n = i.intValue()`;
-
-### 8 种基本类型的包装类和常量池
-
-Java 基本类型的包装类的大部分都实现了常量池技术。`Byte`,`Short`,`Integer`,`Long` 这 4 种包装类默认创建了数值 **[-128,127]** 的相应类型的缓存数据,`Character` 创建了数值在[0,127]范围的缓存数据,`Boolean` 直接返回 `True` Or `False`。
-
-**Integer 缓存源码:**
-
-```java
-/**
-
-*此方法将始终缓存-128 到 127(包括端点)范围内的值,并可以缓存此范围之外的其他值。
-
-*/
-
-public static Integer valueOf(int i) {
-
- if (i >= IntegerCache.low && i <= IntegerCache.high)
-
- return IntegerCache.cache[i + (-IntegerCache.low)];
-
- return new Integer(i);
-
-}
-
-private static class IntegerCache {
-
- static final int low = -128;
-
- static final int high;
-
- static final Integer cache[];
-
-}
-```
-
-**`Character` 缓存源码:**
-
-```java
-public static Character valueOf(char c) {
-
- if (c <= 127) { // must cache
-
- return CharacterCache.cache[(int)c];
-
- }
-
- return new Character(c);
-
-}
-
-
-
-private static class CharacterCache {
-
- private CharacterCache(){}
-
-
-
- static final Character cache[] = new Character[127 + 1];
-
- static {
-
- for (int i = 0; i < cache.length; i++)
-
- cache[i] = new Character((char)i);
-
- }
-
-}
-```
-
-**`Boolean` 缓存源码:**
-
-```java
-public static Boolean valueOf(boolean b) {
-
- return (b ? TRUE : FALSE);
-
-}
-```
-
-如果超出对应范围仍然会去创建新的对象,缓存的范围区间的大小只是在性能和资源之间的权衡。
-
-两种浮点数类型的包装类 `Float`,`Double` 并没有实现常量池技术。
-
-```java
-Integer i1 = 33;
-
-Integer i2 = 33;
-
-System.out.println(i1 == i2);// 输出 true
-
-Float i11 = 333f;
-
-Float i22 = 333f;
-
-System.out.println(i11 == i22);// 输出 false
-
-Double i3 = 1.2;
-
-Double i4 = 1.2;
-
-System.out.println(i3 == i4);// 输出 false
-```
-
-下面我们来看一下问题。下面的代码的输出结果是 `true` 还是 `flase` 呢?
-
-```java
-Integer i1 = 40;
-
-Integer i2 = new Integer(40);
-
-System.out.println(i1==i2);
-```
-
-`Integer i1=40` 这一行代码会发生拆箱,也就是说这行代码等价于 `Integer i1=Integer.valueOf(40)` 。因此,`i1` 直接使用的是常量池中的对象。而`Integer i1 = new Integer(40)` 会直接创建新的对象。
-
-因此,答案是 `false` 。你答对了吗?
-
-记住:**所有整型包装类对象之间值的比较,全部使用 equals 方法比较**。
-
-
-
-## 方法(函数)
-
-### 什么是方法的返回值?
-
-方法的返回值是指我们获取到的某个方法体中的代码执行后产生的结果!(前提是该方法可能产生结果)。返回值的作用是接收出结果,使得它可以用于其他的操作!
-
-### 方法有哪几种类型?
-
-**1.无参数无返回值的方法**
-
-```java
-// 无参数无返回值的方法(如果方法没有返回值,不能不写,必须写void,表示没有返回值)
-public void f1() {
- System.out.println("无参数无返回值的方法");
-}
-```
-
-**2.有参数无返回值的方法**
-
-```java
-/**
-* 有参数无返回值的方法
-* 参数列表由零组到多组“参数类型+形参名”组合而成,多组参数之间以英文逗号(,)隔开,形参类型和形参名之间以英文空格隔开
-*/
-public void f2(int a, String b, int c) {
- System.out.println(a + "-->" + b + "-->" + c);
-}
-```
-
-**3.有返回值无参数的方法**
-
-```java
-// 有返回值无参数的方法(返回值可以是任意的类型,在函数里面必须有return关键字返回对应的类型)
-public int f3() {
- System.out.println("有返回值无参数的方法");
- return 2;
-}
-```
-
-**4.有返回值有参数的方法**
-
-```java
-// 有返回值有参数的方法
-public int f4(int a, int b) {
- return a * b;
-}
-```
-
-**5.return 在无返回值方法的特殊使用**
-
-```java
-// return在无返回值方法的特殊使用
-public void f5(int a) {
- if (a > 10) {
- return;//表示结束所在方法 (f5方法)的执行,下方的输出语句不会执行
- }
- System.out.println(a);
-}
-```
-
-### 在一个静态方法内调用一个非静态成员为什么是非法的?
-
-这个需要结合 JVM 的相关知识,静态方法是属于类的,在类加载的时候就会分配内存,可以通过类名直接访问。而非静态成员属于实例对象,只有在对象实例化之后才存在,然后通过类的实例对象去访问。在类的非静态成员不存在的时候静态成员就已经存在了,此时调用在内存中还不存在的非静态成员,属于非法操作。
-
-### 静态方法和实例方法有何不同?
-
-1. 在外部调用静态方法时,可以使用"类名.方法名"的方式,也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说,**调用静态方法可以无需创建对象。**
-
-2. 静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),而不允许访问实例成员变量和实例方法;实例方法则无此限制。
-
-### 为什么 Java 中只有值传递?
-
-首先,我们回顾一下在程序设计语言中有关将参数传递给方法(或函数)的一些专业术语。
-
-**按值调用(call by value)** 表示方法接收的是调用者提供的值,**按引用调用(call by reference)** 表示方法接收的是调用者提供的变量地址。一个方法可以修改传递引用所对应的变量值,而不能修改传递值调用所对应的变量值。它用来描述各种程序设计语言(不只是 Java)中方法参数传递方式。
-
-**Java 程序设计语言总是采用按值调用。也就是说,方法得到的是所有参数值的一个拷贝,也就是说,方法不能修改传递给它的任何参数变量的内容。**
-
-**下面通过 3 个例子来给大家说明**
-
-> **example 1**
-
-```java
-public static void main(String[] args) {
- int num1 = 10;
- int num2 = 20;
-
- swap(num1, num2);
-
- System.out.println("num1 = " + num1);
- System.out.println("num2 = " + num2);
-}
-
-public static void swap(int a, int b) {
- int temp = a;
- a = b;
- b = temp;
-
- System.out.println("a = " + a);
- System.out.println("b = " + b);
-}
-```
-
-**结果:**
-
-```
-a = 20
-b = 10
-num1 = 10
-num2 = 20
-```
-
-**解析:**
-
-
-
-在 swap 方法中,a、b 的值进行交换,并不会影响到 num1、num2。因为,a、b 中的值,只是从 num1、num2 的复制过来的。也就是说,a、b 相当于 num1、num2 的副本,副本的内容无论怎么修改,都不会影响到原件本身。
-
-**通过上面例子,我们已经知道了一个方法不能修改一个基本数据类型的参数,而对象引用作为参数就不一样,请看 example2.**
-
-> **example 2**
-
-```java
- public static void main(String[] args) {
- int[] arr = { 1, 2, 3, 4, 5 };
- System.out.println(arr[0]);
- change(arr);
- System.out.println(arr[0]);
- }
-
- public static void change(int[] array) {
- // 将数组的第一个元素变为0
- array[0] = 0;
- }
-```
-
-**结果:**
-
-```
-1
-0
-```
-
-**解析:**
-
-
-
-array 被初始化 arr 的拷贝也就是一个对象的引用,也就是说 array 和 arr 指向的是同一个数组对象。 因此,外部对引用对象的改变会反映到所对应的对象上。
-
-**通过 example2 我们已经看到,实现一个改变对象参数状态的方法并不是一件难事。理由很简单,方法得到的是对象引用的拷贝,对象引用及其他的拷贝同时引用同一个对象。**
-
-**很多程序设计语言(特别是,C++和 Pascal)提供了两种参数传递的方式:值调用和引用调用。有些程序员(甚至本书的作者)认为 Java 程序设计语言对对象采用的是引用调用,实际上,这种理解是不对的。由于这种误解具有一定的普遍性,所以下面给出一个反例来详细地阐述一下这个问题。**
-
-> **example 3**
-
-```java
-public class Test {
-
- public static void main(String[] args) {
- // TODO Auto-generated method stub
- Student s1 = new Student("小张");
- Student s2 = new Student("小李");
- Test.swap(s1, s2);
- System.out.println("s1:" + s1.getName());
- System.out.println("s2:" + s2.getName());
- }
-
- public static void swap(Student x, Student y) {
- Student temp = x;
- x = y;
- y = temp;
- System.out.println("x:" + x.getName());
- System.out.println("y:" + y.getName());
- }
-}
-```
-
-**结果:**
-
-```
-x:小李
-y:小张
-s1:小张
-s2:小李
-```
-
-**解析:**
-
-交换之前:
-
-
-
-交换之后:
-
-
-
-通过上面两张图可以很清晰的看出: **方法并没有改变存储在变量 s1 和 s2 中的对象引用。swap 方法的参数 x 和 y 被初始化为两个对象引用的拷贝,这个方法交换的是这两个拷贝**
-
-> **总结**
-
-Java 程序设计语言对对象采用的不是引用调用,实际上,对象引用是按
-值传递的。
-
-下面再总结一下 Java 中方法参数的使用情况:
-
-- 一个方法不能修改一个基本数据类型的参数(即数值型或布尔型)。
-- 一个方法可以改变一个对象参数的状态。
-- 一个方法不能让对象参数引用一个新的对象。
-
-**参考:**
-
-《Java 核心技术卷 Ⅰ》基础知识第十版第四章 4.5 小节
-
-### 重载和重写的区别
-
-> 重载就是同样的一个方法能够根据输入数据的不同,做出不同的处理
->
-> 重写就是当子类继承自父类的相同方法,输入数据一样,但要做出有别于父类的响应时,你就要覆盖父类方法
-
-#### 重载
-
-发生在同一个类中(或者父类和子类之间),方法名必须相同,参数类型不同、个数不同、顺序不同,方法返回值和访问修饰符可以不同。
-
-下面是《Java 核心技术》对重载这个概念的介绍:
-
-
-
-综上:重载就是同一个类中多个同名方法根据不同的传参来执行不同的逻辑处理。
-
-#### 重写
-
-重写发生在运行期,是子类对父类的允许访问的方法的实现过程进行重新编写。
-
-1. 返回值类型、方法名、参数列表必须相同,抛出的异常范围小于等于父类,访问修饰符范围大于等于父类。
-2. 如果父类方法访问修饰符为 `private/final/static` 则子类就不能重写该方法,但是被 static 修饰的方法能够被再次声明。
-3. 构造方法无法被重写
-
-综上:重写就是子类对父类方法的重新改造,外部样子不能改变,内部逻辑可以改变
-
-暖心的 Guide 哥最后再来个图表总结一下!
-
-| 区别点 | 重载方法 | 重写方法 |
-| :--------- | :------- | :----------------------------------------------------------- |
-| 发生范围 | 同一个类 | 子类 |
-| 参数列表 | 必须修改 | 一定不能修改 |
-| 返回类型 | 可修改 | 子类方法返回值类型应比父类方法返回值类型更小或相等 |
-| 异常 | 可修改 | 子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等; |
-| 访问修饰符 | 可修改 | 一定不能做更严格的限制(可以降低限制) |
-| 发生阶段 | 编译期 | 运行期 |
-
-**方法的重写要遵循“两同两小一大”**(以下内容摘录自《疯狂 Java 讲义》,[issue#892](https://github.com/Snailclimb/JavaGuide/issues/892) ):
-
-- “两同”即方法名相同、形参列表相同;
-- “两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等,子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等;
-- “一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。
-
-⭐️ 关于 **重写的返回值类**型 这里需要额外多说明一下,上面的表述不太清晰准确:如果方法的返回类型是 void 和基本数据类型,则返回值重写时不可修改。但是如果方法的返回值是引用类型,重写时是可以返回该引用类型的子类的。
-
-```java
-public class Hero {
- public String name() {
- return "超级英雄";
- }
-}
-public class SuperMan extends Hero{
- @Override
- public String name() {
- return "超人";
- }
- public Hero hero() {
- return new Hero();
- }
-}
-
-public class SuperSuperMan extends SuperMan {
- public String name() {
- return "超级超级英雄";
- }
-
- @Override
- public SuperMan hero() {
- return new SuperMan();
- }
-}
-```
-
-### 深拷贝 vs 浅拷贝
-
-1. **浅拷贝**:对基本数据类型进行值传递,对引用数据类型进行引用传递般的拷贝,此为浅拷贝。
-2. **深拷贝**:对基本数据类型进行值传递,对引用数据类型,创建一个新的对象,并复制其内容,此为深拷贝。
-
-
-
-## Java 面向对象
-
-### 面向对象和面向过程的区别
-
-- **面向过程** :**面向过程性能比面向对象高。** 因为类调用时需要实例化,开销比较大,比较消耗资源,所以当性能是最重要的考量因素的时候,比如单片机、嵌入式开发、Linux/Unix 等一般采用面向过程开发。但是,**面向过程没有面向对象易维护、易复用、易扩展。**
-- **面向对象** :**面向对象易维护、易复用、易扩展。** 因为面向对象有封装、继承、多态性的特性,所以可以设计出低耦合的系统,使系统更加灵活、更加易于维护。但是,**面向对象性能比面向过程低**。
-
-参见 issue : [面向过程 :面向过程性能比面向对象高??](https://github.com/Snailclimb/JavaGuide/issues/431)
-
-> 这个并不是根本原因,面向过程也需要分配内存,计算内存偏移量,Java 性能差的主要原因并不是因为它是面向对象语言,而是 Java 是半编译语言,最终的执行代码并不是可以直接被 CPU 执行的二进制机械码。
->
-> 而面向过程语言大多都是直接编译成机械码在电脑上执行,并且其它一些面向过程的脚本语言性能也并不一定比 Java 好。
-
-### 成员变量与局部变量的区别有哪些?
-
-1. 从语法形式上看,成员变量是属于类的,而局部变量是在代码块或方法中定义的变量或是方法的参数;成员变量可以被 `public`,`private`,`static` 等修饰符所修饰,而局部变量不能被访问控制修饰符及 `static` 所修饰;但是,成员变量和局部变量都能被 `final` 所修饰。
-2. 从变量在内存中的存储方式来看,如果成员变量是使用 `static` 修饰的,那么这个成员变量是属于类的,如果没有使用 `static` 修饰,这个成员变量是属于实例的。而对象存在于堆内存,局部变量则存在于栈内存。
-3. 从变量在内存中的生存时间上看,成员变量是对象的一部分,它随着对象的创建而存在,而局部变量随着方法的调用而自动消失。
-4. 从变量是否有默认值来看,成员变量如果没有被赋初,则会自动以类型的默认值而赋值(一种情况例外:被 `final` 修饰的成员变量也必须显式地赋值),而局部变量则不会自动赋值。
-
-### 创建一个对象用什么运算符?对象实体与对象引用有何不同?
-
-new 运算符,new 创建对象实例(对象实例在堆内存中),对象引用指向对象实例(对象引用存放在栈内存中)。
-
-一个对象引用可以指向 0 个或 1 个对象(一根绳子可以不系气球,也可以系一个气球);一个对象可以有 n 个引用指向它(可以用 n 条绳子系住一个气球)。
-
-### 对象的相等与指向他们的引用相等,两者有什么不同?
-
-对象的相等,比的是内存中存放的内容是否相等。而引用相等,比较的是他们指向的内存地址是否相等。
-
-### 一个类的构造方法的作用是什么? 若一个类没有声明构造方法,该程序能正确执行吗? 为什么?
-
-构造方法主要作用是完成对类对象的初始化工作。
-
-如果一个类没有声明构造方法,也可以执行!因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法(无论是否有参),Java 就不会再添加默认的无参数的构造方法了,这时候,就不能直接 new 一个对象而不传递参数了,所以我们一直在不知不觉地使用构造方法,这也是为什么我们在创建对象的时候后面要加一个括号(因为要调用无参的构造方法)。如果我们重载了有参的构造方法,记得都要把无参的构造方法也写出来(无论是否用到),因为这可以帮助我们在创建对象的时候少踩坑。
-
-### 构造方法有哪些特点?是否可被 override?
-
-特点:
-
-1. 名字与类名相同。
-2. 没有返回值,但不能用 void 声明构造函数。
-3. 生成类的对象时自动执行,无需调用。
-
-构造方法不能被 override(重写),但是可以 overload(重载),所以你可以看到一个类中有多个构造函数的情况。
-
-### 面向对象三大特征
-
-#### 封装
-
-封装是指把一个对象的状态信息(也就是属性)隐藏在对象内部,不允许外部对象直接访问对象的内部信息。但是可以提供一些可以被外界访问的方法来操作属性。就好像我们看不到挂在墙上的空调的内部的零件信息(也就是属性),但是可以通过遥控器(方法)来控制空调。如果属性不想被外界访问,我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法,那么这个类也没有什么意义了。就好像如果没有空调遥控器,那么我们就无法操控空凋制冷,空调本身就没有意义了(当然现在还有很多其他方法 ,这里只是为了举例子)。
-
-```java
-public class Student {
- private int id;//id属性私有化
- private String name;//name属性私有化
-
- //获取id的方法
- public int getId() {
- return id;
- }
-
- //设置id的方法
- public void setId(int id) {
- this.id = id;
- }
-
- //获取name的方法
- public String getName() {
- return name;
- }
-
- //设置name的方法
- public void setName(String name) {
- this.name = name;
- }
-}
-```
-
-#### 继承
-
-不同类型的对象,相互之间经常有一定数量的共同点。例如,小明同学、小红同学、小李同学,都共享学生的特性(班级、学号等)。同时,每一个对象还定义了额外的特性使得他们与众不同。例如小明的数学比较好,小红的性格惹人喜爱;小李的力气比较大。继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。通过使用继承,可以快速地创建新的类,可以提高代码的重用,程序的可维护性,节省大量创建新类的时间 ,提高我们的开发效率。
-
-**关于继承如下 3 点请记住:**
-
-1. 子类拥有父类对象所有的属性和方法(包括私有属性和私有方法),但是父类中的私有属性和方法子类是无法访问,**只是拥有**。
-2. 子类可以拥有自己属性和方法,即子类可以对父类进行扩展。
-3. 子类可以用自己的方式实现父类的方法。(以后介绍)。
-
-#### 多态
-
-多态,顾名思义,表示一个对象具有多种的状态。具体表现为父类的引用指向子类的实例。
-
-**多态的特点:**
-
-- 对象类型和引用类型之间具有继承(类)/实现(接口)的关系;
-- 引用类型变量发出的方法调用的到底是哪个类中的方法,必须在程序运行期间才能确定;
-- 多态不能调用“只在子类存在但在父类不存在”的方法;
-- 如果子类重写了父类的方法,真正执行的是子类覆盖的方法,如果子类没有覆盖父类的方法,执行的是父类的方法。
-
-### String StringBuffer 和 StringBuilder 的区别是什么? String 为什么是不可变的?
-
-**可变性**
-
-简单的来说:`String` 类中使用 final 关键字修饰字符数组来保存字符串,`private final char value[]`,所以`String` 对象是不可变的。
-
-> 补充(来自[issue 675](https://github.com/Snailclimb/JavaGuide/issues/675)):在 Java 9 之后,String 、`StringBuilder` 与 `StringBuffer` 的实现改用 byte 数组存储字符串 `private final byte[] value`
-
-而 `StringBuilder` 与 `StringBuffer` 都继承自 `AbstractStringBuilder` 类,在 `AbstractStringBuilder` 中也是使用字符数组保存字符串`char[]value` 但是没有用 `final` 关键字修饰,所以这两种对象都是可变的。
-
-`StringBuilder` 与 `StringBuffer` 的构造方法都是调用父类构造方法也就是`AbstractStringBuilder` 实现的,大家可以自行查阅源码。
-
-`AbstractStringBuilder.java`
-
-```java
-abstract class AbstractStringBuilder implements Appendable, CharSequence {
- /**
- * The value is used for character storage.
- */
- char[] value;
-
- /**
- * The count is the number of characters used.
- */
- int count;
-
- AbstractStringBuilder(int capacity) {
- value = new char[capacity];
- }}
-```
-
-**线程安全性**
-
-`String` 中的对象是不可变的,也就可以理解为常量,线程安全。`AbstractStringBuilder` 是 `StringBuilder` 与 `StringBuffer` 的公共父类,定义了一些字符串的基本操作,如 `expandCapacity`、`append`、`insert`、`indexOf` 等公共方法。`StringBuffer` 对方法加了同步锁或者对调用的方法加了同步锁,所以是线程安全的。`StringBuilder` 并没有对方法进行加同步锁,所以是非线程安全的。
-
-**性能**
-
-每次对 `String` 类型进行改变的时候,都会生成一个新的 `String` 对象,然后将指针指向新的 `String` 对象。`StringBuffer` 每次都会对 `StringBuffer` 对象本身进行操作,而不是生成新的对象并改变对象引用。相同情况下使用 `StringBuilder` 相比使用 `StringBuffer` 仅能获得 10%~15% 左右的性能提升,但却要冒多线程不安全的风险。
-
-**对于三者使用的总结:**
-
-1. 操作少量的数据: 适用 `String`
-2. 单线程操作字符串缓冲区下操作大量数据: 适用 `StringBuilder`
-3. 多线程操作字符串缓冲区下操作大量数据: 适用 `StringBuffer`
-
-### Object 类的常见方法总结
-
-Object 类是一个特殊的类,是所有类的父类。它主要提供了以下 11 个方法:
-
-```java
-
-public final native Class> getClass()//native方法,用于返回当前运行时对象的Class对象,使用了final关键字修饰,故不允许子类重写。
-
-public native int hashCode() //native方法,用于返回对象的哈希码,主要使用在哈希表中,比如JDK中的HashMap。
-public boolean equals(Object obj)//用于比较2个对象的内存地址是否相等,String类对该方法进行了重写用户比较字符串的值是否相等。
-
-protected native Object clone() throws CloneNotSupportedException//naitive方法,用于创建并返回当前对象的一份拷贝。一般情况下,对于任何对象 x,表达式 x.clone() != x 为true,x.clone().getClass() == x.getClass() 为true。Object本身没有实现Cloneable接口,所以不重写clone方法并且进行调用的话会发生CloneNotSupportedException异常。
-
-public String toString()//返回类的名字@实例的哈希码的16进制的字符串。建议Object所有的子类都重写这个方法。
-
-public final native void notify()//native方法,并且不能重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果有多个线程在等待只会任意唤醒一个。
-
-public final native void notifyAll()//native方法,并且不能重写。跟notify一样,唯一的区别就是会唤醒在此对象监视器上等待的所有线程,而不是一个线程。
-
-public final native void wait(long timeout) throws InterruptedException//native方法,并且不能重写。暂停线程的执行。注意:sleep方法没有释放锁,而wait方法释放了锁 。timeout是等待时间。
-
-public final void wait(long timeout, int nanos) throws InterruptedException//多了nanos参数,这个参数表示额外时间(以毫微秒为单位,范围是 0-999999)。 所以超时的时间还需要加上nanos毫秒。
-
-public final void wait() throws InterruptedException//跟之前的2个wait方法一样,只不过该方法一直等待,没有超时时间这个概念
-
-protected void finalize() throws Throwable { }//实例被垃圾回收器回收的时候触发的操作
-
-```
-
-## 反射
-
-### 何为反射?
-
-如果说大家研究过框架的底层原理或者咱们自己写过框架的话,一定对反射这个概念不陌生。
-
-反射之所以被称为框架的灵魂,主要是因为它赋予了我们在运行时分析类以及执行类中方法的能力。
-
-通过反射你可以获取任意一个类的所有属性和方法,你还可以调用这些方法和属性。
-
-### 反射机制优缺点
-
-- **优点** : 可以让咱们的代码更加灵活、为各种框架提供开箱即用的功能提供了便利
-- **缺点** :让我们在运行时有了分析操作类的能力,这同样也增加了安全问题。比如可以无视泛型参数的安全检查(泛型参数的安全检查发生在编译时)。另外,反射的性能也要稍差点,不过,对于框架来说实际是影响不大的。[Java Reflection: Why is it so slow?](https://stackoverflow.com/questions/1392351/java-reflection-why-is-it-so-slow)
-
-### 反射的应用场景
-
-像咱们平时大部分时候都是在写业务代码,很少会接触到直接使用反射机制的场景。
-
-但是,这并不代表反射没有用。相反,正是因为反射,你才能这么轻松地使用各种框架。像 Spring/Spring Boot、MyBatis 等等框架中都大量使用了反射机制。
-
-**这些框架中也大量使用了动态代理,而动态代理的实现也依赖反射。**
-
-比如下面是通过 JDK 实现动态代理的示例代码,其中就使用了反射类 `Method` 来调用指定的方法。
-
-```java
-public class DebugInvocationHandler implements InvocationHandler {
- /**
- * 代理类中的真实对象
- */
- private final Object target;
-
- public DebugInvocationHandler(Object target) {
- this.target = target;
- }
-
-
- public Object invoke(Object proxy, Method method, Object[] args) throws InvocationTargetException, IllegalAccessException {
- System.out.println("before method " + method.getName());
- Object result = method.invoke(target, args);
- System.out.println("after method " + method.getName());
- return result;
- }
-}
-
-```
-
-另外,像 Java 中的一大利器 **注解** 的实现也用到了反射。
-
-为什么你使用 Spring 的时候 ,一个`@Component`注解就声明了一个类为 Spring Bean 呢?为什么你通过一个 `@Value`注解就读取到配置文件中的值呢?究竟是怎么起作用的呢?
-
-这些都是因为你可以基于反射分析类,然后获取到类/属性/方法/方法的参数上的注解。你获取到注解之后,就可以做进一步的处理。
-
-## 异常
-
-### Java 异常类层次结构图
-
-
-
-图片来自:https://simplesnippets.tech/exception-handling-in-java-part-1/
-
-
-
-图片来自:https://chercher.tech/java-programming/exceptions-java
-
-在 Java 中,所有的异常都有一个共同的祖先 `java.lang` 包中的 `Throwable` 类。`Throwable` 类有两个重要的子类 `Exception`(异常)和 `Error`(错误)。`Exception` 能被程序本身处理(`try-catch`), `Error` 是无法处理的(只能尽量避免)。
-
-`Exception` 和 `Error` 二者都是 Java 异常处理的重要子类,各自都包含大量子类。
-
-- **`Exception`** :程序本身可以处理的异常,可以通过 `catch` 来进行捕获。`Exception` 又可以分为 受检查异常(必须处理) 和 不受检查异常(可以不处理)。
-- **`Error`** :`Error` 属于程序无法处理的错误 ,我们没办法通过 `catch` 来进行捕获 。例如,Java 虚拟机运行错误(`Virtual MachineError`)、虚拟机内存不够错误(`OutOfMemoryError`)、类定义错误(`NoClassDefFoundError`)等 。这些异常发生时,Java 虚拟机(JVM)一般会选择线程终止。
-
-**受检查异常**
-
-Java 代码在编译过程中,如果受检查异常没有被 `catch`/`throw` 处理的话,就没办法通过编译 。比如下面这段 IO 操作的代码。
-
-
-
-除了`RuntimeException`及其子类以外,其他的`Exception`类及其子类都属于受检查异常 。常见的受检查异常有: IO 相关的异常、`ClassNotFoundException` 、`SQLException`...。
-
-**不受检查异常**
-
-Java 代码在编译过程中 ,我们即使不处理不受检查异常也可以正常通过编译。
-
-`RuntimeException` 及其子类都统称为非受检查异常,例如:`NullPointerException`、`NumberFormatException`(字符串转换为数字)、`ArrayIndexOutOfBoundsException`(数组越界)、`ClassCastException`(类型转换错误)、`ArithmeticException`(算术错误)等。
-
-### Throwable 类常用方法
-
-- **`public string getMessage()`**:返回异常发生时的简要描述
-- **`public string toString()`**:返回异常发生时的详细信息
-- **`public string getLocalizedMessage()`**:返回异常对象的本地化信息。使用 `Throwable` 的子类覆盖这个方法,可以生成本地化信息。如果子类没有覆盖该方法,则该方法返回的信息与 `getMessage()`返回的结果相同
-- **`public void printStackTrace()`**:在控制台上打印 `Throwable` 对象封装的异常信息
-
-### try-catch-finally
-
-- **`try`块:** 用于捕获异常。其后可接零个或多个 `catch` 块,如果没有 `catch` 块,则必须跟一个 `finally` 块。
-- **`catch`块:** 用于处理 try 捕获到的异常。
-- **`finally` 块:** 无论是否捕获或处理异常,`finally` 块里的语句都会被执行。当在 `try` 块或 `catch` 块中遇到 `return` 语句时,`finally` 语句块将在方法返回之前被执行。
-
-**在以下 3 种特殊情况下,`finally` 块不会被执行:**
-
-2. 在 `try` 或 `finally`块中用了 `System.exit(int)`退出程序。但是,如果 `System.exit(int)` 在异常语句之后,`finally` 还是会被执行
-3. 程序所在的线程死亡。
-4. 关闭 CPU。
-
-下面这部分内容来自 issue:。
-
-**注意:** 当 try 语句和 finally 语句中都有 return 语句时,在方法返回之前,finally 语句的内容将被执行,并且 finally 语句的返回值将会覆盖原始的返回值。如下:
-
-```java
-public class Test {
- public static int f(int value) {
- try {
- return value * value;
- } finally {
- if (value == 2) {
- return 0;
- }
- }
- }
-}
-```
-
-如果调用 `f(2)`,返回值将是 0,因为 finally 语句的返回值覆盖了 try 语句块的返回值。
-
-### 使用 `try-with-resources` 来代替`try-catch-finally`
-
-1. **适用范围(资源的定义):** 任何实现 `java.lang.AutoCloseable`或者 `java.io.Closeable` 的对象
-2. **关闭资源和 finally 块的执行顺序:** 在 `try-with-resources` 语句中,任何 catch 或 finally 块在声明的资源关闭后运行
-
-《Effecitve Java》中明确指出:
-
-> 面对必须要关闭的资源,我们总是应该优先使用 `try-with-resources` 而不是`try-finally`。随之产生的代码更简短,更清晰,产生的异常对我们也更有用。`try-with-resources`语句让我们更容易编写必须要关闭的资源的代码,若采用`try-finally`则几乎做不到这点。
-
-Java 中类似于`InputStream`、`OutputStream` 、`Scanner` 、`PrintWriter`等的资源都需要我们调用`close()`方法来手动关闭,一般情况下我们都是通过`try-catch-finally`语句来实现这个需求,如下:
-
-```java
- //读取文本文件的内容
- Scanner scanner = null;
- try {
- scanner = new Scanner(new File("D://read.txt"));
- while (scanner.hasNext()) {
- System.out.println(scanner.nextLine());
- }
- } catch (FileNotFoundException e) {
- e.printStackTrace();
- } finally {
- if (scanner != null) {
- scanner.close();
- }
- }
-```
-
-使用 Java 7 之后的 `try-with-resources` 语句改造上面的代码:
-
-```java
-try (Scanner scanner = new Scanner(new File("test.txt"))) {
- while (scanner.hasNext()) {
- System.out.println(scanner.nextLine());
- }
-} catch (FileNotFoundException fnfe) {
- fnfe.printStackTrace();
-}
-```
-
-当然多个资源需要关闭的时候,使用 `try-with-resources` 实现起来也非常简单,如果你还是用`try-catch-finally`可能会带来很多问题。
-
-通过使用分号分隔,可以在`try-with-resources`块中声明多个资源。
-
-```java
-try (BufferedInputStream bin = new BufferedInputStream(new FileInputStream(new File("test.txt")));
- BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream(new File("out.txt")))) {
- int b;
- while ((b = bin.read()) != -1) {
- bout.write(b);
- }
- }
- catch (IOException e) {
- e.printStackTrace();
- }
-```
-
-## I\O 流
-
-### 什么是序列化?什么是反序列化?
-
-如果我们需要持久化 Java 对象比如将 Java 对象保存在文件中,或者在网络传输 Java 对象,这些场景都需要用到序列化。
-
-简单来说:
-
-- **序列化**: 将数据结构或对象转换成二进制字节流的过程
-- **反序列化**:将在序列化过程中所生成的二进制字节流的过程转换成数据结构或者对象的过程
-=======
-这篇文章
->>>>>>> Update Java基础知识.md
-
-
## 基础概念与常识
### Java 语言有哪些特点?
@@ -1994,7 +729,7 @@ public void f5(int a) {
### 在一个静态方法内调用一个非静态成员为什么是非法的?
-由于静态方法可以不通过对象进行调用,因此在静态方法里,不能调用其他非静态变量,也不可以访问非静态变量成员。
+这个需要结合 JVM 的相关知识,静态方法是属于类的,在类加载的时候就会分配内存,可以通过类名直接访问。而非静态成员属于实例对象,只有在对象实例化之后才存在,然后通过类的实例对象去访问。在类的非静态成员不存在的时候静态成员就已经存在了,此时调用在内存中还不存在的非静态成员,属于非法操作。
### 静态方法和实例方法有何不同?
From d5da28a273bc6f786d26941c72c2511be4f10fc7 Mon Sep 17 00:00:00 2001
From: guide
Date: Sun, 25 Apr 2021 12:53:52 +0800
Subject: [PATCH 10/11] =?UTF-8?q?Update=20AQS=E5=8E=9F=E7=90=86=E4=BB=A5?=
=?UTF-8?q?=E5=8F=8AAQS=E5=90=8C=E6=AD=A5=E7=BB=84=E4=BB=B6=E6=80=BB?=
=?UTF-8?q?=E7=BB=93.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...04\344\273\266\346\200\273\347\273\223.md" | 78 +++++++++----------
1 file changed, 39 insertions(+), 39 deletions(-)
diff --git "a/docs/java/multi-thread/AQS\345\216\237\347\220\206\344\273\245\345\217\212AQS\345\220\214\346\255\245\347\273\204\344\273\266\346\200\273\347\273\223.md" "b/docs/java/multi-thread/AQS\345\216\237\347\220\206\344\273\245\345\217\212AQS\345\220\214\346\255\245\347\273\204\344\273\266\346\200\273\347\273\223.md"
index 8ca43dd0087..832cbbc9193 100644
--- "a/docs/java/multi-thread/AQS\345\216\237\347\220\206\344\273\245\345\217\212AQS\345\220\214\346\255\245\347\273\204\344\273\266\346\200\273\347\273\223.md"
+++ "b/docs/java/multi-thread/AQS\345\216\237\347\220\206\344\273\245\345\217\212AQS\345\220\214\346\255\245\347\273\204\344\273\266\346\200\273\347\273\223.md"
@@ -28,11 +28,11 @@
### 1 AQS 简单介绍
-AQS 的全称为(AbstractQueuedSynchronizer),这个类在 java.util.concurrent.locks 包下面。
+AQS 的全称为(`AbstractQueuedSynchronizer`),这个类在 `java.util.concurrent.locks` 包下面。

-AQS 是一个用来构建锁和同步器的框架,使用 AQS 能简单且高效地构造出应用广泛的大量的同步器,比如我们提到的 ReentrantLock,Semaphore,其他的诸如 ReentrantReadWriteLock,SynchronousQueue,FutureTask(jdk1.7) 等等皆是基于 AQS 的。当然,我们自己也能利用 AQS 非常轻松容易地构造出符合我们自己需求的同步器。
+AQS 是一个用来构建锁和同步器的框架,使用 AQS 能简单且高效地构造出应用广泛的大量的同步器,比如我们提到的 `ReentrantLock`,`Semaphore`,其他的诸如 `ReentrantReadWriteLock`,`SynchronousQueue`,`FutureTask`(jdk1.7) 等等皆是基于 AQS 的。当然,我们自己也能利用 AQS 非常轻松容易地构造出符合我们自己需求的同步器。
### 2 AQS 原理
@@ -46,7 +46,7 @@ AQS 是一个用来构建锁和同步器的框架,使用 AQS 能简单且高
> CLH(Craig,Landin,and Hagersten)队列是一个虚拟的双向队列(虚拟的双向队列即不存在队列实例,仅存在结点之间的关联关系)。AQS 是将每条请求共享资源的线程封装成一个 CLH 锁队列的一个结点(Node)来实现锁的分配。
-看个 AQS(AbstractQueuedSynchronizer)原理图:
+看个 AQS(`AbstractQueuedSynchronizer`)原理图:

@@ -79,16 +79,16 @@ protected final boolean compareAndSetState(int expect, int update) {
**1)Exclusive**(独占)
-只有一个线程能执行,如 ReentrantLock。又可分为公平锁和非公平锁,ReentrantLock 同时支持两种锁,下面以 ReentrantLock 对这两种锁的定义做介绍:
+只有一个线程能执行,如 `ReentrantLock`。又可分为公平锁和非公平锁,`ReentrantLock` 同时支持两种锁,下面以 `ReentrantLock` 对这两种锁的定义做介绍:
- 公平锁:按照线程在队列中的排队顺序,先到者先拿到锁
- 非公平锁:当线程要获取锁时,先通过两次 CAS 操作去抢锁,如果没抢到,当前线程再加入到队列中等待唤醒。
> 说明:下面这部分关于 `ReentrantLock` 源代码内容节选自:https://www.javadoop.com/post/AbstractQueuedSynchronizer-2 ,这是一篇很不错文章,推荐阅读。
-**下面来看 ReentrantLock 中相关的源代码:**
+**下面来看 `ReentrantLock` 中相关的源代码:**
-ReentrantLock 默认采用非公平锁,因为考虑获得更好的性能,通过 boolean 来决定是否用公平锁(传入 true 用公平锁)。
+`ReentrantLock` 默认采用非公平锁,因为考虑获得更好的性能,通过 `boolean` 来决定是否用公平锁(传入 true 用公平锁)。
```java
/** Synchronizer providing all implementation mechanics */
@@ -102,7 +102,7 @@ public ReentrantLock(boolean fair) {
}
```
-ReentrantLock 中公平锁的 `lock` 方法
+`ReentrantLock` 中公平锁的 `lock` 方法
```java
static final class FairSync extends Sync {
@@ -187,7 +187,7 @@ final boolean nonfairTryAcquire(int acquires) {
总结:公平锁和非公平锁只有两处不同:
1. 非公平锁在调用 lock 后,首先就会调用 CAS 进行一次抢锁,如果这个时候恰巧锁没有被占用,那么直接就获取到锁返回了。
-2. 非公平锁在 CAS 失败后,和公平锁一样都会进入到 tryAcquire 方法,在 tryAcquire 方法中,如果发现锁这个时候被释放了(state == 0),非公平锁会直接 CAS 抢锁,但是公平锁会判断等待队列是否有线程处于等待状态,如果有则不去抢锁,乖乖排到后面。
+2. 非公平锁在 CAS 失败后,和公平锁一样都会进入到 `tryAcquire` 方法,在 `tryAcquire` 方法中,如果发现锁这个时候被释放了(state == 0),非公平锁会直接 CAS 抢锁,但是公平锁会判断等待队列是否有线程处于等待状态,如果有则不去抢锁,乖乖排到后面。
公平锁和非公平锁就这两点区别,如果这两次 CAS 都不成功,那么后面非公平锁和公平锁是一样的,都要进入到阻塞队列等待唤醒。
@@ -195,9 +195,9 @@ final boolean nonfairTryAcquire(int acquires) {
**2)Share**(共享)
-多个线程可同时执行,如 Semaphore/CountDownLatch。Semaphore、CountDownLatCh、 CyclicBarrier、ReadWriteLock 我们都会在后面讲到。
+多个线程可同时执行,如 `Semaphore/CountDownLatch`。`Semaphore`、`CountDownLatCh`、 `CyclicBarrier`、`ReadWriteLock` 我们都会在后面讲到。
-ReentrantReadWriteLock 可以看成是组合式,因为 ReentrantReadWriteLock 也就是读写锁允许多个线程同时对某一资源进行读。
+`ReentrantReadWriteLock` 可以看成是组合式,因为 `ReentrantReadWriteLock` 也就是读写锁允许多个线程同时对某一资源进行读。
不同的自定义同步器争用共享资源的方式也不同。自定义同步器在实现时只需要实现共享资源 state 的获取与释放方式即可,至于具体线程等待队列的维护(如获取资源失败入队/唤醒出队等),AQS 已经在上层已经帮我们实现好了。
@@ -205,7 +205,7 @@ ReentrantReadWriteLock 可以看成是组合式,因为 ReentrantReadWriteLock
同步器的设计是基于模板方法模式的,如果需要自定义同步器一般的方式是这样(模板方法模式很经典的一个应用):
-1. 使用者继承 AbstractQueuedSynchronizer 并重写指定的方法。(这些重写方法很简单,无非是对于共享资源 state 的获取和释放)
+1. 使用者继承 `AbstractQueuedSynchronizer` 并重写指定的方法。(这些重写方法很简单,无非是对于共享资源 state 的获取和释放)
2. 将 AQS 组合在自定义同步组件的实现中,并调用其模板方法,而这些模板方法会调用使用者重写的方法。
这和我们以往通过实现接口的方式有很大区别,这是模板方法模式很经典的一个运用,下面简单的给大家介绍一下模板方法模式,模板方法模式是一个很容易理解的设计模式之一。
@@ -225,9 +225,9 @@ tryReleaseShared(int)//共享方式。尝试释放资源,成功则返回true
默认情况下,每个方法都抛出 `UnsupportedOperationException`。 这些方法的实现必须是内部线程安全的,并且通常应该简短而不是阻塞。AQS 类中的其他方法都是 final ,所以无法被其他类使用,只有这几个方法可以被其他类使用。
-以 ReentrantLock 为例,state 初始化为 0,表示未锁定状态。A 线程 lock()时,会调用 tryAcquire()独占该锁并将 state+1。此后,其他线程再 tryAcquire()时就会失败,直到 A 线程 unlock()到 state=0(即释放锁)为止,其它线程才有机会获取该锁。当然,释放锁之前,A 线程自己是可以重复获取此锁的(state 会累加),这就是可重入的概念。但要注意,获取多少次就要释放多么次,这样才能保证 state 是能回到零态的。
+以 `ReentrantLock` 为例,state 初始化为 0,表示未锁定状态。A 线程 `lock()` 时,会调用 `tryAcquire()`独占该锁并将 state+1。此后,其他线程再 `tryAcquire()` 时就会失败,直到 A 线程 unlock()到 state=0(即释放锁)为止,其它线程才有机会获取该锁。当然,释放锁之前,A 线程自己是可以重复获取此锁的(state 会累加),这就是可重入的概念。但要注意,获取多少次就要释放多么次,这样才能保证 state 是能回到零态的。
-再以 CountDownLatch 以例,任务分为 N 个子线程去执行,state 也初始化为 N(注意 N 要与线程个数一致)。这 N 个子线程是并行执行的,每个子线程执行完后 countDown()一次,state 会 CAS(Compare and Swap)减 1。等到所有子线程都执行完后(即 state=0),会 unpark()主调用线程,然后主调用线程就会从 await()函数返回,继续后余动作。
+再以 `CountDownLatch` 以例,任务分为 N 个子线程去执行,state 也初始化为 N(注意 N 要与线程个数一致)。这 N 个子线程是并行执行的,每个子线程执行完后 `countDown()` 一次,state 会 CAS(Compare and Swap)减 1。等到所有子线程都执行完后(即 state=0),会 unpark()主调用线程,然后主调用线程就会从 `await()` 函数返回,继续后余动作。
一般来说,自定义同步器要么是独占方法,要么是共享方式,他们也只需实现`tryAcquire-tryRelease`、`tryAcquireShared-tryReleaseShared`中的一种即可。但 AQS 也支持自定义同步器同时实现独占和共享两种方式,如`ReentrantReadWriteLock`。
@@ -238,7 +238,7 @@ tryReleaseShared(int)//共享方式。尝试释放资源,成功则返回true
### 3 Semaphore(信号量)-允许多个线程同时访问
-**synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源,Semaphore(信号量)可以指定多个线程同时访问某个资源。**
+**`synchronized` 和 `ReentrantLock` 都是一次只允许一个线程访问某个资源,`Semaphore`(信号量)可以指定多个线程同时访问某个资源。**
示例代码如下:
@@ -285,7 +285,7 @@ public class SemaphoreExample1 {
}
```
-执行 `acquire` 方法阻塞,直到有一个许可证可以获得然后拿走一个许可证;每个 `release` 方法增加一个许可证,这可能会释放一个阻塞的 acquire 方法。然而,其实并没有实际的许可证这个对象,Semaphore 只是维持了一个可获得许可证的数量。 Semaphore 经常用于限制获取某种资源的线程数量。
+执行 `acquire` 方法阻塞,直到有一个许可证可以获得然后拿走一个许可证;每个 `release` 方法增加一个许可证,这可能会释放一个阻塞的 acquire 方法。然而,其实并没有实际的许可证这个对象,`Semaphore` 只是维持了一个可获得许可证的数量。 `Semaphore` 经常用于限制获取某种资源的线程数量。
当然一次也可以一次拿取和释放多个许可,不过一般没有必要这样做:
@@ -297,12 +297,12 @@ semaphore.release(5);// 获取5个许可,所以可运行线程数量为20/5=4
除了 `acquire`方法之外,另一个比较常用的与之对应的方法是`tryAcquire`方法,该方法如果获取不到许可就立即返回 false。
-Semaphore 有两种模式,公平模式和非公平模式。
+`Semaphore` 有两种模式,公平模式和非公平模式。
- **公平模式:** 调用 acquire 的顺序就是获取许可证的顺序,遵循 FIFO;
- **非公平模式:** 抢占式的。
-**Semaphore 对应的两个构造方法如下:**
+**`Semaphore` 对应的两个构造方法如下:**
```java
public Semaphore(int permits) {
@@ -316,21 +316,21 @@ Semaphore 有两种模式,公平模式和非公平模式。
**这两个构造方法,都必须提供许可的数量,第二个构造方法可以指定是公平模式还是非公平模式,默认非公平模式。**
-[issue645 补充内容](https://github.com/Snailclimb/JavaGuide/issues/645) :Semaphore 与 CountDownLatch 一样,也是共享锁的一种实现。它默认构造 AQS 的 state 为 permits。当执行任务的线程数量超出 permits,那么多余的线程将会被放入阻塞队列 Park,并自旋判断 state 是否大于 0。只有当 state 大于 0 的时候,阻塞的线程才能继续执行,此时先前执行任务的线程继续执行 release 方法,release 方法使得 state 的变量会加 1,那么自旋的线程便会判断成功。
-如此,每次只有最多不超过 permits 数量的线程能自旋成功,便限制了执行任务线程的数量。
+[issue645 补充内容](https://github.com/Snailclimb/JavaGuide/issues/645) :`Semaphore` 与 `CountDownLatch` 一样,也是共享锁的一种实现。它默认构造 AQS 的 state 为 `permits`。当执行任务的线程数量超出 `permits`,那么多余的线程将会被放入阻塞队列 Park,并自旋判断 state 是否大于 0。只有当 state 大于 0 的时候,阻塞的线程才能继续执行,此时先前执行任务的线程继续执行 `release()` 方法,`release()` 方法使得 state 的变量会加 1,那么自旋的线程便会判断成功。
+如此,每次只有最多不超过 `permits` 数量的线程能自旋成功,便限制了执行任务线程的数量。
-由于篇幅问题,如果对 Semaphore 源码感兴趣的朋友可以看下这篇文章:https://juejin.im/post/5ae755366fb9a07ab508adc6
+由于篇幅问题,如果对 `Semaphore` 源码感兴趣的朋友可以看下这篇文章:https://juejin.im/post/5ae755366fb9a07ab508adc6
### 4 CountDownLatch (倒计时器)
`CountDownLatch` 允许 `count` 个线程阻塞在一个地方,直至所有线程的任务都执行完毕。
-`CountDownLatch` 是共享锁的一种实现,它默认构造 AQS 的 `state` 值为 `count`。当线程使用 `countDown()` 方法时,其实使用了`tryReleaseShared`方法以 CAS 的操作来减少 `state`,直至 `state` 为 0 。当调用 `await()` 方法的时候,如果 `state` 不为 0,那就证明任务还没有执行完毕,`await()` 方法就会一直阻塞,也就是说 `await()` 方法之后的语句不会被执行。然后,`CountDownLatch` 会自旋 CAS 判断 `state == 0`,如果 `state == 0` 的话,就会释放所有等待的线程,`await()` 方法之后的语句得到执行。
+`CountDownLatch` 是共享锁的一种实现,它默认构造 AQS 的 `state` 值为 `count`。当线程使用 `countDown()` 方法时,其实使用了`tryReleaseShared`方法以 CAS 的操作来减少 `state`,直至 `state` 为 0 。当调用 `await()` 方法的时候,如果 `state` 不为 0,那就证明任务还没有执行完毕,`await()` 方法就会一直阻塞,也就是说 `await()` 方法之后的语句不会被执行。然后,`CountDownLatch` 会自旋 CAS 判断 `state == 0`,如果 `state == 0` 的话,就会释放所有等待的线程,`await()` 方法之后的语句得到执行。
#### 4.1 CountDownLatch 的两种典型用法
-1. 某一线程在开始运行前等待 n 个线程执行完毕。将 CountDownLatch 的计数器初始化为 n :`new CountDownLatch(n)`,每当一个任务线程执行完毕,就将计数器减 1 `countdownlatch.countDown()`,当计数器的值变为 0 时,在`CountDownLatch上 await()` 的线程就会被唤醒。一个典型应用场景就是启动一个服务时,主线程需要等待多个组件加载完毕,之后再继续执行。
-2. 实现多个线程开始执行任务的最大并行性。注意是并行性,不是并发,强调的是多个线程在某一时刻同时开始执行。类似于赛跑,将多个线程放到起点,等待发令枪响,然后同时开跑。做法是初始化一个共享的 `CountDownLatch` 对象,将其计数器初始化为 1 :`new CountDownLatch(1)`,多个线程在开始执行任务前首先 `coundownlatch.await()`,当主线程调用 countDown() 时,计数器变为 0,多个线程同时被唤醒。
+1. 某一线程在开始运行前等待 n 个线程执行完毕。将 `CountDownLatch` 的计数器初始化为 n :`new CountDownLatch(n)`,每当一个任务线程执行完毕,就将计数器减 1 `countdownlatch.countDown()`,当计数器的值变为 0 时,在`CountDownLatch上 await()` 的线程就会被唤醒。一个典型应用场景就是启动一个服务时,主线程需要等待多个组件加载完毕,之后再继续执行。
+2. 实现多个线程开始执行任务的最大并行性。注意是并行性,不是并发,强调的是多个线程在某一时刻同时开始执行。类似于赛跑,将多个线程放到起点,等待发令枪响,然后同时开跑。做法是初始化一个共享的 `CountDownLatch` 对象,将其计数器初始化为 1 :`new CountDownLatch(1)`,多个线程在开始执行任务前首先 `coundownlatch.await()`,当主线程调用 `countDown()` 时,计数器变为 0,多个线程同时被唤醒。
#### 4.2 CountDownLatch 的使用示例
@@ -393,27 +393,27 @@ for (int i = 0; i < threadCount-1; i++) {
这样就导致 `count` 的值没办法等于 0,然后就会导致一直等待。
-如果对 CountDownLatch 源码感兴趣的朋友,可以查看: [【JUC】JDK1.8 源码分析之 CountDownLatch(五)](https://www.cnblogs.com/leesf456/p/5406191.html)
+如果对 `CountDownLatch` 源码感兴趣的朋友,可以查看: [【JUC】JDK1.8 源码分析之 CountDownLatch(五)](https://www.cnblogs.com/leesf456/p/5406191.html)
#### 4.3 CountDownLatch 的不足
-CountDownLatch 是一次性的,计数器的值只能在构造方法中初始化一次,之后没有任何机制再次对其设置值,当 CountDownLatch 使用完毕后,它不能再次被使用。
+`CountDownLatch` 是一次性的,计数器的值只能在构造方法中初始化一次,之后没有任何机制再次对其设置值,当 `CountDownLatch` 使用完毕后,它不能再次被使用。
#### 4.4 CountDownLatch 相常见面试题
-解释一下 CountDownLatch 概念?
+解释一下 `CountDownLatch` 概念?
-CountDownLatch 和 CyclicBarrier 的不同之处?
+`CountDownLatch` 和 `CyclicBarrier` 的不同之处?
-给出一些 CountDownLatch 使用的例子?
+给出一些 `CountDownLatch` 使用的例子?
-CountDownLatch 类中主要的方法?
+`CountDownLatch` 类中主要的方法?
### 5 CyclicBarrier(循环栅栏)
-CyclicBarrier 和 CountDownLatch 非常类似,它也可以实现线程间的技术等待,但是它的功能比 CountDownLatch 更加复杂和强大。主要应用场景和 CountDownLatch 类似。
+`CyclicBarrier` 和 `CountDownLatch` 非常类似,它也可以实现线程间的技术等待,但是它的功能比 `CountDownLatch` 更加复杂和强大。主要应用场景和 `CountDownLatch` 类似。
-> CountDownLatch 的实现是基于 AQS 的,而 CycliBarrier 是基于 ReentrantLock(ReentrantLock 也属于 AQS 同步器)和 Condition 的.
+> `CountDownLatch` 的实现是基于 AQS 的,而 `CycliBarrier` 是基于 `ReentrantLock`(`ReentrantLock` 也属于 AQS 同步器)和 `Condition` 的.
CyclicBarrier 的字面意思是可循环使用(Cyclic)的屏障(Barrier)。它要做的事情是,让一组线程到达一个屏障(也可以叫同步点)时被阻塞,直到最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续干活。CyclicBarrier 默认的构造方法是 `CyclicBarrier(int parties)`,其参数表示屏障拦截的线程数量,每个线程调用`await`方法告诉 CyclicBarrier 我已经到达了屏障,然后当前线程被阻塞。
@@ -436,7 +436,7 @@ public CyclicBarrier(int parties, Runnable barrierAction) {
#### 5.1 CyclicBarrier 的应用场景
-CyclicBarrier 可以用于多线程计算数据,最后合并计算结果的应用场景。比如我们用一个 Excel 保存了用户所有银行流水,每个 Sheet 保存一个帐户近一年的每笔银行流水,现在需要统计用户的日均银行流水,先用多线程处理每个 sheet 里的银行流水,都执行完之后,得到每个 sheet 的日均银行流水,最后,再用 barrierAction 用这些线程的计算结果,计算出整个 Excel 的日均银行流水。
+`CyclicBarrier` 可以用于多线程计算数据,最后合并计算结果的应用场景。比如我们用一个 Excel 保存了用户所有银行流水,每个 Sheet 保存一个帐户近一年的每笔银行流水,现在需要统计用户的日均银行流水,先用多线程处理每个 sheet 里的银行流水,都执行完之后,得到每个 sheet 的日均银行流水,最后,再用 barrierAction 用这些线程的计算结果,计算出整个 Excel 的日均银行流水。
#### 5.2 CyclicBarrier 的使用示例
@@ -519,7 +519,7 @@ threadnum:6is finish
可以看到当线程数量也就是请求数量达到我们定义的 5 个的时候, `await`方法之后的方法才被执行。
-另外,CyclicBarrier 还提供一个更高级的构造函数`CyclicBarrier(int parties, Runnable barrierAction)`,用于在线程到达屏障时,优先执行`barrierAction`,方便处理更复杂的业务场景。示例代码如下:
+另外,`CyclicBarrier` 还提供一个更高级的构造函数`CyclicBarrier(int parties, Runnable barrierAction)`,用于在线程到达屏障时,优先执行`barrierAction`,方便处理更复杂的业务场景。示例代码如下:
```java
/**
@@ -597,7 +597,7 @@ threadnum:7is finish
#### 5.3 `CyclicBarrier`源码分析
-当调用 `CyclicBarrier` 对象调用 `await()` 方法时,实际上调用的是`dowait(false, 0L)`方法。 `await()` 方法就像树立起一个栅栏的行为一样,将线程挡住了,当拦住的线程数量达到 parties 的值时,栅栏才会打开,线程才得以通过执行。
+当调用 `CyclicBarrier` 对象调用 `await()` 方法时,实际上调用的是`dowait(false, 0L)`方法。 `await()` 方法就像树立起一个栅栏的行为一样,将线程挡住了,当拦住的线程数量达到 `parties` 的值时,栅栏才会打开,线程才得以通过执行。
```java
public int await() throws InterruptedException, BrokenBarrierException {
@@ -698,18 +698,18 @@ threadnum:7is finish
**下面这个是国外一个大佬的回答:**
-CountDownLatch 是计数器,只能使用一次,而 CyclicBarrier 的计数器提供 reset 功能,可以多次使用。但是我不那么认为它们之间的区别仅仅就是这么简单的一点。我们来从 jdk 作者设计的目的来看,javadoc 是这么描述它们的:
+`CountDownLatch` 是计数器,只能使用一次,而 `CyclicBarrier` 的计数器提供 `reset` 功能,可以多次使用。但是我不那么认为它们之间的区别仅仅就是这么简单的一点。我们来从 jdk 作者设计的目的来看,javadoc 是这么描述它们的:
> CountDownLatch: A synchronization aid that allows one or more threads to wait until a set of operations being performed in other threads completes.(CountDownLatch: 一个或者多个线程,等待其他多个线程完成某件事情之后才能执行;)
> CyclicBarrier : A synchronization aid that allows a set of threads to all wait for each other to reach a common barrier point.(CyclicBarrier : 多个线程互相等待,直到到达同一个同步点,再继续一起执行。)
-对于 CountDownLatch 来说,重点是“一个线程(多个线程)等待”,而其他的 N 个线程在完成“某件事情”之后,可以终止,也可以等待。而对于 CyclicBarrier,重点是多个线程,在任意一个线程没有完成,所有的线程都必须等待。
+对于 `CountDownLatch` 来说,重点是“一个线程(多个线程)等待”,而其他的 N 个线程在完成“某件事情”之后,可以终止,也可以等待。而对于 `CyclicBarrier`,重点是多个线程,在任意一个线程没有完成,所有的线程都必须等待。
-CountDownLatch 是计数器,线程完成一个记录一个,只不过计数不是递增而是递减,而 CyclicBarrier 更像是一个阀门,需要所有线程都到达,阀门才能打开,然后继续执行。
+`CountDownLatch` 是计数器,线程完成一个记录一个,只不过计数不是递增而是递减,而 `CyclicBarrier` 更像是一个阀门,需要所有线程都到达,阀门才能打开,然后继续执行。
### 6 ReentrantLock 和 ReentrantReadWriteLock
-ReentrantLock 和 synchronized 的区别在上面已经讲过了这里就不多做讲解。另外,需要注意的是:读写锁 ReentrantReadWriteLock 可以保证多个线程可以同时读,所以在读操作远大于写操作的时候,读写锁就非常有用了。
+`ReentrantLock` 和 `synchronized` 的区别在上面已经讲过了这里就不多做讲解。另外,需要注意的是:读写锁 `ReentrantReadWriteLock` 可以保证多个线程可以同时读,所以在读操作远大于写操作的时候,读写锁就非常有用了。
### 参考
@@ -725,4 +725,4 @@ ReentrantLock 和 synchronized 的区别在上面已经讲过了这里就不多
**Java 工程师必备学习资源:** 一些 Java 工程师常用学习资源公众号后台回复关键字 **“1”** 即可免费无套路获取。
-
+
\ No newline at end of file
From dbfc4ed69d9e81090b6698bd19324312afb143c8 Mon Sep 17 00:00:00 2001
From: guide
Date: Sun, 25 Apr 2021 12:53:54 +0800
Subject: [PATCH 11/11] =?UTF-8?q?Update=20=E7=B1=BB=E5=8A=A0=E8=BD=BD?=
=?UTF-8?q?=E8=BF=87=E7=A8=8B.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...61\273\345\212\240\350\275\275\350\277\207\347\250\213.md" | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git "a/docs/java/jvm/\347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md" "b/docs/java/jvm/\347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md"
index 57e93235be4..30fd1f767d0 100644
--- "a/docs/java/jvm/\347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md"
+++ "b/docs/java/jvm/\347\261\273\345\212\240\350\275\275\350\277\207\347\250\213.md"
@@ -68,7 +68,9 @@ Class 文件需要加载到虚拟机中之后才能运行和使用,那么虚
### 初始化
-初始化是类加载的最后一步,也是真正执行类中定义的 Java 程序代码(字节码),初始化阶段是执行初始化方法 ` ()`方法的过程。
+初始化阶段是执行初始化方法 ` ()`方法的过程,是类加载的最后一步,这一步 JVM 才开始真正执行类中定义的 Java 程序代码(字节码)。
+
+> 说明: ` ()`方法是编译之后自动生成的。
对于` ()` 方法的调用,虚拟机会自己确保其在多线程环境中的安全性。因为 ` ()` 方法是带锁线程安全,所以在多线程环境下进行类初始化的话可能会引起死锁,并且这种死锁很难被发现。