我永远吹着泡泡

【读书笔记】码出高效：Java开发手册

第一章计算机基础

走进0与1的世界
- 计算机就是晶体管、电路板组装起来的电子设备，无论是图形图像的渲染、网络远程共享，还是大数据计算，归根到底都是 0 与 1 的信号处理。信息存储和逻辑计算的元数据只能是 0 与 1，但它们在不同介质里的物理表现方式却是不太一样的，如三极管的通电与断电、CPU 的低电平与高电平、磁盘的电荷左右方向。明确了 0 与 1 的物理表现方式后，设定基数为 2，进位规则是”逢二进一“，借位规则是”借一当二“，所以称为二进制
- 假设有 8 条电路，每条电路有低电平和高电平两种状态。根据数学排列，有 8 个 2 相乘，能够表示 256 种信号。假设表示区间为 0~255，那么 32 条电路能够表示的最大数为 2 的 32 次方减 1 ，平时所有的 32 位机器就能够处理字长位 32 位的电路信号
- 如何表示负数呢，8 条电路时最左侧的一条表示正负，0 表示正数，1 表示负数，不参与数值表示。8 条电路的最大值为 01111111 即 127。表示范围因有正负之分而改变为 -128~127。二进制整数最终都是以补码形式出现的。正数的补码与原码、反码是一样的，负数的补码是反码加一的结果。在各类编程语言中，均规定了不同数组类型的表示范围，有相应的最大值和最小值。例如一个计算需要 9 条电路来表示，但用 8 条电路来表示是就会出现溢出
- 一条电路线在计算机中被称为 1 位，即 1 个 bit，简写为 b。8 个 bit 组成一个单位，称为一个字节，即 1 个 Byte，简写为 B，1024 个 Byte 简写为 KB，1024 个 KB 简写为 MB，1024 个 MB 简写为 GB
浮点数
- 计算机定义了两种小数，分别为定点数和浮点数
  - 定点数的小数点位置是固定的，在确定字长的系统中一旦指定小数点的位置后，它的整数部分和小数部分也随之确定
  - 浮点数是采用科学计算法来表示的，由符号位、有效数字、指数三部分组成
```
    float a = 1f;
    float b = 0.9f;
    float f = a-b;
    // 输出
    // 0.100000024
```
- 科学计数法
  - 浮点数是计算机用来表示小数的一种数据类型，在数学中采用科学计数法来近似表示一个极大或极小且位数较多的数
  - 科学计数法的有效数字为从第 1 个非零数字开始的全部数字，指数决定小数点的位置，符号表示该数的正与负。十进制科学计数法要求有效数字的整数部分必须在 [1,9]区间内
- 浮点数表示
  - 略
字符集与乱码
CPU与内存
- CPU （Central Processing Unit）是一块超大规模的集成电路板，是计算机的核心部件，承载着计算机的主要运算和控制功能，是计算机指令的最终解释模块和执行模块。硬件包括基板、核心、针脚，基板用来固定核心和针脚，针脚通过基板上的基座连接电路信号
- 控制器：由控制单元、指令译码器、指令寄存器组成。控制单元是 CPU 的大脑，由时序控制和指令控制等组成；指令译码器是在控制单元的协调下完成指令读取、分析并交由运算器执行等操作；指令寄存器是存储指令集，当前流行的指令集包括 X86、SSE、MMX等。控制器有点像一个变成语言的编译器，输入 0 与 1 的源码流，通过译码和控制单元对存储设备的数据进行读取，运算完成后，保存回寄存器，甚至内存
- 运算器：运算器的核心是算数逻辑运算单元，即ALU，能够执行算术运算或逻辑运算等各种命令，运算单元会从寄存器中提取或存储数据。相对控制单元来说，运算器是受控的执行部件。任何编程语言诸如 a+b 的算术运算，无论字节码指令还是汇编指令，最后一定会以 0 与 1 的组合流方式在部件内完成最终计算，并保存到寄存器，最后送出 CPU。平时理解的栈与堆，在 CPU 眼里都是内存
- 寄存器：最著名的寄存器是 CPU 的高速缓存 L1、L2，缓存容量是在组装计算机时必问的两个 CPU 性能问题之一
- 存储单元都有一个十六进制的编号，在 32 位机器上是 0x 开始的 8 位数字编号，就是内存存储单元的地址，相当于门牌号。以 C 和 C++ 为代表的编程语言可以直接操作内存地址，进行分配和释放。而以 Java 为代表的编程语言，内存就交给 JVM 进行自动分配与释放，这个过程被称为垃圾回收机制
TCP/IP
- 网络协议
  - 计算机诞生后，从单机模式应用发展到多台计算机连接起来，形成计算机网络，是信息共享、多机协作、大规模计算等称为现实。计算机网络需要解决的第一个问题是如何无障碍地发送和接收数据。而这个发送和接收数据地过程需要相应地协议来支撑，按互相可以理解的方式进行数据的打包与解包，使不同厂商的设备在不同类型的操作系统上实现顺畅的网络通信
  - TCP/IP（Transmission Control Protocol/Internet Protocol）中文译为传输控制协议/因特网互联协议，这个大家族里的其他知名协议还有 HTTP、HTTPS、FTP、SMTP、UDP、ARP、PPP、IEEE802.x 等，TCP/IP 是当前流行的网络传输协议框架，从严格意义上讲它是一个协议族，因为 TCP、IP 是其中最为核心的协议，所以就把该协议族称为 TCP/IP，而另一个是耳熟能详的 ISO/OSI 的七层传输协议，其中 OSI（Open System Interconnection）的出发点是想设计出计算机世界通用的网络通信基本框架，已被淘汰
  - 链路层：单个 0、1 是没有意义的，链路层以字节为单位把 0 与 1 进行分组，定义数据帧，写入源和目标机器的物理地址、数据、校验位来传输数据
    - MAC 地址长 6 个字节共 48 位，通常使用十六进制数表示。使用 ifconfig -a 命令即可看到 MAC 地址。如图 f4:5c:89。即前 24 位由管理机构统一分配，后 24 位由厂商自己分配，保证网卡全球唯一。网卡就像是家庭地址一样，是计算机世界范围内的唯一标识
  - 网络层：根据 IP 定义网络地址，区分网络。子网内根据地址解析协议（ARP）进行 MAC 寻址，子网外进行路由转发数据包，这个数据包即 IP 数据包
  - 传输层：数据包通过网络层发送到目标计算机后，应用程序在传输层定义逻辑端口，确认数据后，将数据包交给应用程序，实现端口到端口间通信。最典型的传输层协议时 UDP 和 TCP。UDP 只是在 IP 数据包上增加端口等部分信息，是面向无连接的，是不可靠传输，多用于视频通话、电话会议等（即使少一帧数据也无妨）。与之相反，TCP 是面向连接的。所谓面向连接，是一种端到端间通过失败重传机制建立的可靠数据传输方式
  - 应用层：传输层的数据到达应用程序时，以某种统一规定的协议格式解读数据。比如：E-mail 在各个公司的程序界面、操作、管理方式都不一样，但是都能够读取邮件内容，是因为 SMTP 协议就像传统的书信格式一样，按规定填写邮编及收信人信息
  - 总结：程序在发送消息时，应用层按既定的协议打包数据，随后由传输层加上双方的端口号，由网络层加上双方的 IP 地址，由链路层加上双方的 MAC 地址，并将数据拆分成数据帧，经过多个路由器和网关后，到达目标机器。就是按“端口 -> IP地址 -> MAC地址”这样的路径进行数据的封装和发送，解包的时候进行反操作即可
- IP 协议
  - IP 是面向无连接、无状态的，没有额外的机制保证发送的包是否有序到达。IP 首先规定出 IP 地址格式，该地址相当于在逻辑意义上进行了网段的划分，给每台计算机额外设置了一个唯一的详细地址。在全世界范围内，不可能通过广播的方式，从数以万计的计算机里找到目标 MAC 地址的计算机而不超时。在数据投递时就需要对地址进行分层管理
  - IP 地址属于网络层，主要功能在 WLAN 内进行路由寻址，选择最佳路由。IP 报文格式共 32 位 4 个字节，通常用十进制数来表示。IP 地址的掩码 0xffffff00 表示 255.255.255.0，掩码相同，则在同一个子网内
  - 协议结构比较简单，TTL 即数据包可经过的最多路由总数，TTL 初始值由源主机设置后，数据包在传输过程中每经过一个路由器 TTL 值减 1，当该字段位 0 时，数据包被丢弃，并发送 ICMP 报文通知源主机，以防止源主机无休止地发送报文。ICMP（Internet Control Message Protcol），它是检测传输网络是否通畅、主机是否可达、路由是否可用等网络运行状态的协议。ICMP 虽然并不传输用户数据，但对评估网络健康状态非常重要，常用的 ping、tracert 命令就是基于 ICMP 检测网络状态的有力工具。TTL 右侧挂载协议标识表示 IP 数据包里放置的子数据包协议类型，如 6 代表 TCP、17 代表 UDP 等
  - IP 报文在互联网上传输时，可能要经历多个物理网络，才能从源主机到达目标主机。比如在手机上给某个 PC 端的朋友发送一个信息，经过无线网的 IEE802.1x 认证，转到光纤通信，然后进入内部企业网 802.3，并最终到达目标 PC。由于不同的硬件和物理特性不同，对数据帧的最大长度都有不同的限制，这个最大长度被称为最大传输单元，即 MTU（Maximum Transmission Unit）。那么在不同的物理网之间就可能需要对 IP 报文进行分片，这个工作通常由路由器负责完成
  - IP 是 TCP/IP 的基石，几乎所有其他协议都建立在 IP 所提供的服务基础上进行传输，其中包括在实际应用中用户传输稳定有序数据得 TCP
- TCP 建立连接
  - TCP 传输控制协议（Transmission Control Propocol），是一种面向连接、确保数据在端到端间可靠传输的协议。面向连接是指在发送数据前，需要先建立一条虚拟的链路，然后让数据在这条链路上“流动”完成传输。为了确保数据的可靠传输，不仅需要对发出的每个字节进行编号确认，校验每一个数据包的有效性，在出现超时情况时进行重传，还需要通过实现滑动窗口和拥塞控制等机制，避免网络状况恶化而最终影响数据传输的极端情况。每个 TCP 数据包是封装在 IP 包中的，每个 IP 头的后面紧跟的是 TCP 头
  - 协议第一行的两个端口各占两个字节，分别表示了源机器和目标机器的端口号。这两个端口号与 IP 报头中的源 IP 地址和目标 IP 地址所组成的四元组可唯一标识一条 TCP 连接。由于 TCP 是面向连接的，因此有服务端和客户端之分。需要服务端先在相应的端口上进行监听，准备好接收客户端发起的建立连接请求。当客户端发起第一个请求连接的 TCP 包时，目标机器端口就是服务端所监听的端口号。比如一些由国际组织定义的广为人知端口号-代表 HTTP 服务的 80 端口、代表 SSH 服务的 22 端口、代表 HTTPS 服务的 443 端口。可以通过 netstat 命令列出在机器上已建立的连接信息，其中包含唯一标识一条连接的四元组，以及各连接的状态等内容。如图红框代码表端口号
  - 协议第二行和第三行是序列号，各占 4 个字节。前者是指所发送数据包中数据部分的第一个字节的序号，后者是指期望收到来自对方的下一个数据包中数据部分第一个字节的序号
  - 由于 TCP 报头中存在一些扩展字段，所以需要通过长度为 4 个 bit 的头部长度字段表示 TCP 报头的大小，这样接收方才能准确地计算出包中数据部分的开始位置
  - TCP 的 FLAG 位由 6 个 bit 组成，分别代表 ACK、SYN、FIN、URG、PSH、RST，都以置 1 表示有效。SYN（Synchronize Sequence Numbers）用作建立连接时的同步信号；ACK（Acknowledgement）用于对收到的数据进行确认，所确认的数据由确认序列号表示；FIN（Finish）表示后面没有数据需要发送，通常意味着所建立的连接需要关闭了
  - TCP 正常情况下通过三次握手建立连接，三次握手指的是建立连接的三个步骤
    - A 机器发出一个数据包并将 SYN 置 1，表示希望建立连接，这个包中的序列号假设是 x
    - B 机器收到 A 机器发过来的数据包后，通过 SYN 得知这是一个建立连接的请求，于是发送一个响应包并将 SYN 和 ACK 标记都置 1，假设这个包中的序列号是 y，而确认序列号必须是 x+1，表示收到了 A 发过来的 SYN，在 TCP 中，SYN 被当作数据部分的一个字节
    - A 收到 B 的响应包后需要确认，确认包中将 ACK 置 1，并将确认序号设置位 y+1，表示收到了来自 B 的 SYN
  - 三次握手的目的
    - 三次握手有两个目的，信息对等和防止超时
    - 信息对等
    - 防止超时。TTL 网络报文的生存时间往往都会超过 TCP 请求超时时间，如果两次握手就可以创建连接，传输数据并释放连接后，第一个超时的连接请求才到达 B 机器的话，B 机器会以为 A 创建新连接的请求，然后确认同意创建连接。因为 A 机器的状态不是 SYN_SENT，所以直接丢弃了 B 的确认数据，以致最后只是 B 机器方面创建连接完毕。如果是三次握手，则 B 机器收到连接请求后，同样会向 A 机器确认同意创建连接，但因为 A 机器不是 SYN_SENT 状态，所以会直接丢弃，B 机器由于长时间没有收到确认信息，最后超时导致连接创建失败，因为不会出现脏连接
  - 从编程的角度，TCP 连接的建立时通过文件描述符（File Descriptor，fd）完成的，通过创建套接字获得一个 fd，然后服务端和客户端需要基于所获得的 fd 调用不同的函数分别进入监听状态和发起连接请求。由于 fd 的数量将决定服务端进程所能建立连接的数量，对于大规模分布式服务来说，当 fd 不足时就会出现 “open too many fils” 错误而使得无法建立更多的连接。为此，需要注意调整服务端进程和操作系统所支持的最大文件句柄数
    - 通过使用 ulimit -n 命令来查看单个进程可以打开文件句柄的数量，如果想查看当前系统各个进程产生了多少句柄，可以使用如下句柄：
```
    lsof -n | awk '{print $2} '| sort |uniq -c |sort -nr|more
```
      - 左侧列是句柄数，右侧列是进程号。lsof 命令用于查看当前系统所打开 fd 的数量，在 Linux 系统中，很多资源都是以 fd 的形式进行读写的，除了提到的文件和 TCP 连接，UDP 数据报、输入输出设备等都被抽象成了 fd
    - 想知道具体的 PID 对应的具体应用程序是什么，使用如下命令即可
```
    ps -ax | grep 32764
```
    - TCP 在协议层面支持 Keep Alive 功能，即隔段时间通过向对方发送数据表示连接处于健康状态。不少服务将确保连接健康的行为放到了应用层，通过定期发送心跳包检查连接的健康度。一旦心跳包出现异常不仅会主动关闭连接，还会回收与连接相关的其他用户提供服务的资源，确保系统资源最大限度地被有效利用
- TCP 断开连接
  - TCP 是全双工通信，双方都能作为数据的发送发和接收方，但 TCP 连接也会有断开的时候。所谓相爱容易分守难，建立连接只有三次，而挥手断开则需要四次。A 机器想要关闭连接，则待本方数据发送完毕后，传递 FIN 信号给 B 机器。B 机器应答 ACK，告诉 A 机器可以断开，但是需要等 B 机器处理完数据，再主动给 A 机器发送 FIN 信号。这时，A 机器处于半关闭状态（FIN_WAIT_2），无法再发送新的数据。B 机器做好连接关闭前的准备工作，发送 FIN 给 A 机器，此时 B 机器也进入半关闭状态（CLOSE_WAIT）。A 机器发送针对 B 机器 FIN 的 ACK 后，进入 TIME_WAIT 状态，经过 2MSL（Maximum Segment Lifetime）后，没有收到 B 机器传来的报文，则确定 B 机器已经收到 A 机器最后发送的 ACK 指令，此时 TCP 连接正式释放
  - 通过抓包分析，如图所示红色箭头表示 B 机器已经清理好现场，并发送 FIN+ACK。注意，B 机器主动发送的两次 ACK 应答的都是 81，第一次进入 CLOSE_WAIT 状态，第二次应答进入 LAST_ACK 状态，表示可以断开连接，在绿色箭头处，A 机器应答的就是 Seq=81
  - TIME_WAIT 和 CLOSE_WAIT 分别表示主动关闭和被动关闭产生的阶段性状态，如果线上服务器大量出现这两种状态，就会加重机器负载，也会影响有效连接的创建
    - TIME_WAIT：主动要求关闭的机器表示收到了对方的 FIN 报文，并发送出了 ACK 报文，进入 TIME_WAIT 状态，等 2MSL 后即可进入到 CLOSED 状态。如果 FIN_WAIT_1 状态下，同时收到带 FIN 标志和 ACK 标志的报文时，可以直接进入 TIME_WAIT 状态，而无须经过 FIN_WAIT_2 状态
    - CLOSE_WAIT：被动要求关闭的机器收到对方请求关闭连接的 FIN 报文，在第一次 ACK 应答后，马上进入 CLOSE_WAIT 状态。这种状态其实表示在等待关闭，并且通知应用程序发送剩余数据，处理现场信息，关闭相关资源
  - 在 TIME_WAIT 等待的 2MSL 是报文在网络上生存的最长时间，超过阈值便将报文丢弃。一般来说，MSL 大于 TTL 衰减至 0 的时间。在 RFC793 中规定 MSL 为 2 分钟。但是在当前的高速网络中，2 分钟的等待时间会造成资源的极大浪费，在高并发服务器上通常会使用更小的值，既然 TIME_WAIT 貌似百害无一利为何不直接关闭，而进入 CLOSED 状态呢？
    - 第一，确认被动关闭方能够顺利进入 CLOSED 状态。假如最后一个 ACK 由于网络原因导致无法到达 B 机器，处于 LAST_ACK 的 B 机器通常“自信”地以为对方没有收到自己的 FIN+ACK 报文，所以会重发。A 机器收到第二次的 FIN+ACK 报文，会重发一次 ACK，并且重新计时。如果 A 机器收到 B 机器的 FIN+ACK 报文后，发送一个 ACK 给 B 机器，就“自私”地立马进入 CLOSED 状态，可能会导致 B 机器无法确保收到最后的 ACK 指令，也无法进入 CLOSED 状态，这是 A 机器不负责任的表现
    - 第二，防止失效请求。这样做是为了防止已失效连接的请求数据包与正常连接的请求数据包混淆而发生异常
  - 因为 TIME_WAIT 状态无法真正释放句柄资源，在此期间，Socket 中使用的本地端口在默认情况下不能再被使用。该限制对客户端机器来说无所谓，但对于高并发服务器来说，会极大地限制有效连接的常见数量，所以，建议将高并发服务器 TIME_WAIT 超时时间调小
  - 在服务器上通过变更 /etc/sysctl.conf 文件来i需改该省略值（秒）
```
    net.ipv4.tcp_fin_timeout=30(建议小于30秒为宜)
```
  - 修改完成过后执行 /sbin/sysctl -p 让参数生效即可，可以通过如下命令查看各连接状态的计数情况
```
    netstat -n | awk '/^tcp/ {++S[$NF]} END {for(a in S) print a,S[a]}'
```
  - 在 sysctl.conf 中还有其他连接参数也用来不断地调优服务器 TCP 连接能力，以提升服务器的有效利用率。TIME_WAIT 是挥手四次断开连接的尾声，如果此状态连接过多，则可以通过优化服务器参数得到解决。如果不是对方连接的异常，一般不会出现无法关闭的情况。但是 CLOSE_WAIT 过多很可能是程序自身的问题，比如在对方关闭连接后，程序没有检测到，或者忘记自己关闭连接。通过命令，查看未关闭的连接
```
    netstat -ant |grep -i "443" |grep CLOSE_WAIT|wc -l
```
连接池
- 在实际业务中，假如数据库配置的 MAX 是 100，一个请求 10 ms，则最大能够处理 10000 QPS，增大连接数，有可能会超过单台服务器的正常负载能力，另外，连接数的创建是受到服务器操作系统的 fd (文件描述符) 数量限制的。创建更多的活跃连接，就需要消耗更多的 fd，系统默认单进程可同时拥有 1024 个 fd，该值虽然可以适当调整，但如果无限制地增加，会导致服务器在 fd 的维护和切换上消耗过多的精力从而降低应用吞吐量
- 一般可以把连接池的最大连接数设置在 30 个左右，理论上还可以设置更大值，但是 DBA 一般不会允许，因为往往只有出现了慢 SQL，才需要使用更多连接数，这时候通常需要优化应用层逻辑或者创建数据库索引，而不是一味地采用加大连接数这种治标不治本的做法
- 从经验上看，在数据库层面的请求应答时间必须在 100ms 以内，秒级的 SQL 查询通常存在巨大的性能提升空间
  - 建立高效且合适的索引
  - 排查连接资源未显示关闭的情形
  - 合并短的请求
  - 合理拆分多个表 join 的 SQL，若是超过三个表则禁止 join。三表 join 的数据量由于笛卡儿积操作会呈几何级数增加，所以不推荐
  - 使用临时表
  - 应用层优化
  - 改用其他数据库。针对不同的业务场景选择不同的数据库
信息安全
- 黑客与安全
  - 互联网公司都需要建立一套完整的信息安全体系，遵顼 CIA 原则，即保密性（Confidentiality）、完整性（Integrity）、可用性（Availability）
- SQL 注入
  - SQL 注入是注入式攻击中常见的类型，SQL 注入式攻击时未将代码与数据进行严格的隔离，导致在读取用户数据的时候，错误地把数据作为代码的一部分执行，从而导致一些安全问题
  - SQL 注入的防范
    - 过滤用户输入参数中的特数字符，从而降低被SQL 注入的风险
    - 禁止通字符串拼接的 SQL 语句，严格使用参数绑定传入的 SQL 参数
    - 合理使用数据库访问框架提供的防注入机制
- XSS与CSRF
  - XSS：跨站脚本攻击，即 Cross-Site Scripting，为了不和前端开发中层叠样式表（CSS）的名字冲突，简称 XSS。XSS 是指黑客通过技术手段，向正常用户请求的 HTML 页面中插入恶意脚本，从而可以执行任意脚本。XSS 主要分为反射型 XSS、存储型 XSS 和 DOM 型 XSS
  - CSRF：跨站请求伪造，即 Cross-Site Request Forgery，简称 CSRF，也被称为 One-click Attack，即在用户并不知情的情况下，冒充用户发起请求，在当前已经登陆的 Web 应用程序上执行恶意操作，如恶意发帖、修改密码、发邮件等
  - CSRF 有别于 XSS，从攻击效果上，两者有重合的地方
    - XSS 是在正常用户请求的 HTML 页面中执行了黑客提供的恶意代码；CSRF 是黑客直接盗用用户浏览器中的登录信息，冒充用户去执行黑客指定的操作
    - XSS 问题是出在用户数据没有过滤、转义；CSRF 问题是出在 HTTP 接口没有防范不受信任的调用
  - 防范 CSRF 漏洞主要有以下方式
    - CSRF Token 验证，利用浏览器的同源限制，在 HTTP 接口执行前验证页面或者 Cookie 中设置的 Token，只有验证通过才继续执行请求
    - 人机交互，比如使用短信校验等
- HTTPS
  - HTTPS 的全称是 HTTP over SSL，简单的理解就是在之前的 HTTP 传输上增加了 SSL 协议的加密能力。SSL 协议工作于传输层与应用层之间，为应用提供数据的加密传输
  - RSA 它将密码革命性的分成公钥和私钥，由于公钥和私钥不相同，所以称为非对称加密。私钥是用来对公钥加密的信息进行解密的，是需要严格保密的，公钥是对信息进行加密，任何人都可以知道，包括黑客
    - 非对称加密的安全性是基于大质数分解的困难性，在非对称的加密中公钥和私钥是一对大质数函数。计算两个大质数的乘积是简单的，但是这个过程的你逆运算是非常困难的。在 RSA 的算法中，从一个公钥和密文中解密出明文的难度等同于分解两个大指数的难度。因此在实际传输中，可以把公钥发送给对方。一方发送信息时，使用另一方的公钥进行加密生成密文，收到密文的一方在使用私钥进行解密，这样就相对安全了
    - 非对称加密并不是完美的，它有个明显的缺点就是加密和解密耗时长，只适合对少量数据进行处理。我们担心对称加密中的密钥安全问题，那么将密钥的传输使用非对称加密就完美的解决了问题，实际上，HTTPS 也是使用这一种方式来建立安全的 SSL 连接的。整个过程如下：
      - 甲告诉乙，使用 RSA 算法进行加密。乙说，好的
      - 甲和乙分别根据 RSA 生成一对密钥，互相发送公钥
      - 甲使用乙的公钥给乙加密报文信息
      - 乙收到信息，并用自己的密钥进行解密
      - 乙使用同样方式给甲发送信息，甲使用相同方式进行解密
    - 整个过程看似无懈可击，但如果甲的送信使者中被拦截，然后拦截者自己生成一对密钥，然后冒充甲的使者到乙家，把自己的公钥给乙。这样乙会把信息都给中间的拦截者。这时就需要一个具有公信力的组织来证明身份。CA （Certificate Authority）就是颁发 HTTPS 证书的组织。HTTPS 是当前网站的主流文本传输协议，在基于 HTTPS 进行连接时，就需要数字证书。如图所示，可以看到协议版本、签名方案、签发的组织是 GlobalSign，这个证书的有效期至 2018 年 10 月 31 日
    - 访问一个 HTTPS 的网站的大致流程如下
      - 浏览器向服务器发送请求，请求中包括浏览器支持的协议，并附带一个随机数
      - 服务器收到请求后，选择某种非对称加密算法，把数字证书签名公钥、身份信息发送给浏览器，同时也附带一个随机数
      - 浏览器收到后，验证证书的真实性，用服务器的公钥发送握手信息给服务器
      - 服务器解密后，使用之前的随机数计算出一个对称加密的密钥，以此作为加密信息并发送
      - 后续所有的信息发送都是以对称加密方式进行
  - 传输层安全协议（Transport Layer Security,TLS），TLS 可以理解为 SSL 协议 3.0 版本的升级，所以 TLS 的 1.0 版本也被标识为 SSL3.1 版本。对于大的协议栈来说，SSL 和 TLS 并没有什么大的区别，因此在 Wireshark 里，分层依然使用的是安全套接字层（SSL）标识
  - 在整个 HTTPS 的传输协议中，主要分为两个部分：首先是 HTTPS 的握手，然后是数据的传输。前者是建立一个 HTTPS 的通道，并确定连接使用的加密套件及数据传输使用的密钥。而后者主要使用密钥对数据加密并传输
  - 整个连接的过程
    - 第一，客户端发送了一个 Client Hello 协议的请求：在 Client Hello 中最重要的信息是 Cihper Suites 字段，这里客户端会告诉服务端自己支持哪些加密的套件，比如在此次 SSL 连接中，客户端支持的加密套件协议如下
    - 第二，服务端在收到客户端发来的 Client Hello 的请求后，会返回一系列的协议数据，并以一个没有数据内容的 Server Hello Done 作为结束。这些协议数据有的是单独发送，有的则这合并发送
      - Server Hello 协议。主要告知客户端后续协议中要使用的 TLS 协议版本，这个版本主要和客户端与服务端支持的最高版本有关。比如本次确认后续的 TLS 协议版本是 TLSv1.2，并为本次连接分配一个会话 ID (Session ID)。此外，还会确认后续采用的加密套件（Cipher Suite），这里确认使用的加密套件为 TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256。该加密套件的基本含义为：使用非对称加密协议加密（RSA）进行对称协议加密（AES）密钥的加密，并使用对称加密协议（AES）进行信息的加密
      - Certificate 协议。主要传输服务端的证书内容
      - Server Key Exchange。如果在 Certifivate 协议中未给出客户端足够的信息，则会在 Server Key Exchange 进行补充。比如在本次连接中 Certificate 未给出证书的公钥（Public Key），这个公钥的信息将会通过 Server Key Exchange 发送给客户端
      - Certificate Request。这个协议是一个可选项，当服务端需要对客户端进行证书验证的时候，才会想客户端发送一个证书请求（Certificate Request）
      - 最后以 Server Hello Done 作为结束信息，告知客户端整个 Server hello 过程结束
    - 第三，客户端在收到服务端的握手信息后，根据服务端的请求，也会发送一系列的协议
      - Certificate。它是可选项。因为上文中服务端发送了 Certificate Request 需要对客户端进行证书验证，所以客户端要发送自己的证书信息
      - Client Key Exchange。它与上文中的 Server Key Exchange 类似，是对客户端 Certificate 信息的补充，在本次请求中同样是补充了客户端证书的公钥信息
      - Certification Verity。对服务端发送的证书信息进行确认
      - Change Cipher Specc。该协议不同于其他握手协议（Handshake Protocol），而是作为一个独立协议告知服务端，客户端已经接收之前服务端确认的加密套件，并会在后续通信中使用该加密套件进行加密
      - Encrypted Handshake Message。用于客户端给服务端加密套件加密一般 Finish 的数据，用以验证这条建立起来的加解密通道的正确性
    - 第四，服务端在接收客户端的确认信息及验证信息后，会对客户端发送的数据进行确认
      - Change Cipher Spec。通过使用私钥对客户端发送的数据进行解密，并告知后续将协商好的加密套件进行加密传输数据
      - Encrypted Handshake Message。与客户端的操作相同，发送一段 Finish 的加密数据验证加密通道的正确性
    - 最后，如果客户端和服务端都确认加解密无误后，各自按照之前约定的 Session Secret 对 Application Data 进行加密传输
编程语言的发展

第二章面向对象

OOP理念
- OOP目标
  - 可维护性、可重用性、可扩展性
- 面向过程与面向对象
  - 面向过程是让计算机有步骤地顺次做一件事，是一种过程化的叙事思维。面向过程的结构相对松散，强调如何流程化地解决问题
  - 面向对象是提出一种计算机世界里解决复杂软件工程的方法论，拆解问题复杂度，从人类思维角度提出解决问题的步骤和方案。面向对象的思维更加内聚，强调高内聚、低耦合，先抽象模型，定义共性行为，再解决实际问题
- 面向对象的特性
  - 面向对象有三大特性：封装、继承、多态。本书明确将“抽象”作为面向对象的特性之一
  - 封装是一种对象功能内聚的表现形式，使模块之间的聚合度变低，更具维护性
  - 继承使子类能够继承父类，获得父类的部分属性和行为，使模块更有复用性
  - 多态使模块在复用性基础上更加有扩展性，使运行期更有想象空间
  - 抽象分为归纳和演绎。归纳是从具体到本质，从个性到共性，将一类对象的共同特征进行归一化的逻辑思维过程；演绎是从本质到具体，从共性到个性，逐步形象化的过程
- Object类
  - 我是谁：getClass() 说明本质上是谁，而toString()是当前职位的名片
  - 我从哪里来：Object() 构造方法是生产对象的基本步骤，clone() 是繁殖对象的另一种方式
  - 我到哪里去：finalize() 是在对象销毁时触发的方法
  - 世界是否因你而不同：hashCode() 和 equals() 就是判断与其他元素是否相同的一组方法
  - 与他人如何协调：wait() 和 notify() 是对象间通信与协作的一组方法
初识 Java
类
- 类的定义
  - 类的定义由访问级别、类型、类名、是否抽象、是否静态、泛型标识、继承或实现关键字、父类或接口名称等组成，类的访问级别有 public 和无访问控制符，类型分为 class、interface、enum
  - Java 类主要由两部分组成：成员和方法。在定义类时，推荐首先定义变量，然后定义方法。由于公有方法是类的调用者和维护者最关心的方法，因此最好首屏展示；保护方法虽然只被子类关心，但也有可能是模板设计模式的核心方法，因此重要性仅次于公有方法；而私有方法对外来说是一个黑盒，因此不需要被特别关注，最后是 getter/setter 方法，虽然他们是公共方法，一般不包含业务逻辑，所以放在最后
- 接口与抽象类
  - 定义类的过程就是抽象和封装的过程，而接口与抽象类则是对实体类进行更高层次的抽象，仅定义公共行为和特征。接口与抽象类的共同点是都不能被实例化，但可以定义引用变量指向实例对象
  - 抽象类在被继承时体现的是 is-a 关系，即抽象类是对同类事物相对具体的抽象，通常包含抽象方法、实体方法、属性变量。如果一个抽象类只有一个抽象方法，他就等同于一个接口，它体现的是里氏替换原则；接口在被实现时体现的是 can-do 关系，即实现类有能力去实现并执行接口种定义的行为，它体现的是接口隔离原则
  - 抽象类是模板式设计，接口时契约式设计
- 内部类
  - 在一个 .java 源文件中，只能定一个类名与文件名完全一致的公开类，使用 public class 关键字来修饰。但在面向对象语言中，任何一个类都可以在内部定义另外一个类，前者为外部类，后者为内部类。内部类本身就是类的一个属性，与其他属性定义方式一致。例如，属性字段 private static String str，由访问控制符、是否静态、类型、变量名组成，而内部类 private static class Inner{}，这样来定义的，类型为 class、enum 甚至 interface。内部类可以是静态和非静态的。具体分类为四种
    - 静态内部类：static class StaticInnerClass{};
    - 成员内部类：private class InstanceInnerClass{};
    - 局部内部类：定义在方法或表达式内部
    - 匿名内部类：(new Thread(){}).start()
```
    public class OuterClass{

        // 成员内部类
        private class InstanceInnerClass{}

        // 静态内部类
        static class StaticInnerClass{}

        public static void main(String[] args){
            // 两个匿名内部类 分别对应 OuterClass$1 和 OuterClass$2
            (new Thread() {}).start();
            (new Thread() {}).start();

            // 两个方法内部类 分别对应 OuterClass$1MethodClass1 和 OuterClass$1MethodClass2
            class MethodClass1{}
            class MethodClass2{}

        } 
    }
```![在这里插入图片描述](https://img-blog.csdnimg.cn/20210218143954704.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xiaF9wYW9wYW8=,size_16,color_FFFFFF,t_70#pic_center)
  * 无论时什么类型的内部类，都会编译成一个独立的 .class 文件。外部类与内部类之间使用 $ 符号分隔，匿名内部类使用数字进行编号，而方法内部类，在类名前还有一个编号来识别时哪个方法。静态内部类时最常用的内部表现形式，外部可以使用 OuterClass.StaticInnerClass 直接访问，类加载与外部类在同一个阶段进行，在 JDK 源码中，定义包内可见静态内部类的方式很常见，这样的好处是：
      * 作用域不会扩散到包外
      * 可以通过“外部类.内部类”的方式直接访问
      * 内部类可以访问外部类中所有静态属性和方法
```
- 访问权限控制
  - 面向对象的核心思想之一是封装，只把有限的方法和成员公开，这也是迪米特法则的内在要求，使外部调用方对方法体内的实现细节知道的尽可能少，至于实现封装的方式，需要使用某些关键字来限制类外部对类属性和方法的随意访问
  - 访问权限控制符
    - public:可以修饰外部类、属性、方法，表示公开的、无限制的，是访问限制最松的一级，被其修饰的类、方法不仅可以被包内访问，还可以跨类、挎包访问，真是允许跨工程访问
    - protected：只能修饰属性和方法，表示受保护的、有限制的，被其修饰的属性和方法被包内及包外子类访问。注意，即使并非继承关系，protected 属性和方法在同一包内也是可见的
    - 无：即无任何访问权限控制符，千万不要说成是 default，它并非访问权限控制符的关键字，另外，在 JDK8 接口中引入 default 默认方法实现，更容易混淆两者释义。无访问权限控制符仅对包内可见。虽然无访问权限控制符还可以修饰外部类，但定义外部类极少使用无控制符的方式，要么定义为内部类，功能内聚，要么定义为公开类，即 public class，包外可以实例化
    - private: 只修饰属性、方法、内部类。表示“私有的”，是访问限制最严格的一级，被其修饰的属性或方法只能在该类内部访问，子类、包内均不能访问，更不允许跨包访问
  - 访问权限控制符的使用
    - 如果不允许外部直接通过 new 创建对象，构造方法必须是 private
    - 工具类不允许有 public 或 default 构造方法
    - 类非 static 成员变量并且与子类共享，必须是 protected
    - 类非 static 成员变量并且仅在本类使用，必须是 private
    - 类 static 成员变量如果仅在本类使用，必须是 private
    - 若是 static 成员变量，必须考虑是否为 final
    - 类成员方法只供类内部调用，必须是 private
    - 类成员方法只对继承类公开，那么限制为 protected
- this和super
  - this 和 super 在很多情况下是可以省略的
    - 本类方法调用本类属性
    - 本类方法调用另一个本类方法
    - 子类构造器隐含调用 super()
  - 任何类在创建之初，都有一个默认的空构造方法，它是 super() 的一条默认通路，构造方法的参数列表决定了调用通路的选择；如果子类指定调用父类的某个构造方法，super 就会不断往上溯源；如果没有指定则默认使用 super()。如果父类没有提供默认的构造方法，子类在继承时就会编译错误。如果父类坚持不提供默认的无参构造器，必须在本类的无参构造方法中使用 super() 方法调用父类的有参构造方法，如 public Son(){super(123);}
  - 一个示例变量可以通过 this. 赋值另一个实例变量；另一个实例方法可以通过 this. 调用另一个实例方法；甚至一个构造方法都可以通过 this. 调用另一个构造方法。如果 this 和 super 指代构造方法，则必须位于方法体的第一行。换句话说，在一个构造方法中，this 和 super 只能出现一个，且只能出现一次，否则在实例化对象时，会因子类调用到多个父类构造方法而造成混乱
  - 由于 this 与 super 都在实例化阶段调用，所以不能在静态方法和静态代码块中使用 this 和 super 关键字。this 还可以指代当前对象，比如在同步代码块 synchronized(this){…} 中，super 并不具备此能力，但 super 也有自己的特异功能，在子类覆盖父类方法时，可以使用 super 调用父类同名的实例方法
- 类关系
  - 类与类之间的关系可以包含如下 5 种类型
    - 继承（extends is-a）
    - 实现（implements can-do）
    - 组合（类是成员变量 contains-a）：类关系种的组合是一种完全绑定的关系，所有成员共同完成一件使命，它们的生命周期是一样的。组合体现的是非常强的整体与部分的关系，同生同死，部分不能再整体之间共享
    - 聚合（类是成员变量 has-a）：聚合是一种可以拆分的整体与部分的关系，是非常松散的暂时组合，部分可以被拆分出来的另一个整体
    - 依赖（import类 use-a）：除组合和聚合外的类与类之间的关系，这个类只要 import，那就是依赖关系
- 序列化
  - 序列化概念
    - 内存中的数据对象只有转换为二进制流才可以进行数据持久化和网络传输。将数据对象转换为二进制流的过程称为对象的序列化（Serialization）。反之，将二进制流恢复为数据对象的过程称为反序列化（Seserialization）。序列化需要保留充分的信息以恢复数据对象，但是为了节约存储空间和网络带宽，序列化后的二进制流又要尽可能小。序列化常见的场景是 RPC 框架的数据传输
  - 序列化分类
    - Java 原生序列化
      - Java 类通过实现 Serializable 接口来实现该类对象的序列化，这个接口非常特殊，没有任何方法，只起标识作用。Java 序列化保留了对象类的元数据（如类、成员变量、继承类信息等），以及对象数据等，兼容性最好，但不支持跨语言，而且性能一般。实现 Serializable 接口的类建议设置 serialVersionUID 字段值，如果不设置，那么每次运行时。编译器会根据类的内部实现，包括类名、接口名、方法和属性等来自动生成 serialVersionUID。如果类的源代码有修改，那么重新编译后 serialVersionUID 的取值可能会发生变化，因此实现 Serialzable 接口的类一定要显式的定义 serialVersionUID 属性值。修改类时需要根据兼容性决定是否修改 serialVersionUID值：
        
        如果是兼容升级，请不要修改 serialVersionUID 字段，避免反序列失败
        
        如果是不兼容升级，需要修改 serialVersionUID 值，避免反序列化混乱
      - 使用 Java 原生序列化需注意，Java 反序列化不会调用类的无参构造器，而是调用 native 方法将成员变量赋值为对应类型的初始值。基于性能考虑，不推荐使用 Java 原生序列化
    - Hession 序列化
      - Hessian序列化是一种支持动态类型、跨语言、基于对象的传输的网络协议。Java 对象序列化的二进制流可以被其他语言（如c++、Python）反序列化。Hession 协议具有如下特性:
        
        自描述序列化类型。不依赖外部描述文件或接口定义，用一个字节表示常用基础类型，极大缩短二进制流
        
        语言无关，支持脚本语言
        
        协议简单，比 Java 原生序列化高效
      - 相比 Hessian 1.0，Hessian 2.0 中增加了压缩编码，其序列化二进制流大小是 Java 序列化的 50%，序列化耗时是 Java 序列化的 30%，反序列化耗时是 Java 反序列化的 20%
      - Hessian 会把复杂对象的所有属性存储在一个 Map 中进行序列化，所以在父类、子类存在同名成员变量的情况下，Hessian 序列化时，先序列化子类，然后序列化父类，因此反序列化结果会导致子类同名成员变量被父类的值覆盖
    - JSON 序列化
      - JSON 是一种轻量级的数据交换格式。JSON 序列化就是将数据对象转换为 JSON 字符串。在序列化过程中抛弃了类型信息，所以反序列化时只有提供类型信息才能准确地反序列化
  - 序列化过程中的注意点
    - 总会有一些数据称为黑客的攻击点，所以有些对象的敏感属性不需要进行序列化传输，可以加 transient 字段，避免把此属性信息转化为序列化的二进制流。如果一定要传递对象的敏感属性，可以使用对称与非对称加密方式独立传输，再使用某个方法把属性还原到对象中
- 方法
  - 方法签名
    - 方法签名包括方法名称和参数列表，是 JVM 标识方法的唯一索引，不包括返回值，更不包括访问权限控制符、异常类型等。假如返回值可以是方法签名的一部分，仅从代码可读性角度来考虑，如下实例中，类型推断的 var 到底接受到的是 1.0d 还是 1L?从静态阅读的角度，根本无从知道它调用的是哪个方法
```
    long f(){
        return 1L;
    }

    double f(){
        return 1.0d;
    }

    var a = f();
```
  - 参数
    - 参数又叫 parameter，在代码注释中用 @param 表示参数类型。参数在方法中，属于方法签名的一部分，包括参数类型和参数个数，多个参数用逗号相隔，在代码风格中，约定每个逗号都必须要有一个空格，不管是形参，还是实参。形参是在方法定义阶段，而实参是在方法调用阶段，先来看看实参传递给形参的过程：
```
    public class ParamPassing{
        private static int intStatic = 222;
        private static String stringStatic = "old stirng";
        private static StringBuilder stringBuilderStatic = new StringBuilder("old stringBuilder");

        public static void main(String[] args){
            // 实参调用
            method(intStatic);
            method(stringStatic);
            method(stringBuilderStatic, stringBuilderStatic);

            // 输出依然是222（第一处）
            System.out.println(intStatic);
            method();

            // 无参方法调用之后，反而修改为888（第二处）
            System.out.println(intStatic);
            // 输出依然是:old string
            System.out.println(stringStatic);
            // 输出结果参考下方分析
            System.out.println(stringBuilderStatic);
        }

        // A方法
        public static void method(int intStatic){
            intStatic = 777;
        }

        // B 方法
        public static void method(){
            intStatic = 888;
        }

        // C 方法
        public static void method(String stringStatic){
            // String 是immutable 对象，String没有提供任何方法用于修改对象
            stringStatic = "new string";
        }

        // D 方法
        public static void method(StringBuilder stringBuilderStatic1, StringBuiler stringBuilderStatic2){
            // 直接使用参数引用修改对象（第三处）
            stringBuilderStatic1.append(".method.First-");
            stringBuilderStatic2.append("method.second-");

            // 引用重新赋值
            stringBuilderStatic1 = new StringBuilder("new stringBuilder");
            stringBuilderStatic1.append("new methods`s append");
        }
    }
```
      - 解析
        
        第一二处：有参的 A 方法字节码如图所示，参数是局部变量，拷贝静态变量的 777，并存入虚拟机中的局部变量表的第一个小格子内。虽然在方法内部的 intStatic 与静态变量同名，但是因为作用域就近原则，它是局部变量的参数，所有的操作与静态变量是无关的。而无参的 B 方法字节码先把本地赋值的 888 压入虚拟机栈的操作栈中，然后给静态变量 intStatic 赋值
        // 第一处 1. SIPUSH 777 2. ISTORE 0 3. RETURN // 第二处 1. SIPUSH 888 2. PUTSTATIC ParamPassing.intStatic: 3. RETURN
        
        第三处：注意上述字节码中的两个 ALOAD 0，是把静态变量的引用赋值给虚拟机栈的栈帧中的局部变量表，然后 ALOAD 操作是把两个对象引用变量压入操作栈的栈顶，注意，这两个引用都指向了静态引用变量执行的 new StringBuilder(“old stringBuilder”) 对象在 method(stringBuilderStatic, stringBuilderStatic) 的执行结果后的值，其中红绿字符串分别是两次 append 的结果：old stringBuilder.method.first-method.second-。在 D 方法中，new 出来一个新的 StringBuilder 对象，赋值为 stringBuilderStatic1。注意，这是一个新的局部引用变量，使用 ASTORE 命令对局部变量表的第一个位置的引用变量值进行了覆盖，然后再重新进行 ALOAD 到操作栈顶，所以后续对于 stringBuilderStatic1 的 append 操作，与类的静态引用变量 stringBuilderStatic 没有任何关系
        public static method(Ljava/lang/StringBuilder;Ljava/lang/StringBuilder;)v L0 ALOAD 0 LDC ".method.first" INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;) Ljava/lang/StringBuilder; POP L1 ALOAD 1 LDC "method.second" INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;) Ljava/lang/StringBuilder; POP L2 NEW java/lang/StringBUilder DUP LDC "new stringBuilder" INVOKESPECIAL java/lang/StringBuilder.<init> (Ljava/lang/String;) V ASTORE 0 L3 ALOAD 0 LDC "new method's append" INVOKEVIRTUAL java/lang/StringBuilder.append (Ljava/lang/String;) Ljava/lang/StringBUilder; POP RETURN
        
        所以，无论是对基本数据类型，还是引用变量，Java 中的参数传递都是值复制的过程，对于引用变量，复制指向对象的首地址，双方都可以通过自己的引用变量修改指向对象的相关属性
    - 可变参数
      - 可变参数是在 jdk5 版本中引入的，主要为了解决当时反射机制和 printf 方法问题，适用于不确定参数个数的场景。可变参数通过"参数参数类型…"的方式定义
    - 参数预处理
      - 入参保护
        
        入参保护本质上是对服务提供方的保护，常见于批量接口，如批量修改个数较多导致服务器宕机等
      - 参数校验
        
        基于防御式变成理念，在方法内，无论是对方法调用方传入参数的理性不信任还是对参数有效值的校验都是有必要的
        
        需要进行参数校验的场景
        
        调用频度低的方法
        
        执行时间开销很大的接口
        
        需要极高稳定性和可用性的接口
        
        对外提供的开放接口
        
        敏感权限入口
        
        不需要进行参数校验的场景
        
        极有可能被循环调用的方法。（需要在方法里注明外部参数校验）
        
        底层调用频度高的方法
        
        声明成 private 只会被自己代码调用的方法
  - 构造方法
    - 介绍
      - 构造方法（Constructor）是方法名与类名相同的特殊方法，在新建对象时调用，可以通过不同的构造方法实现不同方式的对象初始化
    - 特征
      - 构造方法名称必须与类名相同
      - 构造方法是没有返回类型的，即使是 void 也不能有。他返回对象的地址，并赋值给引用变量
      - 构造方法不能被继承，不能被覆写，不能被直接调用。调用的途径有三种：一是通过 new 关键字；二是在子类的构造方法中通过 super 调用父类的构造方法；三是通过反射的方式获取并使用
      - 类定义时提供了默认的无参构造器方法。但是如果显式定义了有参构造器方法，则此无参构造方法就会被覆盖，如果依然想要拥有，就需要显式定义
      - 构造方法可以私有。外部无法使用私有构造方法创建对象
    - 使用
      - 接口中不能定义构造方法，在抽象类中可以定义
      - 枚举类中，可以定义构造方法，但不能加 public 修饰，默认是 private。是绝对的单例，不允许外部以创建对象的方式生成枚举对象
      - 一个类可以有多个参数不同的构造方法，称为构造方法的重载
      - 构造方法的使命就是在构造对象时进行传参操作，所以不应该在构造方法中引入业务逻辑。单一职责对构造方法是适用的。如果一个对象在生产中，需要完成初始化上下游对象、分配内存、执行静态方法、赋值句柄等繁重的工作，其中某个步骤出错，导致没有完成对象初始化，再寄希望与业务逻辑部分来处理异常就是不受控制的事情了，所以推荐将初始化业务逻辑方法某个方法中，例如 init()，当对象确认完成所有初始化工作之后再显式调用
    - 示例
```
    class Son extends Parent {
        static { System.out.println("Son 静态代码块"); }
        Son() { System.out.println("Son 构造方法"); }

        public static void main(String[] args) {
            new Son();
            new Son();
        }
    }

    class Parent {
        static { System.out.println("Parent 静态代码"); }
        public Parent() { System.out.println("Parent 构造方法");}
    }

    // 输出
    // Parent 静态代码块
    // Son 静态代码块
    // Parent 构造方法
    // Son 构造方法
    // Parent 构造方法
    // Son 构造方法
```
  - 类内方法
    - 介绍
      - 在面向过程的语言中，几乎所有方法都是全局静态方法，在引入面向对象理念后，某些方法才归属于具体对象，即类内方法。构造方法无论是有形、无形、私有、公有，在一个类中必然是存在的。除构造方法外，类中还有三类方法：实例方法、静态方法、静态代码块
      - 实例方法：又称为非静态方法。实例方法比较简单，它必须依附于某个实际对象，并可以通过引用变量调用其方法。类内部各个实例方法之间可以相互调用，也可以直接读写类内变量，但是不包含 this。当 .class 字节码文件加载之后，实例方法并不会被分配方法入口地址，只有在对象创建之后才会被分配。实例方法可以调用静态变量和静态方法，当从外部创建对象后，应尽量使用"类名.静态方法"来调用，而不是对象名，一来为编译器减负，二来提升代码可读性
      - 静态方法：又称类方法，当类加载后，即分配了响应的内存空间。通常静态方法都是用于定义工具类的方法的，静态方法如果使用了可修改的对象，那么在并发时会存在线程安全问题。需要注意的是：一静态方法中不能使用实例成员变量和实例方法；二静态方法不能使用 super 和 this 关键字，这两个关键字指代的都是需要被创建出来的对象。
      - 静态代码块：在代码的执行方法体中，非静态代码块和静态代码块比较特殊。非静态代码块又称为局部代码块，实际不推荐的处理方式。而静态代码块在类加载的时候就被调用且只调用一次。静态代码块是先于构造方法执行的特殊代码块。今天太代码块不能存在于任何方法体内，包括类静态方法和属性变量
        public class StaticCode { // prior 必须定义在last 前边，否则编译出错：illegal forword reference static String prior = "done"; // 以此调用 f() 的结果，三目运算符为 true，执行 g()，最后赋值成功 static String last = f() ? g():prior; public static boolean f(){ return true; } public static String g(){ return "hello world"; } static { // 静态代码块可以访问静态变量和静态方法 System.out.println(last); g(); } }
  - getter与setter
    - 介绍
      - 在实例方法中有一类特殊的方法，即 getter 与 setter 方法，它们一般不包含任何业务逻辑，仅仅是类成员属性提供读取和修改的方法
    - 优势
      - 满足面向对象语言封装的特性。尽可能将类中的属性定义为 private，针对属性的访问和修改需要使用相应的 getter 与 setter 方法，而不是直接对 public 的属性进行读取和修改
      - 有利于统一控制。在反射中尤为明显
    - POJO 类
      - 常见的 POJO 类包括 DO(Domain Object)、BO(Business Object)、DTO(Data Transfer Object)、VO(View Object)、AO(Application OBject)
      - POJO 作为数据载体，通常用于数据传输，不应该包含任何业务逻辑
  - 同步与异步
    *
  - 覆写
    - 介绍
      - 多态中的 override。如果父类定义的方法达不到子类的期望，那么子类可以重新实现方法覆盖父类的实现。因为有些子类是延迟加载的，甚至是网络加载的，所以最终的实现需要在运行期判断，这就是所谓的动态绑定。动态绑定是多态性得以实现的重要因素，元空间有一个方法表保存着每个可以实例化类的方法信息，可以通过方法表快速地激活实例方法。如果某个类覆写了父类的某个方法，则 JVM 方法表中的方法指向引用会指向子类的实现处。代码通常是用这样的方式来调用子类的方法，通常这也被称作向上转型
    - 条件
      - 访问权限不能变小
      - 返回类型能够向上转型称为父类的返回类型
      - 异常也要能向上转型成为父类的异常
      - 方法名、参数类型及个数必须严格一致
- 重载
  - 介绍
    - 在同一个类中，如果多个方法有相同的名字、不同的参数，即成为重载。在编译器的眼里，方法名称 + 参数类型 + 参数个数组成一个唯一键，称为方法签名，JVM 通过这个唯一键决定调用哪个重载的方法。注意，方法返回值并非是这个组合体中的一员，所以使用重载机制时，不能有两个方法名称完全相同，参数类型和个数也相同但是返回类型不同的方法
```
    public class SameMethodSignature {
        public void methodForOverload () {}

        // 编译出错，返回值并不是方法签名的一部分     
        public final int methodForOverload () { return 7; }

        // 编译出错，访问控制符也不是方法签名的一部分
        private void methodForOverload () {}

        // 编译出错，静态标识符也不是方法签名的一部分
        public static void methodForOverload () {}

        // 编译出错，final标识符也不是方法签名的一部分
        private final void methodForOverload () {}

    }
```
  - 重载的优先顺序（从上到下优先级依次降低）
    - 精确匹配
    - 如果是基本数据类型，自动转换成更大表示范围的基本类型
    - 通过自动拆箱与装箱
    - 通过子类向上转型继承路线依次匹��
    - 通过可变参数匹配
  - 注意
    - 下列方式也是可以编译通过的
```
    public void methodForOverload(int paraml, Integer param2) {}
    public void methodForOverload(Integer param3, int param4) {} 
    // 若调用 methodForOverload(13, 14) 会抛异常
```
- 泛型
  - 介绍
    - 泛型的本质是类型参数化，解决不确定具体对象类型的问题
  - 应用
    - 泛型可以定义在类、接口、方法中，编译器通过识别尖括号和尖括号内的字母来解析泛型。在泛型定义时，约定成俗的符号包括：E 代表 Element，用于集合中的元素；T 代表 the Type of object，表示某个类；K 代表 Key、V 代表 Value，用于键值对元素
```
    public class GenericDefinitionDemo<T> {
        static <String, T, Alibaba> String get(String string, Alibaba alibaba){
            return string;
        }

        public static void main(String[] args){
            Integer first = 222;
            Long second = 333L;
            Integer result = get(first,second);
        }
    }
```
      - 尖括号里的每个元素都指代一种未知类型，Sting 并不是 java.lang.String，而仅仅是一个代号。类名后定义的泛型和 get() 前定义的是两个指代，完全不同，互不影响
      - 尖括号的位置非常讲究，必须在类名之后或方法返回值之前
      - 泛型在定义处只具备执行 Object() 方法的能力。因此想在 get() 内部执行 string.longValue()+aliaba.intValue() 是做不到的，此时泛型只能调用 Object 类中的方法，如 toString()
      - 对于编译之后的字节码指令，其实没有这些方法签名，充分说明反省只是一种编写代码时的语法检查。在使用泛型元素时，会执行强制类型转换
        INVOKESTATIC com/alibaba/easy/coding/generic/GenericDefinitionDemo.get (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; CHECKCAST java/lang/Integer
      - 类型擦除
        
        CHECKCAST 指令在运行时会检查对象实例的类型是否匹配，如果不匹配，则抛出运行时异常 ClassCastException。与 C＋＋根据模板类生成不同的类的方式不同，Java 使用的是类型擦除的方式。编译后 get() 的参数是两个 Object 返回值也是 Object，尖括号里很多内容消失了，参数中也没有 String 和 Alibaba 两个类型。数据返回给 Integer result 时，进行了类型强制转化。因此，泛型就是在编译期增加了一道检查而己，目的是促使程序员在使用泛型时安全放置和使用数据
  - 优势
    - 类型安全。放置的什么取出的就是什么
    - 提升可读性。从编码阶段就显示地知道泛型集合、泛型方法等处理地对象类型是什么
    - 代码重用。泛型合并了同类型的处理代码，使代码重用度变高
- 数据类型
  - 基本数据类型
    - 基本数据类型是指不可再分的原子数据类型，内存中直接存储此类型的值，通过内存地址即可直接访问到数据，并且此内存区域只能存放这种类型的值。它们不具备对象的特征，没有属性和行为。Java 的 9 中基本数据类型包括 boolean、byte、char、short、int、long、float、double和refvar。前八中数据类型表示生活中的真假、字符、整数和小数，最后一种 refvar 是面向对象世界中的引用变量，也叫引用句柄
    - 默认值
      - 虽然默认值都与 0 有关，但是它们之间是存在区别的。比如，boolean 的默认值以 0 表示 false，JVM 并没有针对 Boolean 数据类型进行赋值的专用字节码指令，boolean flag = false 就是用 ICONST_0，即常数 0 来进行赋值；byte 的默认值以一个字节的 0 表示，在默认值的表示上使用了了强制类型转化， float 的默认值以单精度浮点数 0.0f 表示，浮点的 0.0 使用后缀 f 和 d 区别标识；char 的默认值只能是单引号的’＼u0000’ 表示 NUL，注意不是 null，它就是一个空的不可见字符，在码表中是第一个，其码值 0 ，与 ‘\n’ 换行之类的不可见控制符的理解角度是一样的。注意，不可以用双引号方式对 char 进行赋值，那是字符串的表示方式。在代码中直接出现的没有任何上下文的 0 和 0.0 分别默认为 int 和 double 类型，可以使用 JDK10 的类型推断证明 var a=0; Long b=a：代码编译出错，因为在自动装箱时，默认是 int 类型，自动装箱为 Integer，无法转化为 Long 类型
    - 符号
      - 所有数值类型都是有符号的，因为浮点数无法表示零值，所以表示范围分为两个区间：正数区间和负数区间，float 和 double 的最小值与最大值均指正数区间，它们对应的包装类并没有缓存任何数值
  - 引用数据类型
    - 引用数据类型分为引用变量本身和引用指向的对象。本书把引用变量称为 refvar，而把引用指向的实际对象简称为 refobj
    - refvar是基本的数据类型，它的默认值是 null，存储 refobj 的首地址，可以直接使用双等号 == 进行等值判断，而平时使用的 refvar.hashCode() 返回的值，只是对象的某种哈希计算，可能与地址有关，与 refvar 本身存储的内存单元地址是两回事。作为一个引用变量，不管它是指向包装类、集合类、字符串类还是自定义类，refvar 均占用 4B 空间，对于 refobj 来说，无论多么小的对象，最小占用的存储空间是 12B(用于存储基本信息，称为对象头)，但由于存储空间分配必须是 8B 的倍数，所以初始分配的空间至少是 16B。一个 refvar 之多存储一个 refobj 的首地址，一个 refobj 可以被多个 refvar 存储下它的首地址，即一个堆内对象可以被多个 refvar 引用指向。如果 refobj 没有被任何 refvar 指向，那么它迟早会被垃圾回收，而 refvar 的内存释放，与其他基本数据类型。由于 refobj 对象的基础大小是 12B，再加上 int 是 4B，所以 Integer 实例对象占用 16B，按此推算 Double 对象占用的存储容量是 24B
    - 对象结构
      - 对象头（Object Header）
        
        对象头占用 12 个字节，存储内容包括对象标记（markOop）和类元信息(klassOop)。对象标记存储对象本身运行时的数据，如哈希码、GC标识、锁信息、线程关联信息等，这部分数据在 64 位 JVM 上占用 8 个字节，称为 “Mark Word”。为了存储更多的状态信息，对象标记的存储是非固定的（与JVM实现有关），类元信息存储的是对象指向它的类元数据（即Klass）的首地址，占用 4 个字节，与 refvar 一样
      - 实例数据（Instance Data）
        
        存储本类对象的实例成员变量和所有可见的父类成员变量，如 Integer 的实例成员只有一个 private int value，占用 4 个字节，所以加上对象头为 16 个字节；再如，上述示例代码的 RefObjDemo 对象大小为 48 个字节，一个子类 RefObjSon 继承 RefObjDemo，即使子类内部是空的，new RefObjSon 的对象也占用 48 个字节
      - 对齐填充（Padding）
        
        对象的存储空间分配单元是 8 个字节，如果一个占用大小为 16 个字节的对象，增加一个成员变量 byte 类型，此时需要占用 17 个字节，但是也会分配 24 个字节进行对齐填充操作
  - 包装类型
    - 推荐所有包装类对象之间值的比较，全部使用 equals() 方法
    - 只有 Integer 可以修改缓存范围，-XX:AutoBoxCacheMax=xxx
    - 推荐
      - 所有的 POJO 类型属性必须使用包装数据类型
      - RPC 方法的返回值和参数必须使用包装数据类型
      - 所有局部变量推荐使用基本数据类
  - 字符串
    - 介绍
      - 字符串相关类型主要有三种，String、StringBuilder、StringBuffer
      - String 是只读字符串，典型的 immutable 对象，对它的任何改代，其实都是创建一个新对象，再引用指向该对象。String 对象赋值操作后，会在常量池中进行缓存，如果下次再申请创建对象时，缓存中已经存在，则直接返回响应引用给创建者
      - StringBuffer 可以在原对象上进行修改，是线程安全的。JDK5 引入的 StringBuilder 与 StringBuffer 均继承自 AbstractStringBuilder，两个子类的很多方法都是通过"super.方法()"的方式调用抽象父类中的方法，此抽象类在内部与 String 一样，也是以字符数组的形式存储字符串的
      - StringBuilder 是非线程安全的，但效率高于 StringBuffer
    - 使用
      - 在非基本数据类在对象中，String 是仅支持直接相加操作的对象，但在循环体内，字符串的连接方式应该是 StringBuilder 的 append 方法进行扩展

第三章代码风格

命名规约
- 命名约定
  - 命名符合本语言特性
  - 命名体现代码元素特征
  - 命名最好望文知义
- 常量
  - 常量是在作用域内保持不变的值，一般用 final 关键字进行修饰，根据作用域区分，分为全局常量、类内常量、局部常量。全局常量是指类的公开静态属性，使用 public static final 修饰；类内常量是私有静态属性，使用 private static final 修饰；局部常量分为方法常量和参数常量，前者是在方法或代码块内定义的常量，后者是在定义形式参数时，增加 final 标识，表示此参数不能被修改。全局常量和类内常量时最主要的常量表现形式，他们的命名方式比较特殊，采用字母全部大写、单词之间加下划线的方式。而局部常量采用小驼峰形式即可
- 变量
  - 变量是在程序中一切通过分配内存并赋值的量，分为不可变量（常量）和可变变量。狭义来说，变量仅指在程序运行过程中可以改变其值的量，包括成员变量和局部可变变量等
  - 一般情况下，变量的命名需要满足小驼峰格式，命名体现业务含义即可。存在一种特殊情况，在定义类成员变量时，特别是在 POJO 类中，针对布尔类型的变量，命名不要加 is 前缀，否则部分框架解析会引起序列化错误
- 代码展示风格
  - 缩进
    - 推荐使用 4 个空格缩进，禁止使用 Tab 键（不同编辑器对 Tab 解析不一致，空格在编辑器之间是兼容的）
  - 空格
    - 任何二目、三目运算符的左右两边都必须加一个空格
    - 注释的双斜线与注释内容之间有且仅有一个空格
    - 方法参数在定义和传入时，多个参数逗号后边必须加空格
    - 没有必要增加若干空格使变量的赋值等号与上一行对应位置的等号对齐
    - 如果是大括号内为空，则简洁地写成 {} 即可，大括号中间无须换行和空格
    - 左右小括号与括号内部的相邻字符之间不要出现括号
    - 左括号前需要加空格
  - 空行
    - 在方法定义之后
    - 属性定义与方法之间
    - 不同逻辑
    - 不同语义
    - 不同业务的代码
- 换行与高度
  - 换行：约定单行字符数不超过 120 个，超出需要换行
    - 第二行相对第一行缩进 4 个空格。从第三行开始，不再继续缩进
    - 运算符与下文一起换行
    - 方法调用中的多个参数需要换行时，在逗号后换行
    - 在括号前不要换行
  - 方法行数限制
    - 约定单个方法的总行数不超过 80 行
- 控制语句
  - 在 if、else、for、while、do-while 等语句中必须使用大括号
  - 在条件表达式中不允许有赋值操作，也不允许在判断表达式中出现复杂的逻辑组合
  - 多层嵌套不得超过 3 层
  - 避免采用去反逻辑运算符
代码注释
- 注释三要素
  - Nothing is strange
  - Less is more
  - Advance with the times
- 注释格式
  - Javadoc 规范
    - 枚举必须使用注释
  - 简单注释
    - 单行注释
    - 多行注释

第四章走进 JVM

字节码
- 介绍
  - 在不同的时代，不同的厂商，机器指令组成的集合是不同的。但毕竟 CPU 是底层基础硬件，指令集通常以扩展兼容的方式向前不断演进。而机器码是离 CPU 指令集最近的编码，是 CPU 可以直接解读的指令，因此机器码肯定是与底层硬件系统耦合的。那 JAVA 是如何实现跨平台的？计算机工程领域的任何问题都可以通过增加一个中间层来解决，于是字节码(Bytecode)应运而生。Java 所有的指令有 200 个左右，一个字节（8位）可以存 256 种不同的指令信息，这样的字节称为字节码（Bytecode）
  - 在代码的执行过程中，JVM 将字节码解释执行，屏蔽对底层操作系统的依赖；JVM 也可以将字节码编译执行，如果是热点代码，会通过 JIT 动态地编译为机器码，提高执行效率
- 字节码指令
  - 如图所示，十六进制表示的二进制流通常是一个操作指令。起始的 4 个字节非常特殊，即绿色框的 cafe babe 是 Gosling 定义的一个魔法书，意思为 Coffee Baby，其十进制值为 3405691582。它的作用是：标志该文件是一个 Java 类文件，如果没有识别到该标志，说明该文件不是 Java 类文件或者文件已受损，无法进行加载。而红色框代表当前版本号，0X37 的十进制为 55，是 JDK11 的内部版本号
  - 由于字节码的纯数字比较难记，JVM 在字节码上设计了一整套操作码住记符，常见的字节码主要指令为：
    - 加载或存储指令：在某个栈帧中，通过指令操作数据在虚拟机栈的局部变量表和操作栈之间来回传输
      - 将局部变量加载到操作栈中
        
        ILOAD：将 int 类型的局部变量压入栈
        
        ALOAD：将对象引用的局部变量压入栈
      - 从操作栈顶存储到局部变量表
        
        ISTORE
        
        ASTORE
      - 将厂里加载到操作栈顶，这是极为高频使用的指令
        
        ICONST：加载的是 -1~5 的数（ICONST与BIPUSH的加载界限）
        
        BIPUSH：即 Byte Immediate PUSH，加载 -128~127 之间的数
        
        SOPUSH：即 Short Immediate PUSH，加载 -32768~32767 之间的数
        
        LDC：即 Load COnstant，在 -2147483648~2147483647 或者是字符串时，JVM 采用 LDC 指令压入栈中
    - 运算指令：对两个操作栈帧上的值进行运算，并把结果写入操作栈顶
      - IADD
      - IMUL
    - 类型转换指令：显式转换两种不同的数值类型
      - I2L
      - D2F
    - 对象创建与访问指令：根据类进行对象的创建、初始化、方法调用相关指令
      - 创建对象指令
        
        NEW
        
        NEWARRAY
      - 访问属性指令
        
        GETFIELD
        
        PUTFIELD
        
        GETSTATIC
      - 检查实例类型指令
        
        INSTANCEOF
        
        CHECKCAST
    - 操作栈管理指令：直接控制操作栈的指令
      - 出栈操作
        
        POP：一个元素出栈
        
        POP2：两个元素出栈
      - 复制栈顶元素并压入栈
        
        DUP
    - 方法调用与返回指令
      - INVOKEVIRTUAL：调用对象的实例方法
      - INVOKESPECIAL: 调用实例初始化方法、私有方法、父类方法等
      - INVOKESTATIC：调用类静态方法
      - RETURN：返回 VOID 类型
    - 同步指令
      - JVM 使用方法结构中的 ACC_SYNCHRONIZED 表示同步方法，指令集中有 MONTORENTEDR 和 MONITOEREXIT 支持 synchronized 语义
  - 除字节码之另外，还包含了一些额外信息。例如，LINENUMBER 存储了字节码与源码行号的对应关系，方便调试的时候正确地定位到代码地所在行；LOCALVARIABLE 存储当前方法中使用到地局部变量表
- 编译
  - 词法解析时通过空格分析出单词、操作符、控制符等信息，将其形成 token 信息流，传递给语法解析器
  - 语法解析器时，把词法解析得到的 token 信息流按照 Java 语法规则组装成一颗语法树
  - 在语义分析阶段，需要检查关键字的使用是否合理、类型是否匹配、作用域是否正确等
  - 语义分析完成后，生成字节码
- 加载
  - 字节码必须通过类加载过程加载到 JVM 环境后才可以执行。执行有三种模式：第一，解释执行；第二，JIT 编译执行；第三，JIT 编译与解释混合执行（主流JVM默认执行模式）
  - 混合执行模式的优势在于解释器在启动时先解释执行，省去编译时间。随着时间推进，JVM 通过热点代码统计分析，识别高频的方法调用、循环体、公共模块等，基于强大的 JIT 动态编译技术，将热点代码转化为机器码，直接交给 CPU 执行。JIT 的作用是将 Java 字节码动态地编译成可以直接发送给处理器指令执行的机器码
  - 注意解释执行与编译执行在线上环境微妙的辩证关系，机器在热机状态可以承受的负载要大于冷机状态（刚启动时），如果以热机状态时的流量进行切流，可能使处于冷机状态的服务器因无法承受流量而假死，在生产环境发布中，以分批的方式进行发布，根据机器数量划分成多个批次，每个批次的机器数之多占到整个集群的 1/8

类加载

介绍

在冯·诺伊曼定义的计算机模型中，任何程序都需要加载到内存才能与 CPU 进行交流，字节码.class 文件需要加载到内存中在可以实例化类。而 ClassLoader 就是提前加载 .class 类文件到内存中，在加载类时，使用的是 Parents Delegation Model，译为双亲委派模式，意译的话叫做"溯源委派加载模型"更为贴切
Java 的类加载器是一个运行时核心基础模块，主要在启动之初进行类的 Load、Link 和 Init，即加载、链接、初始化
- Load阶段：读取类文件产生二进制流，并转化为特定的数据结构，初步校验 cafe babe 魔法数、常量池、文件长度、是否有父类等，然后创建对应类的 java.lang.Class 实例
- Link阶段：Linkd 阶段包含验证、准备、解析三个阶段。验证时更详细的校验，比如 final 是否合规、类型是否正确、静态变量是否合理等；准备阶段是为静态变量分配默认内存，并设计默认值，解析类和方法确保类与类之间的相互引用正确性，完成内存结构布局
- Init阶段：执行类构造器方法，如果赋值运算是通过其他类的静态方法来完成的，则马上解析另外一个类，在虚拟机栈中执行完毕后通过返回值进行赋值
类加载是一个将 .class 字节码文件实例化成 Class 对象并进行相关初始化的过程。在这个过程中，JVM 会初始化继承树上还没被初始化过的所有父类，并且会执行这个链路上所有未执行过的静态代码块、静态变量赋值语句等。某些类在使用时，也可以按需由类加载器进行加载

全小写的 class 是关键字，用来定义类，而首字母大写的 Class，它是所有 class 的类

    public class ClassTest {
        // 数组类型有一个魔法属性：length来获取数组长度
        private static int[] array = new int[3];
        private static int length = array.length;

        // 任何小写class定义的类，也有一个魔法属性：class，来获取此类的大写 Class 类对象
        private static Class<One> one = One.class;
        private static Class<Another> another = Another.class;

        public static void main(String[] args) throws Exception{ 
            // 通过newInstance方法创建One 和Another的类对象（第一处）
            One oneObject = one.newInstance();
            oneObject.call();

            Another anotherObject = another.newInstance();
            anotherObject.speak();

            // 通过one这个大写的Class对象，获取私有成员属性对象Field（第二处）
            Field privateFieldInOne = one.getDeclaredField("inner");

            // 设置私有对象可以访问和修改（第三处）
            privateFiledInOne.setAccessible(true);

            privateFiledInOne.set(oneObject, "world changed.");
            // 成功修改类的私有属性inner变量值未word changed。
            System.out.println(oneObject.getInner());
        }

    }

    class one{
        private String inner = "time flier.";

        public void call(){
            System.out.println("hello world.");
        }

        public String getInner(){
            return inner;
        }
    }

    class Annother{
        public void speak(){
            System.out.println("easy coding.");
        }
    }

    // 输出
    // hello world.
    // easy coding.
    // world changed.

类加载器分类
- 类加载器中最高一层的是 Bootstrap，它是在 JVM 启动时创建的，通常由与操作系统相关的本地代码实现，是最根据的类加载器，负责装载最核心的 Java 类，比如 Object、System、String等；第二层是在 JDK9 版本中，称为 Platform ClassLoader，即平台类加载器，用以加载一些扩展的系统类，比如 XML、加密、压缩相关的功能类等，JDK9 之前的加载器是 Extension ClassLoader；第三层是 Appliation ClassLoader 的应用类加载器，主要是加载用户定义的 CLASSPATH 路径下的类。第二、三类加载器为 Java 语言实现，用户也可以自定义类加载器
```
    ClassLoader c = TestWhoLoad.class.getClassLoader();
    ClassLoader c1 = c.getParent();
    // 由于bootstrap 是通过 C/C++ 实现的，并不存在于 JVM 体系内，所以输出为 null
    ClassLoader c2 = c1.getParent();

    // 输出 jdk8
    // sun.misc.Launcher\$AppClassLoader@14dad5dc
    // sun.misc.launcher\$ExtClassLoader@6e0be858
    // null
```
- 低层次的当前类加载器不能覆盖更高层次类加载器已经加载的类。如果低层次的类加载器想加载一个未知类，会一次往上询问是否存在，只有父类都不存在时才可以加载
- 通过如下代码可以查看 BootStrap 所有已经加载的类库
```
    URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();
    for(java.net.URL url : urls){
        System.out.println(url.toExternalForm());
    }
```
  - Boostrap 加载的路径可以追加，不建议修改或删除原来加载路径。在 JVM 中增加如下参数，则能通过 Class.forName 正常读取到指定类，说明此参数可以增加 Boostrap 的类加载路径
```
    -Xbootclasspath/a:/Users/yangguangbao/book/easyCoding/byJdk11/src
```
- 如果想在启动时观察加载了哪个 jar 包中的哪个类，可以增加 -XX:+TraceClassLoading 参数，此参数在解决类冲突时非常实用
需要自定义类加载器的地方
- 隔离加载类：例如某些中间件以应用的模块隔离，把类加载到不同的环境
- 修改类加载方式：指定某些类在某个时间点进行按需动态加载
- 扩展加载源：从数据库、网络甚至电视机机顶盒加载
- 防止源码泄露：Java代码容易呗编译和篡改，可以进行编译加密。那么类加载器也需要自定义，还原加密的字节码

实现自定义加载器

    public class CustomerClassLoader extends ClassLoader {
        @Override
        protected Class<?> findClass(String name) throws ClassNotFoundException{
            try{
                byte[] result = getClassFormCustomerPath(name);
                if (result == null ) {
                    throw new FileNotFoundException();
                } else {
                    return defineClass(name, result, 0, result.length);
                }
            } catch (Exception e){
                e.printStackTrace();
            }
            throws new ClassNotFoundException(name);
        }

        private byte[] getClassFromCustomerPath(String name){
            // 从自定义路径中加载指定类
        }
    }

    public static void main(String[] args){
        CustomerClassLoader customerClassLoader = new CustomerClassLoader();
        try{
            Class<?> clazz = Class.forName("one", true, customerClassLoader);
            Object obj = clazz.newInstance();
            System.out.println(obj.getClass().getClassLoader());
        } catch(Exception e){
            e.printStackTrace();
        }
    }

    // 输出
    // classloader.CustomerClassLoader@5e481248

内存布局
- 介绍
  - 内存是非常重要的系统资源，是硬盘和 CPU 的中间仓库及桥梁，承载着操作系统和应用程序的实时运行。JVM 内存布局规定了 Java 在运行过程中内存申请、分配、管理的策略，保证了 JVM 的高效稳定运行
- Heap(堆区)
  - Heap 是 OOM 故障最主要的发源地，它存储着几乎所有的实例对象，堆由垃圾收集器自动回收，堆区由各自子线程共享使用。堆内存的空间既可以固定大小，也可以在运行时动态地调整，通过如下参数设定初始值和最大值，比如 -Xms256M -Xmx1024M，其中-x表示它是 JVM 运行参数，ms 是 menmory start 的简称，mx 是 memory max 的简称，分别代表最小堆容量和最大堆容量。但是在通常情况下，服务器在运行过程中，堆空间不断地扩容与回缩，势必造成不必要地系统压力，所以在线上生产环境中， JVM 的 Xms 和 Xms 设置成一样大小，避免在 GC 后调整堆大小时带来的额外压力
  - 堆分成两大块：新生代和老年代。对象产生之初在新生代，步入暮年时进入老年代，但是在老年代也接纳在新生代无法容纳的超大对象。新生代 = 1 个 Eden 区 + 2 个 Survivor 区。绝大部分对象在 Eden 区生成，当当 Eden 区填满的时候，会触发 Young Garbage Collection，即 YGC。垃圾回收的时候，在 Eden 区实现清楚策略，没有被引用的对象则直接回收。依然存活的对象会被移送到 Survivor 区。Survivor 区分为 S0 和 S1 两块内存空间，每次 YGC 的时候，它们将存活的对象复制到未使用的那块空间，然后将当前正在使用的空间完全清楚，交换两块空间的使用状态。如果 YGC 要移送的对象大于 Survivor 区容量的上限，则直接移交给老年代。每个对象都有一个计数器，每次 YGC 都会加 1。-XX:MaxTenuringThreshold 参数能配置计数器的值到达某个阈值的时候，对象从新生代晋升到老年代。该值默认是 15，可以在 Survivor 区交换 14 次后今生老年代
  - 如果 Survivor 区无法放下，或者超大对象的阈值超过上限，则尝试在老年代进行分配，如果老年代也无法放下，则会触发 Full Garbage Collertion，即FGC。如果依然无法放下，则抛出 OOM。堆内存出现 OOM 的概率是所有内存耗尽异常中最高的。出错时的堆内存信息堆解决问题非常有帮助，所以给 JVM 设置运行参数 -XX:+HeapDumpOnOutOfMemoryError，让 JVM 遇到 OOM 异常时能输出堆内信息
- Metaspace(元空间)
  - 本书采用 JDK11 版本，JVM 则为 Hotspot。早在 JDK8 版本中，元空间的前身 Perm 区已经被淘汰。在 JDK7 及之前的版本中，只有 Hotspot 才有 Perm 区，译为永久代，它在启动时固定大小，很难进行调优，并且 FGC 时会移动类元信息，在某些场景下，如果动态加载类过多，容易产生 Perm 区的 OOM(“Exception in thread ‘double client x.x connector’ java.lang.OutOfMemoryError:PermGenapce”)，为了解决该问题，需要设定运行参数 -XX:MaxPermSize=1280m。JDK8 使用元空间替代永久代，在 JDK8 及以上版本中，设定 MaxPermSize 参数，JVM 在启动时并不会报错，但是会提示：Java HotSpot 64Bit Server VM warning:ignoring option MaxPermSize=2560m;support was removed in 8.0
  - 区别于永久代，元空间在本地内存中分配。在 JDK8 里，Perm 区中所有内容字符串常量移至堆内存，其他内容包括类元信息、字段、静态属性、方法、常量等都移动到元空间
- JVM Stack(虚拟机栈)
  - 栈(Stack)是一个先进后出的数据结构，相对于基于寄存器的运行环境来说，JVM 是基于栈结构的运行环境，栈结构移植性更好，可控性更强。JVM 中的虚拟机栈是描述 Java 方法执行的内存区域，它是线程私有的。栈中的元素用于支持虚拟机栈进行方法调用，每个方法从开始调用到执行完成的过程，就是栈帧从入栈到出栈的过程。在活动线程中，只有位于栈顶的栈才是有效的，称为当前栈帧。正在执行的方法称为当前方法，栈帧是方法运行的基本机构，在执行引擎运行时，所有指令都只能针对当前栈帧进行操作。而 StackOverflowError 表示请求的栈溢出，导致内存耗尽，通常出现在递归方法中。JVM 能够横扫千军，虚拟机栈就是它的心腹大将，当前方法的栈帧，都是正在战斗的战场，其中的操作栈是参与战斗的士兵
  - 虚拟机栈通过压栈和出栈的方式，堆每个方法对应的活动栈帧进行运算处理，犯法正常执行结束，肯定会跳转到另一个栈帧上。在执行的过程中，如果出现异常，会进行异常回溯，返回地址通过异常处理表确定，栈帧在整个 JVM 体系中的地位颇高，包括局部变量表、操作栈、动态链接、方法返回地址等
    - 局部变量表
      - 局部变量表是存放方法参数和局部变量的区域。相对于类属性变量的准备阶段和初始化阶段来说，局部变量没有准备阶段，必须显式初始化。如果是非静态方法，则在 index[0] 位置上存储的是方法所属对象的实例引用，随后存储的是参数和局部变量。字节码指令中的 STORE 指令就是将操作栈中计算完成的局部变量写回局部变量表的存储空间内
    - 操作栈
      - 操作栈是一个初始状态为空的桶式结构栈。在方法执行过程中，会有各种指令往栈中写入和提取信息。 JVM 的执行引擎是基于栈的执行引擎，其中的栈指的就是操作栈。字节码指令集的定义都是基于栈类型的，栈的深度在方法元信息的 stack 属性中，下面用一段简单的代码说明操作栈与局部变量表的交互：
        public int simpleMethod(){ int x = 13; int y = 14; int z = x + y; return z; }
      - 字节码操作顺序
        public simpleMethod(); descriptor: ()I flags: ACC_PUBLIC Code: stack=2, loacls=4, args_Size=1 // 最大栈深度为2，局部变量个数为4 BIPUSH 13 // 常量13压入操作栈 ISTORE_1 // 并保存到局部变量表的slot_1中（第一处） BIPUSH 14 // 常量14压入操作栈，注意是BIPUSH ISTORE_2 // 并保存到局部变量表的slot_2中 ILOAD_1 // 把局部变量表的slot_1元素（int x）压入操作栈 ILOAD_2 // 把局部变量表的slot_2元素（int y）压入操作栈 IADD // 把上方的两个数都取出来，在CPU里加一下，并压回操作栈的栈顶 ISTORE_3 // 把栈顶的结果存储到变量表的slot_3中 ILOAD_3 IRETURN // 返回栈顶元素
    - 动态连接
      - 每个栈帧中包含一个在常量池中对当前方法的引用，目的至支持方法调用过程的动态连接
    - 方法返回地址
      - 方法执行时有两种退出情况：第一，正常退出，即正常执行到任何方法的返回字节码指令，如 RETURN、IRETURN、ARETURN等；第二，异常退出。无论何种退出情况，都将返回至方法当前被调用的位置，方法退出的过程相当于弹出当前栈帧，退出有三种可能的方式：（1）返回值压入上层调用栈帧；（2）异常信息抛给能够处理的栈帧；（3）PC 计数器指向方法调用后的下一条指令
    - Native Method Stack（本地方法栈）
      - 本地方法栈在 JVM 内存布局中，也是线程对象私有的，但是虚拟机栈"主内"，而本地方法栈"主外"。这个"内外"是针对 JVM 来说的，本地方法栈为 Native 方法服务。线程开始调用本地方法时，会进入一个不再受 JVM 约束的世界。本地方法可以通过 JNI (Java Native Interface)来访问虚拟机运行时的数据区，甚至可以调用寄存器，具有和 JVM 相同的能力和权限。当大量本地方法出现时，必然削弱 JVM 对系统的控制力，因为它的出错都比较黑盒。对于内存不足的情况，本地方法栈还是会抛出 native heap OutOfMemory。此外最著名的本地方法应该时 System.currentTimeMillis()
    - Program Counter Register(程序计数寄存器)
      - 每个线程在创建后，都会产生自己的程序计数器和栈帧，程序计数器用来存放执行指令的偏移量和行号指示器等，线程执行或恢复都要依赖程序计数器。程序计数器在各个线程之间互不影响，此区域也不会发生内存溢出异常
    - 总结
      - 从线程共享的角度看，堆和元空间是线程共享的，虚拟机栈、本地方法栈、程序计数器都是线程内部私有的
对象实例化
- 介绍
  - Java 是面向对象的静态强类型语言，声明并创建对象的代码很常见，很具某个类声明一个引用变量指向被创建的对象，并使用此引用变量操作该对象
- 实例化对象的过程
  - 从最简单的 Obejct ref = new Object(); 代码进行分析，利用 javap -verbose -p 命令查看对象创建的字节码
```
    stack=2，locals=1，args_size=0
    NEW java/lang/Object
    BUP
    INVOKESPECIAL java/lang/Object.<init> ()V
    ASTORE_1
    LocalVariableTable:
        Start  Length  Slot  Name  Signature
        8      1       0     ref   Ljava/lang/Object; 
```
    - NEW：如果找不到 Class 对象，则进行类加载。加载成功后，则在堆中分配内存，Object 开始到本类路径上的所有属性值都要分配内存。分配完毕之后，进行零值初始化。在分配过程中，注意引用是占据存储空间的，它是一个变量，占用 4 个字节。这个指令完毕后，将指向实例对象的引用变量压入虚拟机栈顶
    - DUP：在栈顶复制该引用变量，这时的栈顶有两个指向堆内实例对象的引用变量。如果方法有参数，还需要把参数压入操作栈中。两个引用变量的目的不同，其中压至底下的引用用于赋值，或者保存到局部变量表，另一个栈顶的引用变量作为句柄调用相关方法
    - INVOKESPECIAL：调用对象实例方法，通过栈顶的引用变量调用方法。是类初始化时执行的方法，而是对象初始化时执行的方法
  - 前面所示是从字节码的角度看待对象的创建过程，现在从执行步骤的角度来分析
    - 确认类元信息是否存在。当 JVM 接收到 new 指令时，首先在 metaspace 内检查需要创建的类元信息是否存在。若不存在，那么在双亲委派模式下，使用当前类加载器以 ClassLoader＋包名＋类名为 Key 进行查找对应的 .class 文件。如果没有找到文件，则抛出 ClassNotFoundException 异常，如果找到，则进行类加载，并生成对应的 Class 类对象
    - 分配对象内存。首先计算对象占用空间大小，如果实例成员变量是引用变量，仅分配引用变量空间即可，即 4 个字节大小，接着在堆中划分一块内存给新对象。在分配内存空间时，需要进行同步操作，比如采用 CAS (Compare And Swap）失败重试、区域加锁等方式保证分配操作的原子性
    - 设定默认值。成员变量值都需要设定为默认值，即各种不同形式的零值
    - 设置对象头。设置新对象的哈希码、GC信息、锁信息、对象所属的类元信息等。这个过程的具体设置方式取决于 JVM 实现
    - 执行 init 方法。初始化成员变量，执行实例化代码块，调用类的构造方法，并把堆内对象的首地址赋值给引用变量
垃圾回收
- 介绍
  - Java 会对内存进行自动分配与回收管理，使上层业务更加安全，方便地使用内存实现程序逻辑。在不同的 Java 实现及不同的回收机制中，堆内存的划分方式是不一样的。这里简要介绍垃圾回收（ Garbage Collection, GC ）。垃圾回收的主要目的是清除不再使用的对象，自动释放内存
- GC Roots
  - 如果一个对象与 GC Roots 之间没有直接或间接的引用关系，比如某个失去任何引用的对象，或者两个互相环岛状循环引用的对象等，判决这些对象“死缓”，是可以被回收的。什么对象可以作为 GC Roots ？比如类静态属性中引用的对象、常量引用的对象、虚拟机栈中引用的对象、本地方法栈中引用的对象等
- 垃圾回收算法
  - 最基础的为"标记－清除算法"，该算法会从每个 GC Roots 出发，依次标记有引用关系的对象，最后将没有被标记的对象清除。但是这种算法会带来大量的空间碎片，导致需要分配－个较大连续空间时容易触发 FGC。为了解决这个问题，又提出了"标记一整理算法"，该算法类似计算机的碰盘整理，首先会从 GC Roots 发标记存活的对象，然后将存活对象整理到内存空间的一端，形成连续的已使用空间，最后把已使用空间之外的部分全部清理掉，这样就不会产生空间碎片的问题。"Mark-Copy"算法为了能够并行地标记和整理将空间分为两块，每次只激活其中一块，垃圾回收时只需把存活的对象复制到另一块未激活空间上，将未激活空间标记为己激活，将己激活空间标记为未激活，然后清除原空间中的原对象。堆内存空间分为较大的 Eden 和两块较小 Survivor，每次只使用 Eden 和 Survivor 区的一块。这种情形下的 “Mark-Copy” 减少了内存空间的浪费。"Mark-Copy"现作为主流的 YGC 算法进行新生代的垃圾回收
- 垃圾回收器
  - 垃圾回收器是实现垃圾回收算法并应用在 JVM 环境中的内存管理模块
  - Serial回收器
    - Serial 回收器是一个主要应用于 YGC 的垃圾回收器，采用串行单线程的方式完 GC 任务，其中“ Stop The World ”简称 STW ，即垃圾回收的某个阶段会暂停整个应用程序的执行。 FGC 的时间相对较长，频繁 FGC 会严重影响应用程序的性能
  - CMS回收器
    - CMS 回收器是回收停顿时间比较短、目前比较常用的垃圾回收器。它通过初始标记（Initial Mark）、并发标记（Concurrent Mark）、重新标记（Remark）、并发清除（Concurrent Sweep）四个步骤完成垃圾回收工作。第1、3步的初始标记和重新标记阶段依然会引发 STW ，而第2、4步的并发标记和并发清除两个阶段可以和应用程序并发执行，也是比较耗时的操作，但并不影响应用程序的正常执行。由于 CMS 采用的是"标记一清除算法"，因此产生大量的空间碎片。为了解决这个问题， CMS 可以通过配置 XX :+UseCMSCompactAtFullCollection 参数，强制 JVM FGC 完成后对老年代进行压缩，执行一次空间碎片整理，但是空间碎片整理阶段也会引发 STW 。为了减少 STW 次数， CMS 还可以通过配置一XX:+CMSFul!GCsBeforeCompaction=n 参数，在执行了 n 次 FGC 后，JVM 再在老年代执行空间碎片整理
  - G1回收器
    - Hotspot 在 JDK7 推出了新一代 G1 (Garbage-First Garbage Collector) 垃圾回收，通过 -XX:+UseG1GC 参数启用。和 CMS 相比，G1具备压缩功能，能避免碎片问题，G1 的暂停时间更加可控
    - G1 将 Java 堆空间分割成了若干相同大小的区域，即 region，包括 Eden、Survivor、Old、Humongous 四种类型。其中，Humongous 是特殊的 Old 类型，专门放置大型对象。这样的划分方式意昧着不需要一个连续的内存空间管理对象。G1 将空间分为多个区域，优先回收垃圾最多的区域。G1 采用的是"Mark-Copy"，有非常好的空间整合能力，不会产生大量的空间碎片。 G1 的一大优势在于可预测的停顿时间，能够尽可能快地在指定时间内完成垃圾回收任务。在 JDK11 中，已经将 G1 设为默认垃圾回收器，通过 jstat 命令可以查看垃圾回收情况，在 YGC 时 S0/S1 并不会交换
    - S0/S1 的功能由 G1 中的 survivor region 来承载。通过 GC 日志可以观察到完整的垃圾回收过程如下，其中就有 surivor regions 的区域从 0 个到 1 个
    - 红色标识的为 G1 中的四种 region 都处于 Heap 中。G1 执行时使用 worker 并发执行，在初始标记时，还是会触发 STW 如第一步所示的 Pause

第五章异常与日志

处理异常需要解决的问题
- 哪里发生异常？
- 谁来处理异常？
- 如何处理异常？
异常的分类
- JDK 中定义了一套完整的异常机制，所有异常都是 Throwable 的子类，分为 Error(致命异常)和 Exception(非致命异常)。Error 是一种非常特殊的异常类型，它出现标志的系统发生不可控的错误，例如 StackOverflowError、OutofMemoryError。针对此类错误程序无法处理，只能人工介入。Exception 又分为 checked 异常(受检异常)和 unchecked 异常(非受检异常)
- checked 异常时需要在代码中显式处理的异常，unchecked 异常时运行时异常，它们都继承自 RuntimeException，不需要程序进行显式的捕捉和处理
- unchecked 异常又可以分为三类：
  - 可预测异常（Predicted Exception）：常见的可预测异常包括 IndexOutOfBoundsException、NullPointerException 等，需要做好预判并处理
  - 需捕捉异常（Caution Exception）：例如远程访问的 DubboTimeoutException，此类异常必须显示处理
  - 可透出异常（Ignored Exception）：框架或系统产生的会自行处理的异常，例如 404 等

try代码块

try-catch-finally 是处理程序异常的三部曲。当存在 try 时，可以只有 catch 代码块，也可以只有 finally 代码块，就是不能单独只有 try 这个光杆司令
try 代码块：监视代码执行过程，一旦发现异常则直接跳转至 catch，如果没有 catch，则直接跳转至 finally
catch 代码块：可选执行代码块，如果没有任何异常不会执行，如果发现异常则进行处理或向上抛出

finally 代码块：必选执行的代码块，不管是否又异常产生，即使发生 OOM 异常也会执行，通常用户处理善后清理工作

如果 finally 代码块没有执行，那么有三种可能
- 没有进入 try 代码块
- 进入 try 代码块，但是代码运行中出现了死循环或死锁状态
- 进入 try 代码块，但是执行了 System.exit() 操作

finally 是在 return 表达式运行后执行的，此时要 return 的结果已经被封存起来了，待 finally 代码块执行结束后将之前暂存的结果返回

    public static int finallyNotWork() {
        int temp = 10000;
        try {
            throw new Exception();
        } catch (Exception e) {
            return ++temp ;
        }finally {
            temp = 99999;
        }
    }
    // 输出
    // 10001

相比在 finally 代码块中赋值，更加危险的是 finally 块中使用 return 操作，这样的代码会使返回值变得非常不可控

    public class TryCatchFinally{
        static int x = 1;
        static int y = 10;
        static int z = 100;
        public static void main(String[] args){
            int value = finallyReturn();
            System.out.println("Value=" + value);
            Systme.out.println("x=" + x);
            Systme.out.println("y=" + y);
            Systme.out.println("z=" + z);
        }
        public static int finallyReturn(){
            try{
                // ...
                return ++x;
            }catch(Excepton e){
                return ++y;
            }finally{
                return ++z;
            }
        }
    }
    // 输出
    // value=101
    // x=2
    // y=10
    // z=101

以上执行结果说明
- 最后的 return 的动作是由 finally 代码块中的 return ++z 完成的，所以方法返回的结果是 101
- 语句 return ++x 中的 ++x 被成功执行，所以运行结果是 x=2
- 如果有异常抛出，那么运行结果将会是 y=11,x=1

try 代码块与锁

Lock、ThreadLocal、InputStream等这些需要进行强制释放和清除的对象都得在 finally 代码块中进行显式的清理，避免产生内存泄露，或者资源消耗

    Lock lock = new XxxLock();
    preDo();
    try{
        // 无论加锁是否成功，unlock 都会执行
        lock.lock();
        doSomething();
    }finally{
        lock.unlock();
    }

异常的抛与接
- 对外提供的开放接口使用错误码
- 公司内部跨应用远程服务调用优先考虑使用 Result 对象来封装错误码、错误描述信息
- 应用内部则推荐直接抛出异常信息
日志
- 日志规范
  - 推荐的日志文件命名方式为：appName_logType_LogName.log
- 日志级别
  - DEBUG 级别日志：记录对调试程序有帮助的信息
  - INFO 级别日志：记录程序运行现场，虽然此处并未发生错误，但对排查其他错误具有指导意义
  - WARN 级别日志：记录程序运行现场，但是更偏向于此处有出现潜在错误的可能
  - ERROR 级别日志：记录程序发生了错误，需要被关注。但当前错误没有影响系统的继续进行
  - FATAL 级别日志：记录程序运行的验证错误，并且会导致系统中断
- 日志级别的使用
  - 预先判断日志级别
  - 避免无效日志打印：生产环境禁止输出 DEBUG 日志而有选择地输出 INFO 日志
  - 区别对待错误日志：一些业务是可以通过引导重试恢复正常地，可以使用 WARN，而需要人工介入的使用 ERROR。所以 ERROR 级别只记录系统逻辑错误、异常或违反重要的业务规则，其他错误都可以归为 WARN 级别
  - 保证记录内容完整：记录异常时，一定要输出异常堆栈，例如 logger.error(“xxx”+e.getMessage(),e)
日志框架
- 日志框架分为三大部分，包括日志门面、日志适配器、日志库。利用门面设计模式，即 Facade 来进行解耦
- 门面模式
  - 门面设计模式是面向对象设计模式中的一种，日志框架采用的就是这种模式，类似 JDBC 的设计理念。它只提供一套接口规范，自身不负责日志功能的实现，目的是让使用者不需要关注底层具体是哪个日志库来负责日志打印及具体的使用细节等。目前用得最为广泛的日志门面有两种：slf4j 和 commons-logging
- 日志库
  - 它具体实现了日志的相关功能，主流的日志库有三个，分别是 log4j、log-jdk、logback。最早 Java 要想记录日志只能通过 System.out 或 System.error 来完成，非常不方便。log4j 就是为了解决这一问题而提出的，它是最早诞生的日志库。接着 JDK 也在 1.4 版本引入了一个日志库 java.util.logging.Logger，简称 log-jdk。这样市面上就出现两种功能的实现，开发者在使用时需要关注所使用的日志库的具体细节。 logback 是最晚出现的，它与 log4j 出自同一个作者，是 log4j 的升级版且本身就实现了 slf4j 的接口
- 日志适配器
  - 日志门面适配器：因为 slf4j 规范是后来出的，在此之前的日志库是没有实现 slf4j 的接口的，例如 log4j，所以在工程里要使用 slf4j+log4j 的模式，就额外需要一个适配器（slf4j-log4j）来解决接口不兼容的问题
  - 日志库适配器：在一些老的工程里，一开始为了开发简单而直接使用了日志库 API 来完成日志的打印，但随着时间推移想从原来直接调用日志库的模式改为业界标准的门面模式，就需要一个适配器来完成从旧日志库的 API 到 slf4j 的路由

日志的使用

新项目：则推荐使用 slf4j+logback 模式

    <dependency>
        <groupid>org.slf4]groupid>
        <artifactid>slf4j-apiartifactid>
        <version>${slf4j-api.version}version>
    dependency>
    <dependency>
        <groupid>ch.qos.logbackgroupid>
        <artifactid>logback-classicartifactid>
        <version>${logback-classic.version}version>
    dependency>
    <dependency>
        <groupid>ch.qos.logbackgroupid>
        <artifactid>logback-coreartifactid>
        <version>${logback-core.version}version>
    dependency>

老项目：如果是老工程，则需要根据所使用的日志库来确定门面适配器，通常情况下老工程使用的都是 log4j 因此以 log4j 日志库为例

    <dependency>
        <groupid>org.slf4jgroupid>
        <artifactid>slf4j-apiartifactid>
        <version>${slf4j-api.version}version>
    dependency>
    <dependency>
        <groupid>org.slf4jgroupid>
        <artifactid>slf4j-log4j12artfactid>
        <version>${slf4j-log4j12.version}version>
    dependency>
    <dependency>
        <groupid>log4jgroupid>
        <artifactid>log4jartifactid>
        <version>${log4j.version}version>
    dependency>

如果老代码中直接使用了 log4j 日志库提供的接口来打印曰志，则还需要引人日志库适配器

    <dependency>
        <groupid>org.slf4jgroupid>
        <artifactid>log4j-over-slf4jartifactid>
        <version>${log4j-over-slf4j.version}version>
    dependency>

logger 被定义为 static 变量，是因为这个 logger 与当前类绑定避免每次new 一个新对象，造成资源浪费，甚至引发 OutOfMernoryError 问题
在使用 slf4j + 日志库模式时，要防止日志库冲突，一旦发生则可能会出现日志打印功能失效的问题

第六章数据结构与集合

数据结构
- 数据结构的定义
  - 数据结构是指逻辑意义上的数据组织方式及其相应的处理方式
  - 什么是逻辑意义
    - 数据结构的抽象表达非常丰富，而实际物理存储的方式相对单一。二叉树在说盘中的存储真的是树形排列吗？并非如此。树的存储可能是基于物理上的顺序存储方式，可以理解为一个格子一个格子连续地放
  - 什么是数据组织方式
    - 逻辑意义上的组织方式有很多，比如树、图、队列、哈希等。树可以是二叉树、三叉树、B+树等，图可以是有向图或无向图，队列是先进先出的线性结构；哈希是根据某种算法直接定位的数据组织方式
  - 什么是数据处理方式
    - 在既定的数据组织方式上，以某种特定的算法实现数据的增加、删除、修改、查找和遍历。不同的数据处理方式往往存在着非常大的性能差异
- 数据结构的分类
  - 线性结构：0 至 1 个直接前继和直接后继。当线性结构非空时，有唯－的首元素和尾元素，除两者外，所有的元素都有唯一的直接前继和直接后继。线性结构包括顺序表、链表、栈、队列等，其中栈和队列是访问受限的结构。栈是后进先出，即 Last In, First-Out ，简称 LIFO；队列是先进先出，即 First-In First-Out，简称 FIFO
  - 树结构：0 至 1 个直接前继和 0 至 n 个直接后继（n大于或等于2）。树是一种非常重要的有层次的非线性数据结构，像自然界的树一样。由于树结构比较稳定和均衡，在计算机领域中得到广泛应用
  - 图结构：0 至 N 个直接前继和直接后继（n大于或等于2）。图结构包括简单图、多重图、有向图和无向图等
  - 哈希结构：没有直接前继和直接后继。哈希结构通过某种特定的哈希函数将索引与存储的值关联起来，它是一种查找效率非常高的数据结构
- 数据处理的性能
  - 空间复杂度
  - 时间复杂度
    - 从最好到最坏的常用算法复杂度排序如下：常数级O(1)、对数级O(logn)、线性级O(n)、线性对数级O(nlogn)、平方级O(n2)、立方级O(n3)、指数级O(2n)等
集合框架图
- Java 中的集合是用于存储对象的工具类容器，它实现了常用的数据结构，提供了一系列公开的方法用于增加、删除、修改、查找和遍历数据，降低日常开发成本
- 集合框架主要分为两类：第一类是按照单个元素存储的 Collection，在继承树中 Set 和 List 都实现了 Collection 接口；第二类是按照 Key-Value 存储的 Map
- 在集合框架图中，红色代表接口，蓝色代表抽象类，绿色代表并发包中的类，灰色代表早期线程安全的类（基本已经弃用）
- List集合
  - List 集合是线性数据结构的主要实现，集合元素通常存在明确的上一个和下一个元素，也存在明确的第一个元素和最后一个元素
  - 该体系最常用的是 ArrayList 和 LinkedList 两个集合类
    - ArrayList 是容量可以改变的非线程安全集合。内部实现使用数组进行存储，集合扩容时会创建更大的数组空间，把原有数据复制到新数组中。ArrayList 支持对元素的快速随机访问，但是插入与删除时速度通常很慢，因为这个过程很有可能需要移动其他元素
    - LinkedList 的本质是双向链表。与 ArrayList 相比 LinkedList 的插入和删除速度更快，但是随机访问速度则很慢。测试表明，对于 10 万条的数据，与 ArrayList 相比，随机提取元素时存在数百倍的差距。除继承 abstractList 抽象类外， LinkedList 还实现了另一个接口 Deque ，即 double-ended queue。这个接口同时具有队列和栈的性质。LinkedList 包含 3 个重要的成员 first、first、last。size 是双向链表中节点的个数。first 和 last 分别指向第一个和最后一个节点的引用。 LinkedList 的优点在于可以将零散的内存单元通过附加引用的方式关联起来，形成按链路顺序查找的线性结构，内存利用率较高
- Queue （队列）
  - Queue 是一种先进先出的数据结构，队列是一种特殊的线性表，它只允许在表的一端进行获取操作，在表的另一端进行插入操作。当队列中没有元素时，称为空队列。自从 BlockingQueue （阻塞队列）问世以来，队列的地位得到极大的提升，在各种高并发编程场景中，由于其本身 FIFO 的特性和阻塞操作的特点，经常被作为 Buffer （数据缓冲区）使用
- Map
  - Map 集合是以 Key-Value 键值对作为存储元素实现的哈希结构， Key 按某种哈希函数计算后是唯一的， Value 则是可以重复的。Map 类提供三种 Collection 视图，在集合框架图中， Map 指向 Collection 的箭头仅表示两个类之间的依赖关系可以使用 keySet（）查看所有的町，使用 values （）查看所有的 Value ，使用 ent Set（）查看所有的键值对。最早用于存储键值对的 Has table 因为能瓶颈已经被淘汰，而如今广泛使用的 HashMa 线程是不安全的。 ConcurrentHashMap 是线程安全的，在 JDK8 进行了锁的大幅度优化，体现出不错的性能。在多线程并发场景中，优先推荐使ConcurrentHashMap ，而不是 HashMap TreeMap Key 有序的 Map 类集合
- Set 集合
  - Set 是不允许出现重复元素的集合类型。 Set 体系最常用的是 HashSet、TreeSet 和 LinkedHashSet 三个集合类。 HashSet 从源码分析是使用 HashMap 来实现的，只是 Value 固定为一个静态对象，使用 Key 保证集合元素的唯一性，但它不保证集合元素的顺序。TreeSet 也是如此，从源码分析是使用 TreeMap 来实现的，底层为树结构，在添加新元素到集合中时，按照某种比较规则将其插入合适的位置，保证插入后的集合仍然是有序的。LinkedHashSet 继承自 HashSet，具有 HashSet 的优点，内部使用链表维护了元素插入顺序

集合初始化

集合初始化通常进行分配容量、设置特定参数等相关工作

ArrayList

    public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
        private static final int DEFAULT_CAPACITY  = 10；
        // 空表的表示方法
        private static final Object[] EMPTY_ELEMENTDATA = {};
        transient Object[] elementData;
        private int size;

        public ArrayList(int initialCapacity) {
            if (initialCapacity > 0) {
                // 值大于0时，根据构造方法的参数值，忠实地创建一个多大的数组
                this.elementData = new Object[initialCapacity];
            } else if (initialCapacity == 0) {
                this.elementData = EMPTY_ELEMENTDATA;
            }
        }

        // 公开的 add 方法调用此内部私有方法
        private void add(E e, Object[] elementData, int s) {
            // 当前数组能否容纳size+1的数组，如果不够则调用grow来扩展
            if (s == elementData.length)
                elementData = grow();
            elementData[s] = e;
            size = s + 1;
        }

        private Object[] grow() {
            return grow(size + 1);
        }

        // 扩容的最小要求，必须满足容纳刚才的元素个数+1，注意，newCapacity()
        // 方法才是扩容的重点
        private Object[] grow(int minCapacity) {
            return elementData = Arrays.copyof(elementData, newCapacity(minCapacity));
        }

        private int newCapacity(int minCapacity) {
            // 防止扩容1.5倍后超过int的表示范围（第一处）
            int oldCapacity = elementData.length;
            // JDK6之前扩容50%或50%-1，但是取ceil，而之后的版本取floor（第二处）
            int newCapacity = oldCapacity + (oldCapacity >> 1);
            if (newCapacity- minCapacity <=0) {
                if (elementData == DEFAULTCAPACITY_EMPTY_ ELEMENTDATA)
                    // 无参数构造方法，会在此时分配默认10的容量
                    return Math.max(DEFAULT_CAPACITY, minCapacity);
                if (minCapacity < 0 )
                    throw new OutOfMemoryError();
                return minCapacity;
            }
            return (newCapacity - MAX_ARRAY_SIZE <= 0)? newCapacity:hugeCapacity(minCapacity);
        }

    }

第一处说明：正数带符号右移的值肯定是正值，所以 oldCapatity+(oldCapacity>>1) 的结果可能超过 int 可以表示的最大值，反而有可能比 minCapacity 更小，则返回值为 (size+1) 的 minCapacity
第二处说明：如果原始容量是 13，当新添加一个元素时，根据程序中的算法得出 13 的二进制数为 1101，随后右移 1 位操作后得到二进制数 110，即十进制数 6。最终扩容的大小计算结果为 oldCapacity+(oldCapacity>>1)=13+6=19。使用位运算主要是基于计算效率的考虑。在JDK7 之前的公式，扩容计算方式和结果为 oldCapacity3/2+1=133/2+1=20

HashMap
- HashMap 扩容是需要重建 hash 表非常影响性能。在 HashMap 中有两个比较重要的参数，CapaCity 和 Load Factory，其中 Capacity 决定了存储容量的大小，默认为 16；而 Load Factor 决定了填充比例，一般使用默认的 0.75。基于这两个参数的乘积，HashMap 内部用 threshold 变量表示 HashMap 中能放入的元素个数。HashMap 容量并不会在 new 的时候分配，而是在第一次 put 的时候完成创建的
```
    public v put(K key, V value) {
        if (table == EMPTY_TABLE) {
            inflateTable(threshold);
        }
        // ...省略代码
    }

    // 第一次put时，调用如下方法，初始化table
    private void inflateTable(int toSize) {
        // 找到大于参数值且最接近2的幂值，假如输入参数是27则返回32
        int capacity = roundUpToPowerOf2{toSize};

        // threshold 在不超过限制最大值的前提下等于 capacity * loadFactor
        threshold = (int)Math.min(capacity * loadFactory, MAXIMUM_CAPACITY + 1);
        table = new Entry[capacity];
        initHashSeedAsNeeded(capacity);
    }
```
- 为了提高运算速度，设定 HashMap 容量大小为 2 的 n 次方。如果初始化 HashMap 的时候通过构造器指定了 initialCapacity，则会计算出比 initialCapacity 大的 2 的幂存入 threshold，在第一次 pull 时会按照这个 2 的幂初始化数组大小，此后每次扩容都是增加 2 倍

数组与集合
- 数组是一种顺序表，在各种高级语言中，它是组织和处理数据的一种常见方式，我们可以使用索引下标进行快速定位并获取指定位置的元素。数组的下标从 0 开始，源于 BCPL 语言，它将指针设置在 0 的位置，用数组下标作为直接偏移量进行计算，为什么下标不从 1 开始呢？如果这样，计算偏移量就要使用当前下标减 1 的操作。加减法对 CPU 来说是一种双数运算，在数组下标使用频率极高的场景下，这种运算十分耗时
- 在 Java 体系中，数组用以存储同一类型的对象，一旦分配内存后无法扩容
- Arrays 是针对数组对象进行操作的工具类，包括数组的排序、查找、对比、拷贝等操作

集合与泛型

示例

    public class ListNoGeneric {
        public static void main(String[] args){
            
            // 第一段：泛型出现之前的集合定义方式
            List a1 = new ArrayList();
            a1.add(new Object());
            a1.add(new Integer(111));
            a1.add(new String("hello a1a1"));

            // 第二段：把a1引用赋值给a2，注意a2与a1的区别是增加了泛型限制

方法	释义
fail	断言测试失败
assertTrue/asse11False	断言条件为真或为假
assertNull/assertNotNull	断言指定值为 null 或非 null
assertEquals/assertNotEquals	断言指定两值相等或不相等，对于基本数据类型，使用值比较；对于对象，使用 equals 方法比较
assertArrayEquals	断言数组元素全部相等
assertSame/assertNotSame	断言指定两个对象是否为同一个对象
assettThrows/assertDoesNotThrow	断言是否抛出了一个特定类型的异常
assertTimeout/assertTimeoutPreemptively	断言是否执行超时，区别在于测试程序是否在同一个线程内执行
assertlterabIeEquals	断言迭代器中的元素全部相等
assertLinesMatch	断言字符串列表元素全部正则匹配
assertAll	断言多个条件同时满足
assumeTrue/assumeFalse	先判断给定的条件为真或假，再决定是否继续接下来的测试

【读书笔记】码出高效：Java开发手册

第一章计算机基础

第二章面向对象

第三章代码风格

第四章走进 JVM

第五章异常与日志

第六章数据结构与集合

第七章并发与多线程

第八章单元测试

第九章代码规约

免责声明：本文仅用于个人学习、交流，非商业用途；版权均属于原出品公司及原作者！

免责声明：本文禁止转载！

个人建议买本正版书，这是本值得反复翻看反复学习的书

你可能感兴趣的:(读书笔记)

名称	说明
table	存储所有节点数据的数组
slot	哈希槽。即table[i]这个位置
bucket	哈希桶。table[i]上所有元素形成的表或数的集合

名称	说明
length	table数组的长度
size	成功通过put方法添加到HashMap中的所有元素的个数
hashCode	Object.hashCode()返回的int值，尽可能地离散均为分布
hash	Object.hashCode()与当前集合地table.length进行位运算地结果，以确定哈希槽的位置

【读书笔记】码出高效：Java开发手册

第一章 计算机基础

第二章 面向对象

第三章 代码风格

第四章 走进 JVM

第五章 异常与日志

第六章 数据结构与集合

第七章 并发与多线程

第八章 单元测试

第九章 代码规约

免责声明：本文仅用于个人学习、交流，非商业用途；版权均属于原出品公司及原作者！

免责声明：本文禁止转载！

个人建议买本正版书，这是本值得反复翻看反复学习的书

你可能感兴趣的:(读书笔记)

第一章计算机基础

第二章面向对象

第三章代码风格

第四章走进 JVM

第五章异常与日志

第六章数据结构与集合

第七章并发与多线程

第八章单元测试

第九章代码规约