示例 代码

前言

为编程的核心知识建立知识地图，从最基础的概念开始，分解为知识点，一个知识点一个知识点地讲解，每一个知识点都力争清晰透彻，阐述知识点是什么、怎么用、有什么用途、实现原理是什么、思维逻辑是什么、与其他知识点有什么关系等。

要掌握人工智能技术，必须先掌握基本编程技术。

2017年7月，国务院印发了《新一代人工智能发展规划》，其中提到“实施全民智能教育项目，在中小学阶段设置人工智能相关课程，逐步推广编程教育”，未来，可能大部分人都需要学习编程。

一、编程基础与二进制

1 编程基础

操作系统将时间分成很多细小的时间片，一个时间片给一个程序用，另一个时间片给另一个程序用，并频繁地在程序间切换。不过，在应用程序看来，整个机器资源好像都归它使用，操作系统给它制造了这种假象。对程序员而言，编写程序时基本不用考虑其他应用程序，做好自己的事就可以了。

应用程序看上去能做很多事情，能读写文档、能播放音乐、能聊天、能玩游戏、能下围棋等，但本质上，计算机只会执行预先写好的指令（操作数据或者设备）而已。

所谓程序，基本上就是告诉计算机要操作的数据和执行的；指令序列，即对什么数据做什么操作，比如：

1. 读文档，就是将数据从磁盘加载到内存，然后输出到显示器上；
2. 写文档，就是将数据从内存写回磁盘；
3. 播放音乐，就是将音乐的数据加载到内存，然后写到声卡上；
4. 聊天，就是从键盘接收聊天数据，放到内存，然后传给网卡，通过网络传给另一个人的网卡，再从网卡传到内存，显示在显示器上。

数据在计算机内部都是二进制表示的，不方便操作，为了方便操作数据，高级语言引入了数据类型和变量的概念；

对数据进行的第一个操作：赋值；

数据有了初始值之后，可以对数据进行的一些基本运算；

为了编写有实用功能的程序，需要对操作的过程进行流程控制；

为了减少重复代码和分解复杂操作，计算机程序引入了函数和子程序的概念。

1.1 数据类型和变量

8中基本数据类型：

1. 整数类型：有4种整型byte/short/int/long（分别占1、2、4、8个字节），分别有不同的取值范围；
2. 小数类型：有两种类型float/double（4和8字节），有不同的取值范围和精度；
3. 字符类型：char，表示单个字符（2字节）；
4. 真假类型：boolean，表示真假。

世界万物都是由元素周期表中的基本元素组成的，基本数据类型就相当于化学中的基本元素，而对象就相当于世界万物。

所谓内存在程序看来就是一块有地址编号的连续的空间，数据放到内存中的某个位置后，为了方便地找到和操作这个数据，需要给这个位置起一个名字。编程语言通过变量这个概念来表示这个过程。

变量就是给数据起名字，方便找不同的数据，它的值可以变，但含义不应变。

1.2 赋值

赋值声明变量之后，就在内存分配了一块位置，但这个位置的内容是未知的，赋值就是把这块位置的内容设为一个确定的值。

数组类型

3中赋值方式：

1
2
3
4
5
6
7
8

int[] arr = {1,2,3};

int[] arr = new int[]{1,2,3};

int[] arr = new int[3];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;

动态确定数组长度：

1
2

int length = ...; // 根据一些条件动态计算
int[] arr = new int[length];

数组组长度虽然可以动态确定，但定了之后就不可以变。

数组类型和基本类型是有明显不同的，一个基本类型变量，内存中只会有一块对应的内存空间。但数组有两块：一块用于存储数组内容本身，另一块用于存储内容的位置。

1.3 基本运算

算术运算

整数相除不是四舍五入，而是直接舍去小数位。

小数计算结果不精确。

比较运算

逻辑运算

• 与（&）
• 或（|）
• 非（!）
• 异或（^）：两个相同为false，两个不相同为true；
• 短路与（&&）
• 短路或（||）

1.4 条件执行

if/else

三元运算

switch

实现原理

CPU的指令指示器，跳转指令，有两种：

1. 条件跳转（满足某个条件则进行跳转）
2. 无条件跳转（直接跳转）

if/else就是转换为跳转指令：

1
2
3
4
5
6

        1 int a=10;
        2 if(a%2==0)
        3 {
        4     System.out.println("偶数");
        5 }
        6 //其他代码

转换为：

1
2
3
4
5
6
7

        1 int a=10;
        2 条件跳转：如果a%2==0，跳转到第4行
        3 无条件跳转：跳转到第7行
        4 {
        5     System.out.println("偶数");
        6 }
        7 //其他代码

switch的转换和具体系统实现有关。如果分支比较少，可能会转换为跳转指令。如果分支比较多，使用条件跳转会进行很多次的比较运算，效率比较低，可能会使用一种更为高效的方式，叫跳转表。跳转表是一个映射表，存储了可能的值以及要跳转到的地址：

跳转表为什么会更为高效呢？因为其中的值必须为整数，且按大小顺序排序。按大小排序的整数可以使用高效的二分查找。

程序源代码中的case值排列不要求是排序的，编译器会自动排序。

switch值的类型可以是byte、short、int、char、枚举和String。byte、short、int、char都是整数，枚举也可以表示为整数，String用于switch时也会转换为整数（通过hasCode方法）。不可以使用long，因为跳跳转表值的存储空间一般为32位，容纳不下long。

1.5 循环

循环：多次重复执行某些类似的操作。

计算机程序运行时大致只能顺序执行、条件执行和循环执行。顺序和条件其实没什么特别的，而循环大概才是程序强大的地方。

循环的4中形式：

1. while

2. do/while

3. for

4. foreach 对于不需要使用索引变量，只是简单遍历的情况，foreach语法上更为简洁。

   1 2 3

   for (int element : arr) { }

循环控制：

break

continue

虽然循环看起来只是重复执行一些类似的操作而已，但它其实是计算机程序解决问题的一种基本思维方式。

解决复杂问题的基本策略是分而治之，将复杂问题分解为若干相对简单的子问题，然后子问题再分解为更小的子问题……程序由数据和指令组成，大程序可以分解为小程序，小程序接着分解为更小的程序。

1.6 函数的用法

使用函数来减少重复代码和分解复杂操作。

Java中，任何函数都需要放在一个类中。Java中的函数一般叫做方法。

1
2
3
4

修饰符 返回值类型 函数名字(参数类型 参数名字，...) {
	操作
  return 返回值;
}

Java中函数有大量修饰符，如：public、private、static、final、synchronized、abstract等。

定义函数时声明参数，实际上就是定义变量，只是这些变量的值是未知的，调用函数时传递参数，实际上就是给函数中的变量赋值。

对于需要重复执行的代码，可以定义函数，然后在需要的地方调用，这样可以减少重复代码。对于复杂的操作，可以将操作分为多个函数，会使得代码更加易读。

进一步理解函数

1 参数传递

有两类特殊类型的参数：

• 数组

函数内修改数组中的元素会修改调用者中的数组内容。

• 可变长度的参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public static int max(int min, int ... a){
  int max = min;
  for(int i=0; i<a.length; i++){
    if(max<a[i]){
      max = a[i];
    }
  }
  return max;
}
public static void main(String[] args) {
  System.out.println(max(0));
  System.out.println(max(0,2));
  System.out.println(max(0,2,4));
  System.out.println(max(0,2,4,5));
}

可变长度参数可以看作是数组。可变长度参数必须是参数列表中的最后一个，一个函数也只能有一个可变长度的参数。

1.7 函数调用的基本原理

栈的概念

程序执行的基本原理：CPU有一个指令指示器，指向下一条要执行的指令，要么顺序执行，要么进行跳转（条件跳转或无条件跳转）。

程序从main函数开始顺序执行，函数调用可以看作一个无条件跳转，跳转到对应函数的指令处开始执行，碰到return语句或者函数结尾的时候，再执行一次无条件跳转，跳转回调用方，执行调用函数后的下一条指令。

有几个问题：

1. 参数如何传递？

2. 函数如何知道返回到什么地方？

   在if/else、for中，跳转的地址都是确定的，但函数自己并不知道会被谁调用，而且可能会被很多地方调用，它并不能提前知道执行结束后返回哪里。

3. 函数结果如何传给调用方？

解决思路是使用内存来存放这些数据，函数调用方和函数自己就如何存放和使用这些数据达成一个一致的协议或约定。这个约定在各种计算机系统中都是类似的，存放这些数据的内存有一个相同的名字，叫栈。

栈中存放函数调用过程中需要的数据，包括参数、返回地址以及函数内定义的局部变量。

函数执行的基本原理

• 当程序在main函数调用Sum.sum之前，栈的情况：

• 在程序执行到Sum.sum的函数内部，准备返回之前，即第5行，栈的情况：

  

在main函数调用Sum.sum时，首先将参数1和2入栈，然后将返回地址（也就是调用函数结束后要执行的指令地址）入栈，接着跳转到sum函数，在sum函数内部，需要为局部变量c分配一个空间，而参数变量a和b则直接对应于入栈的数据1和2，在返回之前，返回值保存到了专门的返回值存储器中。

在调用return后，程序会跳转到栈中保存的返回地址，即main的下一条指令地址，而sum函数相关的数据会出栈，从而又变回图1-1的样子。

这些变量只有在函数被调用的时候才分配，而且在调用结束后就被释放了。但这个说法主要针对基本数据类型。

数组和对象的内存分配

数组和对象类型，存放地址的空间是分配在栈上的，实际内容空间一般分配在**堆中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

public class ArrayMax {
  public static int max(int min, int[] arr) {
    int max = min;
    for(int a : arr){
      if(a>max){
        max = a;
      }
    }
    return max;
  }
  public static void main(String[] args) {
    int[] arr = new int[]{2,3,4};
    int ret = max(0, arr);
    System.out.println(ret);
  }
}

递归调用的原理

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public static int factorial(int n){
  if(n==0){
    return 1;
  }else{
    return n＊factorial(n-1);
  }
}
public static void main(String[] args) {
  int ret = factorial(4);
  System.out.println(ret);
}

返回值存储器是没有值的。

每递归调用一次，栈的深度就增加一层，每次调用都会分配对应的参数和局部变量，也都会保存调用的返回地址。

递归函数的执行过程，函数代码虽然只有一份，但在执行的过程中，每调用一次，就会有一次入栈，生成一份不同的参数、局部变量和返回地址。

小结

函数调用主要是通过栈来存储相关的数据，系统就函数调用者和函数如何使用栈做了约定，返回值可以简单认为是通过一个专门的返回值存储器存储的。

从函数调用的过程可以看出，调用是有成本的，每一次调用都需要分配额外的栈空间用于存储参数、局部变量以及返回地址，需要进行额外的入栈和出栈操作。

栈的空间不是无限的，如果栈空间过深，系统就会抛出错误java.lang.StackOverflowError，即栈溢出。

2 理解数据背后的二进制

2.1 整数的二进制表示与位运算

123 十进制表示 1× (10^2)+2× (10^1)+3× (10^0)

==位权==

正整数的二进制表示

负整数的二进制表示

二进制使用最高位表示符号位，用1表示负数，用0表示正数。

原码表示法

但负数表示不是简单地将最高位变为1，而是用补码表示法，是在原码表示的基础上取反然后加1。

• -1: 1的原码表示是00000001，取反是11111110，然后再加1，就是11111111。
• -2: 2的原码表示是00000010，取反是11111101，然后再加1，就是11111110。
• -127: 127的原码表示是01111111，取反是10000000，然后再加1，就是10000001。

给定一个负数的二进制表示，要得到它的十进制，也可以使用补码运行，取反然后加1（注意不是减1），比如：

• 100100101 ，取反是01101101，加1是01101110，就是十进制110(2^6+2^5+2^3+2^2+2)，所以原值的十进制表示就是-110。

负整数为什么要采用这种奇怪的表示形式呢？

原因是，只有这种形式，计算机才能实现正确的加减法。

计算机只能做加法，而补码的一个良好特性就是，对负数的补码表示做补码运算就可以得到其对应正数的原码。

1-1其实是1+(-1)，如果用原码表示，结果就不对了：

1
2
3
4

1   ->  00000001
-1  ->  10000001
+   --------------
-2  ->  10000010   

结果就是-2了，补码表示：

1
2
3
4

1   ->  00000001
-1  ->  11111111
+   --------------
0   ->  00000000   

结果就是0，对的。

为什么正数的运算结果可能出现负数？

当计算结果超出表示范围的时候，最高位往往是1，然后就会被看作负数。

十六进制

用十六进制简化二进制的写法。

位运算

位运算有移位运算和逻辑运算。

移位以下几种：

1. <<：向左移动，右边的低位补0，高位的就舍弃掉了，将二进制看作整数，左移1位就相当于乘以2。
2. >>>：无符号右移，右边的舍弃掉，左边补0。
3. >>：有符号右移，右边的舍弃掉，左边补什么取决于原来最高位是什么，原来是1就补1，原来是0就补0，将二进制看作整数，右移1位相当于除以2。

逻辑运算：

1. 按位与&：两位都为1才为1。
2. 按位或|：只要有一位为1，就为1。
3. 按位取反~:1变为0,0变为1。、
4. 按位异或^：相异为真，相同为假。

1
2
3

        int a = …;
        a = a & 0x1 	//返回0或1，就是a最右边一位的值
        a   = a | 0x1 //不管a原来最右边一位是什么，都将设为1

2.2 小数的二进制表示

小数计算为什么会出错

计算机根本就不能精确地表示很多数。

十进制也只能表示那些可以表述为10的多少次方和的数。如如12.345 = 1× 10+2× 1+3× 0.1+4× 0.01+5× 0.001。

二进制只能表示那些可以表述为2的多少次方和的数。

为什么计算机使用二进制而不是十进制？

在最底层，计算机使用的电子元器件只能表示两个状态，通常是低压和高压，对应0和1，使用二进制容易基于这些电子元器件构建硬件设备和进行运算。如果非要使用十进制，则这些硬件就会复杂很多，并且效率低下。

在误差足够小的时候，结果看上去是精确的，但不精确其实才是常态。

如果真的需要比较高的精度，一种方法是将小数转化为整数进行运算，运算结束后再转化为小数；另一种方法是使用十进制的数据类型，这个并没有统一的规范。在Java中是BigDecimal，运算更准确，但效率比较低。

二进制表示

小数运算被称为==浮点运算==。

为什么要叫浮点数呢？

这是由于小数的二进制表示中，表示那个小数点的时候，点不是固定的，而是浮动的。

二进制中为表示小数，也采用类似的科学表示法，形如m×(2^e)。m称为尾数，e称为指数。指数可以为正，也可以为负，负的指数表示那些接近0的比较小的数。

几乎所有的硬件和编程语言表示小数的二进制格式都是一样的，叫做==IEEE 754标准==。

32位格式(float)中，1位表示符号，23位表示尾数，8位表示指数。64位格式(double)中，1位表示符号，52位表示尾数，11位表示指数。

查看浮点数的具体二进制形式：

1
2

System.out.println(Integer.toBinaryString(Float.floatToIntBits(1.2345f)));
System.out.println(Long.toBinaryString(Double.doubleToLongBits(1.2345f)));

1
2

111111100111100000010000011001
11111111110011110000001000001100100000000000000000000000000000

2.3 字符的编码与乱码

编码分两大类：非Unicode编码，Unicode编码。

常见非Unicode编码

1 ASCII

ASCII编码，全称是American Standard Codefor InformationInterchange，即美国信息互换标准代码。

一个字节表示一个字符，ASCII码中最高位设置为0，用剩下的7位表示字符。

数字32～126表示的字符都是可打印字符，0～31和127表示一些不可以打印的字符，这些字符一般用于控制目的。

各个国家的各种计算机厂商就发明了各种各种的编码方式以表示自己国家的字符，为了保持与ASCII码的兼容性，一般都是将最高位设置为1。也就是说，当最高位为0时，表示ASCII码，当为1时就是各个国家自己的字符。

2 ISO 8859-1(Latin-1)

一个字节表示一个字符。其中0～127与ASCII一样，128～159表示一些控制字符，160～255表示一些西欧字符。

3 Windows-1252

与ISO 8859-1标准类似。区别只在于数字128～159。Windows-1252使用其中的一些数字表示可打印字符。

基本上可以认为，ISO 8859-1已被Windows-1252取代。

HTML5甚至明确规定，如果文件声明的是ISO 8859-1编码，它应该被看作Win-dows-1252编码。

4 GB2312

针对简体中文常见字符，包括约7000个汉字和一些罕用词和繁体字。

GB2312==固定==使用**==两个字节==**表示汉字，在这两个字节中，最高位都是1，如果是0，就认为是ASCII字符。在这两个字节中，其中高位字节范围是0xA1（1010 0001）～0xF7（1111 0111），低位字节范围是0xA1～0xFE（1111 1110）。

5 GBK

GBK建立在GB2312的基础上，向下兼容GB2312，也就是说，GB2312编码的字符和二进制表示，在GBK编码里是完全一样的。GBK增加了14 000多个汉字，共计约21 000个汉字，其中包括繁体字。也是==固定两个字节==表示汉字。

GBK同样使用固定的两个字节表示，其中高位字节范围是0x81～0xFE，低位字节范围是0x40～0x7E和0x80～0xFE。需要注意的是，低位字节是从0x40（也就是64）开始的，也就是说，低位字节的最高位可能为0。那怎么知道它是汉字的一部分，还是一个ASCII字符呢？其实很简单，因为汉字是用固定两个字节表示的，在解析二进制流的时候，如果第一个字节的最高位为1，那么就将下一个字节读进来一起解析为一个汉字，而不用考虑它的最高位，解析完后，跳到第三个字节继续解析。

6 GB18030

GB18030向下兼容GBK，增加了55 000多个字符，共76 000多个字符，包括了很多少数民族字符，以及中日韩统一字符。

用两个字节已经表示不了GB18030中的所有字符，GB18030使用变长编码，==有的字符是两个字节，有的是四个字节==。在两字节编码中，字节表示范围与GBK一样。在四字节编码中，第一个字节的值为0x81～0xFE，第二个字节的值为0x30～0x39，第三个字节的值为0x81～0xFE，第四个字节的值为0x30～0x39。

解析二进制时，如何知道是两个字节还是4个字节表示一个字符呢？看第二个字节的范围，如果是0x30～0x39就是4个字节表示，因为两个字节编码中第二个字节都比这个大。

7 Big5

主要香港、台湾地区使用，针对繁体中文。固定两个字节表示汉字。

8 编码汇总

ASCII码是基础，使用一个字节表示，最高位设为0，其他7位表示128个字符。其他编码都是兼容ASCII的，最高位使用1来进行区分。

西欧主要使用Windows-1252，使用一个字节，增加了额外128个字符。

我国内地的三个主要编码GB2312、GBK、GB18030有时间先后关系，表示的字符数越来越多，且后面的兼容前面的，GB2312和GBK都是用两个字节表示，而GB18030则使用两个或四个字节表示。

我国香港特别行政区和我国台湾地区的主要编码是Big5。

如果文本里的字符都是ASCII码字符，那么采用以上所说的任一编码方式都是一样的。但如果有高位为1的字符，除了GB2312、GBK、GB18030外，其他编码都是不兼容的。比如，Windows-1252和中文的各种编码是不兼容的，即使Big5和GB18030都能表示繁体字，其表示方式也是不一样的，而这就会出现所谓的乱码，

Unicode编码

Unicode 做了一件事，就是给世界上所有字符都分配了一个唯一的数字编号，这个编号范围从0x000000～0x10FFFF，包括110多万(16^4 - 1 + 16^5 = 1114111)。但大部分常用字符都在0x0000～0xFFFF之间，即65536个数字之内。

一般写成十六进制，在前面加U+。大部分中文的编号范围为U+4E00～U+9FFF。

上面的几种编码既规定了能表示哪些字符，又规定了每个字符对应的二进制是什么。但是Unicode并没有规定这个编号怎么对应到二进制表示，有几种方案：

1 UTF-32

这个最简单，就是字符编号的整数二进制形式，4个字节。

但有个细节，就是字节的排列顺序，如果第一个字节是整数二进制中的最高位，最后一个字节是整数二进制中的最低位，那这种字节序就叫==“大端”（Big Endian,BE）==，否则，就叫==“小端”（Little Endian, LE）==。对应的编码方式分别是==UTF-32BE==和==UTF-32LE==。

每个字符都用4个字节表示，非常浪费空间，实际采用的也比较少。

2 UTF-16

UTF-16使用变长字节表示：

• 对于编号在U+0000～U+FFFF的字符（常用字符集），直接用两个字节表示。需要说明的是，U+D800～U+DBFF的编号其实是没有定义的。
• 字符值在U+10000～U+10FFFF的字符（也叫做增补字符集），需要用4个字节表示。前两个字节叫高代理项，范围是U+D800～U+DBFF；后两个字节叫低代理项，范围是U+DC00～U+DFFF。数字编号和这个二进制表示之间有一个转换算法，本书就不介绍了。

区分是两个字节还是4个字节表示一个字符就看前两个字节的编号范围，如果是U+D800～U+DBFF，就是4个字节，否则就是两个字节。

UTF-16也有和UTF-32一样的字节序问题，如果高位存放在前面就叫大端（BE），编码就叫UTF-16BE，否则就叫小端，编码就叫UTF-16LE。

UTF-16常用于系统内部编码，UTF-16比UTF-32节省了很多空间，但是任何一个字符都至少需要两个字节表示，对于美国和西欧国家而言，还是很浪费的。

3 UTF-8

UTF-8使用变长字节表示，每个字符使用的字节个数与其Unicode编号的大小有关，编号小的使用的字节就少，编号大的使用的字节就多，使用的字节个数为1～4不等。

小于128的，编码与ASCII码一样，最高位为0。其他编号的第一个字节有特殊含义，最高位有几个连续的1就表示用几个字节表示，而其他字节都以10开头。

对于一个Unicode编号，具体怎么编码呢？

首先将其看作整数，转化为二进制形式（去掉高位的0），然后将二进制位从右向左依次填入对应的二进制格式x中，填完后，如果对应的二进制格式还有没填的x，则设为0。

例子，“马”的Unicode编号是0x9A6C，整数编号是39 532，其对应的UTF-8二进制格式是：

1110xxxx 10xxxxxx 10xxxxxx

整数编号39 532的二进制格式是：

1001 101001 101100

将这个二进制位从右到左依次填入二进制格式中，结果就是其UTF-8编码：

11101001 10101001 10101100

十六进制表示为0xE9A9AC。

和UTF-32/UTF-16不同，UTF-8是兼容ASCII的，对大部分中文而言，一个中文字符需要用三个字节表示。

4 Unicode编码小结

Unicode给世界上所有字符都规定了一个统一的编号，编号范围达到110多万，但大部分字符都在65 536以内。Unicode本身没有规定怎么把这个编号对应到二进制形式。

UTF-32/UTF-16/UTF-8都在做一件事，就是把Unicode编号对应到二进制形式，其对应方法不同而已。UTF-32使用4个字节，UTF-16大部分是两个字节，少部分是4个字节，它们都不兼容ASCII编码，都有字节顺序的问题。UTF-8使用1～4个字节表示，兼容ASCII编码，英文字符使用1个字节，中文字符大多用3个字节。

编码转换

有了Unicode之后，每一个字符就有了多种不兼容的编码方式，如：

这几种格式之间可以借助Unicode编号进行编码转换。可以认为：每种编码都有一个映射表，存储其特有的字符编码和Unicode编号之间的对应关系，这个映射表是一个简化的说法，实际上可能是一个映射或转换方法。

编码转换的具体过程可以是：一个字符从A编码转到B编码，先找到字符的A编码格式，通过A的映射表找到其Unicode编号，然后通过Unicode编号再查B的映射表，找到字符的B编码格式。

举例来说，“马”从GB18030转到UTF-8，先查GB18030->Unicode编号表，得到其编号是9A 6C，然后查Uncode编号->UTF-8表，得到其UTF-8编码：E9 A9AC。

编码转换改变了字符的二进制内容，但并没有改变字符看上去的样子。

乱码的原因

乱码有两种常见原因：一种比较简单，就是简单的解析错误；另外一种比较复杂，在错误解析的基础上进行了编码转换。

1 解析错误

看个简单的例子。一个法国人采用Windows-1252编码写了个文件，发送给了一个中国人，中国人使用GB18030来解析这个字符，看到的可能就是乱码。比如，法国人发送的是Pékin, Windows-1252的二进制（采用十六进制）是50 E9 6B 69 6E，第二个字节E9对应é，其他都是ASCII码，中国人收到的也是这个二进制，但是他把它看成了GB18030编码，GB18030中E9 6B对应的是字符“閗”，于是他看到的就是“P閗in”，这看来就是一个乱码。

反之也是一样的，一个GB18030编码的文件如果被看作Windows-1252也是乱码。

这种情况下，之所以看起来是乱码，是因为==看待或者说解析数据的方式错了==。只要使用正确的编码方式进行解读就可以纠正了。很多文件编辑器，如EditPlus、NotePad++、UltraEdit都有切换查看编码方式的功能，浏览器也都有切换查看编码方式的功能，如Fire-fox，在菜单“查看”→“文字编码”中即可找到该功能。

切换查看编码的方式并没有改变数据的二进制本身，而只是改变了解析数据的方式，从而改变了数据看起来的样子，这与前面提到的编码转换正好相反。很多时候，做这样一个编码查看方式的切换就可以解决乱码的问题，但有的时候这样是不够的。

2 错误的解析和编码转换

如果怎么改变查看方式都不对，那很有可能就不仅仅是解析二进制的方式不对，而是文本在错误解析的基础上还进行了编码转换。我们举个例子来说明：

• 两个字“老马”，本来的编码格式是GB18030，编码（十六进制）是C0 CF C2ED。
• 这个二进制形式被错误当成了Windows-1252编码，解读成了字符“ÀÏÂí”。
• 随后这个字符进行了编码转换，转换成了UTF-8编码，形式还是“ÀÏÂí”，但二进制变成了C3 80 C3 8F C3 82 C3 AD，每个字符两个字节。
• 这个时候再按照GB18030解析，字符就变成了乱码形式“脌脧脗铆”，而且这时无论怎么切换查看编码的方式，这个二进制看起来都是乱码。

🔖

从乱码中恢复🔖

2.4 char的真正含义🔖

Java内部字符处理，采用的都是Unicode，具体编码格式是UTF-16BE。

char本质上是一个固定占用两个字节的无符号正整数，这个正整数对应于Unicode编号，用于表示那个Unicode编号对应的字符。由于固定占用两个字节，char只能表示Unicode编号在65 536以内的字符，而不能表示超出范围的字符。

超出范围的字符怎么表示呢？使用两个char。

char多种赋值方式：

1
2
3
4
5

  1. char c = 'A'
  2. char c = '马'
  3. char c = 39532
  4. char c = 0x9a6c
  5. char c = '\u9a6c'

本质都是将Unicode编号39 532赋给了字符。

由于char本质上是一个整数，所以可以进行整数能做的一些运算。

二、面向对象

3 类的基础

程序主要就是数据以及对数据的操作，为方便理解和操作，高级语言使用了数据类型这个概念。

3.1 类的基础概念

某些情况下，类也确实只是函数的容器，但类更多表示的是自定义数据类型。

函数容器

Math

Arrays

static表示==类方法==，也叫静态方法，与类方法相对的是==实例方法==。实例方法没有static修饰符，必须通过实例或者对象调用，而类方法可以直接通过类名进行调用，不需要创建实例。

通过private封装和隐藏内部实现细节，避免被误操作，是计算机程序的一种基本思维方式。

Math和Arrays也可以看作自定义数据类型，分别表示数学和数组类型，其中的public static函数可以看作类型能进行的操作。

自定义数据类型

一个数据类型由其包含的属性以及该类型可以进行的操作组成，属性又可以分为是类型本身具有的属性（==类变量== 或叫 静态变量 或叫 静态成员变量），还是一个具体实例具有的属性（==实例变量==），同样，操作也可以分为是类型本身可以进行的操作（==类方法==/静态方法），还是一个具体实例可以进行的操作（==实例方法==）。

类变量和实例变量都叫**==成员变量==**；类方法和实例方法都叫==成员方法==。

实例方法中，有一个隐含的参数，这个参数就是当前操作的实例自己，直接操作实例变量，实际也需要通过参数进行。

实例方法和类方法的区别：

1. 类方法只能访问类变量，不能访问实例变量，可以调用其他的类方法，不能调用实例方法。
2. 实例方法既能访问实例变量，也能访问类变量，既可以调用实例方法，也可以调用类方法。

final在修饰变量的时候表示常量。

==引用类型==的变量都有两块内存：一块存放实际内容，一块存放实际内容的位置。声明变量本身只会分配存放位置的内存空间，这块空间还没有指向任何实际内容。

通过对象来访问和操作其内部的数据是一种基本的面向对象思维。

变量默认值

在创建对象的时候，所有的实例变量都会分配一个默认值，这与创建数组的时候是类似的，数值类型变量的默认值是0, boolean是false, char是\u0000，引用类型变量都是null。

初始化代码块。

静态初始化代码块，类加载时只执行一次。

private变量

一般而言，不应该将实例变量声明为public，而只应该通过对象的方法对实例变量进行操作。这也是为了减少误操作，直接访问变量没有办法进行参数检查和控制，而通过方法修改，可以在方法中进行检查。

构造方法

1. 名称是固定的，与类名相同。
2. 没有返回值，也不能有返回值。构造方法隐含的返回值就是实例本身。

1
2
3
4
5
6
7
8

        public Point(){
            this(0,0);
          	....
        }
        public Point(int x, int y){
              this.x = x;
              this.y = y;
        }

this的两个用法：this(0,0)表示调用其它构造方法；this.x表示当前实例。

构造方法中的this调用必须放在第一行，这个规定也是为了避免误操作。构造方法是用于初始化对象的，如果要调用别的构造方法，先调别的，然后根据情况自己再做调整，而如果自己先初始化了一部分，再调别的，自己的修改可能就被覆盖了。

默认构造方法

私有构造方法

使用场景：

1. 不能创建类的实例，类只能被静态访问，如Math和Arrays类。
2. 能创建类的实例，但只能被类的静态方法调用，如单例模式。
3. 只是用来被其他多个构造方法调用，用于减少重复代码。

类和对象的生命周期

在程序运行的时候，当第一次通过new创建一个类的对象时，或者直接通过类名访问类变量和类方法时，Java会将类加载进内存，为这个类分配一块空间，这个空间会包括类的定义、它的变量和方法信息，同时还有类的静态变量，并对静态变量赋初始值。

类加载进内存后，一般不会释放，直到程序结束。一般情况下，类只会加载一次，所以静态变量在内存中只有一份。

当通过new创建一个对象的时候，对象产生，在内存中，会存储这个对象的实例变量值，每做new操作一次，就会产生一个对象，就会有一份独立的实例变量。

每个对象除了保存实例变量的值外，可以理解为还保存着对应类型即类的地址，这样，通过对象能知道它的类，访问到类的变量和方法代码。

实例方法可以理解为一个静态方法，只是多了一个参数this。通过对象调用方法，可以理解为就是调用这个静态方法，并将对象作为参数传给this。

对象和数组一样，有两块内存，保存地址的部分分配在栈中，而保存实际内容的部分分配在堆中。栈中的内存是自动管理的，函数调用入栈就会分配，而出栈就会释放。

总结

1. public：可以修饰类、类方法、类变量、实例变量、实例方法、构造方法，表示可被外部访问。
2. private：可以修饰类、类方法、类变量、实例变量、实例方法、构造方法，表示不可以被外部访问，只能在类内部被使用。
3. static：修饰类变量和类方法，它也可以修饰内部类。
4. this：表示当前实例，可以用于调用其他构造方法，访问实例变量，访问实例方法。
5. final：修饰类变量、实例变量，表示只能被赋值一次，也可以修饰实例方法和局部变量。

3.2 类的组合

程序是用来解决现实问题的，将现实中的概念映射为程序中的概念，是初学编程过程中的一步跨越。

String和Date

String表示多个字符，即一段文本或字符串，它内部是一个char的数组，提供了若干方法用于操作字符串。

Date表示日期和时间，它内部是一个long类型的值。

图形类

在设计线时，我们考虑的层次是点，而不考虑点的内部细节。每个类封装其内部细节，对外提供高层次的功能，使其他类在更高层次上考虑和解决问题，是程序设计的一种基本思维方式。

1
2
3
4
5
6

    public static void main(String[] args) {
        Point start = new Point(2, 3);
        Point end = new Point(5, 9);
        Line line = new Line(start, end);
        System.out.println(line.length());
    }

start、end、line三个引用型变量分配在栈中，保存的是实际内容的地址，实际内容保存在堆中，line的两个实例变量line.start和line.end还是引用，同样保存的是实际内容的地址。

用类描述电商概念

电商系统中最基本的有产品、用户和订单。

• 产品：有产品唯一id、名称、描述、图片、价格等属性。
• 用户：有用户名、密码等属性。
• 订单：有订单号、下单用户、选购产品列表及数量、下单时间、收货人、收货地址、联系电话、订单状态等属性。

想想现实问题有哪些==概念==，这些概念有哪些==属性==、哪些==行为==，概念之间有什么关系，然后定义类、定义属性、定义方法、定义类之间的关系。概念的属性和行为可能是非常多的，但定义的类只需要包括那些与现实问题相关的就行了。

用类描述人之间的血缘关系

一个类定义中还可以引用它自己。

目录和文件

两个类之间可以互相引用，MyFile引用了MyFolder，而MyFolder也引用了MyFile。

类中应该定义哪些变量和方法，这是与要解决的问题密切相关的。

类之间的组合关系在Java中实现的都是**==引用==，但在逻辑关系上，有两种明显不同的关系，一种是==包含==，另一种是==单纯引用==**。比如，在订单类Order中，Order与User的关系就是单纯引用，User是独立存在的；而Order与OrderItem的关系就是包含，OrderItem总是从属于某一个Order。

分解现实问题中涉及的概念以及概念间的关系，将概念表示为多个类，通过类之间的组合来表达更为复杂的概念以及概念间的关系，是计算机程序的一种基本思维方式。

3.3 代码的组织机制

使用任何语言进行编程都有一个类似的问题，那就是**==如何组织代码？==** 具体就是：如何避免命名冲突？如何合理组织各种源文件？如何使用第三方库？各种代码和依赖库如何编译链接为一个完整的程序？

包的概念

完全限定名：带完整包名的类名。

Java API中所有的类和接口都位于包java或javax下，java是标准包，javax是扩展包。

1. ==声明==类所在的包

包声明语句应该位于源代码的最前面，前面不能有注释外的其他语句。

包名和文件目录结构必须匹配。

如果代码需要公开给其他人用，最好有一个域名以确保唯一性。

包可以方便模块化开发，不同功能可以位于不同包内，不同开发人员负责不同的包。包也可以方便封装，供外部使用的类可以放在包的上层，而内部的实现细节则可以放在比较底层的子包内。

2. 通过包==使用==类

同一个包下的类之间互相引用是不需要包名的。不同包，两种方式使用：一种是通过类的完全限定名；另外一种是将用到的类引入当前类。

只有一个例外，==java.lang包下的类可以直接使用，不需要引入==，也不需要使用完全限定名，比如String类、System类，其他包内的类则不行。

import java.util.*，引入不能递归，它只会引入java.util包下的直接类，而不会引入java.util下嵌套包内的类。

==静态导入==：可以直接导入类的公开静态方法和成员。静态导入不应过度使用，否则难以区分访问的是哪个类的代码。

1
2
3
4
5

import static java.util.Arrays.*;
import static java.lang.System.out;

sort(arr);
out.println(...)

3. 包范围可见性

同一个包指的是同一个直接包，子包下的类并不能访问。

可见性范围从小到大是：private < 默认(包) < protected < public

jar包

各种程序语言大多有打包的概念，打包的一般不是源代码，而是编译后的代码。

在Java中，编译后的一个或多个包的Java class文件可以打包为一个文件，Java中打包命令为jar，打包后的文件扩展名为.jar，一般称之为jar包。jar包其实就是一个压缩文件。

jar -cvf <包名>.jar <最上层包名>

Java类库、第三方类库都是以jar包形式提供的。如何使用jar包呢？将其加入**类路径（classpath）**中即可。

程序的编译与链接

从Java源代码到运行的程序，有编译和链接两个步骤。编译是将源代码文件变成扩展名是.class的一种字节码，这个工作一般是由javac命令完成的。链接是在运行时动态执行的，.class文件不能直接运行，运行的是Java虚拟机，虚拟机听起来比较抽象，执行的就是java命令，这个命令解析.class文件，转换为机器能识别的二进制代码，然后运行。所谓链接就是**==根据引用到的类加载相应的字节码并执行==**。

Java编译和运行时，都需要以参数指定一个classpath，即类路径。类路径可以有多个，对于直接的class文件，路径是class文件的根目录；对于jar包，路径是jar包的完整名称（包括路径和jar包名）。在Windows系统中，多个路径用分号“; ”分隔；在其他系统中，以冒号“:”分隔。

import是编译时概念，用于确定完全限定名，在运行时，只根据完全限定名寻找并加载类。

🔖在Java 9中，引入了模块的概念，JDK和JRE都按模块化进行了重构，传统的组织机制依然是支持的，但新的应用可以使用模块。一个应用可由多个模块组成，一个模块可由多个包组成。模块之间可以有一定的依赖关系，一个模块可以导出包给其他模块用，可以提供服务给其他模块用，也可以使用其他模块提供的包，调用其他模块提供的服务。对于复杂的应用，模块化有很多好处，比如更强的封装、更为可靠的配置、更为松散的耦合、更动态灵活等。

4 类的继承

现实中的概念有个重要关系：分类。

计算机程序经常使用类之间的继承关系来表示对象之间的分类关系。

使用继承一方面可以复用代码，公共的属性和行为可以放到父类中，而子类只需要关注子类特有的就可以了；另一方面，不同子类的对象可以更为方便地被统一处理。

4.1 基本概念

根父类Object：在Java中，即使没有声明父类，也有一个隐含的父类。

每个类有且只有一个父类，没有声明父类的，其父类为Object，子类继承了父类非private的属性和方法，可以增加自己的属性和方法，以及重写父类的方法实现。

new过程中，父类先进行初始化，可通过super调用父类相应的构造方法，没有使用super的情况下，调用父类的默认构造方法（super必须放在第一行）。

子类变量和方法与父类重名的情况下，可通过super强制访问父类的变量和方法。

super的使用与this有点像，但super和this是不同的，this引用一个对象，是实实在在存在的，可以作为函数参数，可以作为返回值，但super只是一个关键字，不能作为参数和返回值，它只是用于告诉编译器访问父类的相关变量和方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class ShapeManager {
    private static final int MAX_NUM = 100;
    private Shape[] shapes = new Shape[MAX_NUM];
    private int shapeNum = 0;

    public void addShape(Shape shape) {
        if (shapeNum < MAX_NUM) {
            shapes[shapeNum++] = shape;
        }
    }

    public void draw() {
        for (int i = 0; i < shapeNum; i++) {
            shapes[i].draw();
        }
    }

    public static void main(String[] args) {
        ShapeManager shapeManager = new ShapeManager();
        shapeManager.addShape(new Line(new Point(1, 2), new Point(3, 5), "red"));
        shapeManager.addShape(new Circle(new Point(5, 9), 2));
        shapeManager.addShape(new ArrowLine(new Point(6, 7), new Point(8, 11), "blue", true, false));

        shapeManager.draw();
    }
}

继承的一个好处是可以统一处理不同子类型的对象。

子类对象赋值给父类引用变量，这叫向上转型。

参数Shape shape中的变量shape可以引用任何Shape子类类型的对象，这叫多态，即一种类型的变量，可引用多种实际类型对象。

这样，对于变量shape，它就有两个类型：类型Shape，我们称之为shape的**==静态类型==；类型Circle/Line/ArrowLine，我们称之为shape的==动态类型==。在ShapeManager的draw方法中，shapes[i].draw()调用的是其对应动态类型的draw方法，这称之为方法的==动态绑定==**。

为什么要有多态和动态绑定呢？

创建对象的代码（ShapeManager以外的代码）和操作对象的代码（ShapeManager本身的代码），经常不在一起，操作对象的代码往往只知道对象是某种父类型，也往往只需要知道它是某种父类型就可以了。

多态和动态绑定是计算机程序的一种重要思维方式，使得操作对象的程序不需要关注对象的实际类型，从而可以统一处理不同对象，但又能实现每个对象的特有行为。

总结：子类对象可以赋值给父类引用变量，这叫==多态==；实际执行调用的是子类实现，这叫动态绑定。

4.2 继承的细节

构造方法

父类只有一个带参数的构造方法，没有默认构造方法的时候，它的任何子类都必须在构造方法中通过super调用父类的带参数构造方法。

在父类构造方法中调用可被子类重写的方法，是一种不好的实践，容易引起混淆，应该只调用private的方法。

重名与静态绑定

子类与父类中实例变量、静态方法和静态变量可以重名吗？如果重名，访问的是哪一个呢？

重名是可以的，重名后实际上有两个变量或方法。private变量和方法只能在类内访问，访问的也永远是当前类的，即：在子类中访问的是子类的；在父类中访问的是父类的，它们只是碰巧名字一样而已，没有任何关系。

public变量和方法，则要看如何访问它。在类内，访问的是当前类的，但子类可以通过super．明确指定访问父类的。在类外，则要看访问变量的静态类型：静态类型是父类，则访问父类的变量和方法；静态类型是子类，则访问的是子类的变量和方法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

public class Base {
    public static String s = "static_base";
    public String m = "base";
    public static void staticTest(){
        System.out.println("base static: "+s);
    }
}
public class Child extends Base {
    public static String s = "child_base";
    public String m = "child";
    public static void staticTest(){
        System.out.println("child static: "+s);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

    public static void main(String[] args) {
        Child c = new Child();
        Base b = c;
        System.out.println(b.s);
        System.out.println(b.m);
        b.staticTest();
        System.out.println(c.s);
        System.out.println(c.m);
        c.staticTest()
    }

结果为

        static_base
        base
        base static: static_base
        child_base
        child
        child static: child_base

当通过b（静态类型Base）访问时，访问的是Base的变量和方法，当通过c（静态类型Child）访问时，访问的是Child的变量和方法，这称之为**==静态绑定==**，即访问绑定到变量的静态类型。静态绑定在程序编译阶段即可决定，而动态绑定则要等到程序运行时。实例变量、静态变量、静态方法、private方法，都是静态绑定的。🔖

重载和重写

重载是指方法名称相同但==参数签名==不同（参数==个数、类型或顺序==不同），重写是指子类重写与父类相同参数签名的方法。

当有多个重名函数的时候，在决定要调用哪个函数的过程中，首先是按照参数类型进行匹配的，换句话说，寻找在所有重载版本中最匹配的，然后才看变量的动态类型，进行动态绑定。

父子类型转换

1
2

Base b = new Base();
Child c = (Child)b;

语法上Java不会报错，但运行时会抛出错误，错误为类型转换异常。

一个父类的变量能不能转换为一个子类的变量，取决于这个父类变量的动态类型（即引用的对象类型）是不是这个子类或这个子类的子类。

可通过instanceof来判断一个父类的变量是不是某个子类的对象：

1
2
3

public boolean canCast(Base b) {
  return b instanceof Child;
}

继承访问权限protected

protected表示虽然不能被外部任意访问，但可被子类访问。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

public class Base {
    protected int currentStep;
    protected void step1() {}
    protected void step2() {}

    public void action() {
        this.currentStep = 1;
        step1();
        this.currentStep = 2;
        step2();
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Child extends Base {
    protected void step1() {
        System.out.println("child step " + this.currentStep);
    }
    protected void step2() {
        System.out.println("child step " + this.currentStep);
    }

    public static void main(String[] args) {
        Child c = new Child();
        c.action();
    }
}

基类定义了表示对外行为的方法action，并定义了可以被子类重写的两个步骤step1()和step2()，以及被子类查看的变量currentStep，子类通过重写protected方法step1()和step2()来修改对外的行为。

这种思路和设计是一种设计模式，称之为==模板方法==。action方法就是一个模板方法，它定义了实现的模板，而具体实现则由子类提供。模板方法在很多框架中有广泛的应用，这是使用protected的一种常见场景。

可见性重写

重写方法时，一般并不会修改方法的可见性；如果要修改，子类方法不能降低父类方法的可见性。

为什么要这样规定呢？

继承反映的是“is-a”的关系，即子类对象也属于父类，子类必须支持父类所有对外的行为，将可见性降低就会减少子类对外的行为，从而破坏“is-a”的关系，但子类可以增加父类的行为，所以提升可见性是没有问题的。

防止继承final

一个Java类，默认情况下都是可以被继承的，但加了final关键字之后就不能被继承了。另外final实例方法不能被重写。

4.3 继承实现的基本原理

示例

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

public class Base {
    public static int s;
    private int a;
    static {
        System.out.println("基类静态代码块，s：" + s);
        s = 1;
    }
    {
        System.out.println("基类实例代码块，a：" + a);
        a = 1;
    }

    public Base() {
        System.out.println("基类构造方法，a：" + a);
        a = 2;
    }

    protected void step() {
        System.out.println("base s: " + s + ", a:" + a);
    }

    public void action() {
        System.out.println("start");
        step();
        System.out.println("end");
    }
}


public class Child extends Base {
    public static int s;
    private int a;
    static {
        System.out.println("子类静态代码块，s：" + s);
        s = 10;
    }
    {
        System.out.println("子类实例代码块，a：" + a);
        a = 10;
    }

    public Child() {
        System.out.println("子类构造方法，a：" + a);
        a = 20;
    }

    protected void step() {
        System.out.println("child s: " + s + ", a:" + a);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

    public static void main(String[] args) {
        System.out.println("---- new Child()");
        Child c = new Child();
        System.out.println("\n---- c.action()");
        c.action();
        Base b = c;
        System.out.println("\n---- b.action()");
        b.action();
        System.out.println("\n---- b.s: " + b.s);
        System.out.println("\n---- c.s: " + c.s);
    }

结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

基类静态代码块，s：0
---- new Child()
子类静态代码块，s：0
基类实例代码块，a：0
基类构造方法，a：1
子类实例代码块，a：0
子类构造方法，a：10

---- c.action()
start
child s: 10, a:20
end

---- b.action()
start
child s: 10, a:20
end

---- b.s: 1

---- c.s: 10

类加载过程❤️

Java中，所谓类的加载是指将类的相关信息加载到内存。在Java中，类是动态加载的，当第一次使用这个类的时候才会加载，加载一个类时，会查看其父类是否已加载，如果没有，则会加载其父类。

1. 一个类的信息主要包括以下部分：
   • 类变量（静态变量）；
   • 类初始化代码；
   • 类方法（静态方法）；
   • 实例变量；
   • 实例初始化代码；
   • 实例方法；
   • 父类信息引用
2. 类初始化代码包括：
   • 定义静态变量时的赋值语句；
   • 静态初始化代码块。
3. 实例初始化代码包括：
   • 定义实例变量时的赋值语句；
   • 实例初始化代码块；
   • 构造方法。
4. 类加载过程包括：
   • 分配内存保存类的信息；
   • 给类变量赋默认值；
   • 加载父类；
   • 设置父子关系；
   • 执行类初始化代码。

栈存放函数的局部变量；而堆存放动态分配的对象，存放类的信息，这个区在Java中称为方法区。

上面的示例，加载后，Java方法区有3份类信息，分别是Child、Base、Object。

用class_init()来表示类初始化代码；用instance_init()表示实例初始化代码（实例初始化代码块和构造方法），例子中只有一个构造方法，实际情况则可能有多个实例初始化方法。

对象创建的过程

在类加载之后，new Child()就是创建Child对象，创建对象过程包括：

1. 分配内存；
2. 对所有实例变量赋默认值；
3. 执行实例初始化代码。

分配的内存包括本类和所有父类的实例变量，但不包括任何静态变量。实例初始化代码的执行从父类开始，再执行子类的。但在任何类执行初始化代码之前，所有实例变量都已设置完默认值。

每个对象除了保存类的实例变量之外，还保存着实际类信息的引用。

Child c = new Child();会将新创建的Child对象引用赋给变量c，而Base b = c;会让b也引用这个Child对象。

引用型变量c和b分配在栈中，它们指向相同的堆中的Child对象。Child对象存储着方法区中Child类型的地址，还有Base中的实例变量a和Child中的实例变量a

方法调用的过程

c.action(); 执行过程：

1. 查看c的对象类型，找到Child类型，在Child类型中找action方法，发现没有，到父类中寻找；
2. 在父类Base中找到了方法action，开始执行action方法；
3. action先输出了start，然后发现需要调用step()方法，就从Child类型开始寻找step()方法；
4. 在Child类型中找到了step()方法，执行Child中的step()方法，执行完后返回action方法；
5. 继续执行action方法，输出end。

寻找要执行的实例方法的时候，是从对象的实际类型信息开始查找的，找不到的时候，再查找父类类型信息。

b.action()和c.action()的输出是一样的，这称为动态绑定，而动态绑定实现的机制就是根据对象的实际类型查找要执行的方法，子类型中找不到的时候再查找父类。

如果继承的层次比较深，要调用的方法位于比较上层的父类，则调用的效率是比较低的，因为每次调用都要进行很多次查找。大多数系统使用一种称为虚方法表的方法来优化调用的效率。

==虚方法表==，就是在类加载的时候为每个类创建一个表，记录该类的对象所有动态绑定的方法（包括父类的方法）及其地址，但一个方法只有一条记录，子类重写了父类方法后只会保留子类的。

变量访问的过程

**对变量的访问是静态绑定的，无论是类变量还是实例变量。**代码中演示的是类变量：b.s和c.s，通过对象访问类变量，系统会转换为直接访问类变量Base.s和Child.s。

4.4 为什么说继承是把双刃剑

继承为什么会有破坏力呢？

因为继承可能破坏封装，而封装可以说是程序设计的第一原则；另外，继承可能没有反映出is-a关系。

继承破坏封装

封装就是隐藏实现细节，提供简化接口。实现细节可以随时修改，而不影响使用者。

函数是封装，类也是封装。

通过封装，才能在更高的层次上考虑和解决问题。

没有封装，代码之间会到处存在着实现细节的依赖，则构建和维护复杂的程序是难以想象的。

继承可能破坏封装是因为子类和父类之间可能存在着实现细节的依赖。子类在继承父类的时候，往往不得不关注父类的实现细节，而父类在修改其内部实现的时候，如果不考虑子类，也往往会影响到子类。

封装是如何被破坏的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Base {
  private static final init MAX_NUM = 1000;
  private int[] arr = new int[MAX_NUM];
  private int count;
  
  public void add(int number) {
    if (count < MAX_NUM) {
      arr[count++] = number;
    }
  }
  
  public void addAll(int[] numbers) {
    for(int num : numbers) {
      add(num);
    } 
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class Child extends Base {
  private long sum;
  @Override
  public void add(int number) {
    super.add(number);
    sum += number;
  }
  
  @Override
  public void addAll(int[] numbers) {
    super.addAll(numbers);
    for (int i=0; i<numbers.length; i++) {
      sum += numbers[i];
    }
  }
  
  public long getSum() {
    return sum;
  }
}

1
2
3
4
5

    public static void main(String[] args) {
        Child c = new Child();
        c.addAll(new int[]{1,2,3});
        System.out.println(c.getSum());
    }

使用addAll添加1、2、3，期望的输出是1+2+3=6，实际输出为12！

因为同一个数字被汇总了两次。子类的addAll方法首先调用了父类的addAll方法，而父类的addAll方法通过add方法添加，由于动态绑定，子类的add方法会执行，子类的add也会做汇总操作。

可以看出，如果子类不知道基类方法的实现细节，它就不能正确地进行扩展。知道了错误，现在我们修改子类实现，修改addAll方法为：

1
2
3
4

    @Override
    public void addAll(int[] numbers) {
        super.addAll(numbers);
    }

也就是说，addAll方法不再进行重复汇总。这次，程序就可以输出正确结果6了。

但是，基类Base决定修改addAll方法的实现，改为下面代码：

1
2
3
4
5
6
7

    public void addAll(int[] numbers) {
        for (int num : numbers) {
          if (count < MAX_NUM) {
            arr[count++] = num;
          }
        }
    }

也就是说，它不再通过调用add方法添加，这是Base类的实现细节。但是，修改了基类的内部细节后，上面使用子类的程序却错了，输出由正确值6变为了0。

上面的例子看出，子类和父类之间是细节依赖，子类扩展父类，仅仅知道父类能做什么是不够的，还需要知道父类是怎么做的，而父类的实现细节也不能随意修改，否则可能影响子类。

父类不能随意增加公开方法，因为给父类增加就是给所有子类增加，而子类可能必须要重写该方法才能确保方法的正确性。

小结：对于子类而言，通过继承实现是没有安全保障的，因为父类修改内部实现细节，它的功能就可能会被破坏；而对于基类而言，让子类继承和重写方法，就可能丧失随意修改内部实现的自由。

继承没有反映is-a关系🔖

现实中，设计完全符合is-a关系的继承关系是困难的。

==预期的行为==

但对于通过父类引用操作子类对象的程序而言，它是把对象当作父类对象来看待的，期望对象符合父类中声明的属性和行为。如果不符合，结果是什么呢？混乱。

如何应对继承的双面性

两个思路：1 避免使用继承；2 正确使用继承。

避免继承的三种方法：

1. 使用final；
2. 优先使用组合而非继承；
3. 使用接口

使用final避免继承

给方法加final修饰符，父类就保留了随意修改这个方法内部实现的自由，使用这个方法的程序也可以确保其行为是符合父类声明的。

给类加final修饰符，父类就保留了随意修改这个类实现的自由，使用者也可以放心地使用它，而不用担心一个父类引用的变量，实际指向的却是一个完全不符合预期行为的子类对象。

优先使用组合而非继承

使用组合可以抵挡父类变化对子类的影响，从而保护子类，应该优先使用组合。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class Child {
    private Base base;
    private long sum;
    public Child() {
        base = new Base();
    }
    public void add(int number) {
        base.add(number);
        sum += number;
    }
    public void addAll(int[] numbers) {
        base.addAll(numbers);
        for (int i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }
    }

    public long getSum() {
        return sum;
    }
}

这样，子类就不需要关注基类是如何实现的了，基类修改实现细节，增加公开方法，也不会影响到子类了。但组合的问题是，子类对象不能当作基类对象来统一处理了。解决方法是使用接口。

正确使用继承

使用继承的三种主要场景：

1. 基类是别人写的，我们写子类。主要是Java API、其他框架或类库中的类。注意
   • 重写方法不要改变预期的行为；
   • 阅读文档说明，理解可重写方法的实现机制，尤其是方法之间的依赖关系；
   • 在基类修改的情况下，阅读其修改说明，相应修改子类。
2. 我们写基类，别人可能写子类.注意：
   • 使用继承反映真正的is-a关系，只将真正公共的部分放到基类；
   • 对不希望被重写的公开方法添加final修饰符；
   • 写文档，说明可重写方法的实现机制，为子类提供指导，告诉子类应该如何重写；
   • 在基类修改可能影响子类时，写修改说明。
3. 基类、子类都是我们写的。关于基类，注意事项和第2种场景类似，关于子类，注意事项和第1种场景类似，不过程序都由我们控制，要求可以适当放松一些。

5 类的扩展

程序主要就是数据以及对数据的操作，而为了方便操作数据，高级语言引入了数据类型的概念。Java定义了8种基本数据类型，而类相当于是自定义数据类型，通过类的组合和继承可以表示和操作各种事物或者说对象。

5.1 接口的本质

只是将对象看作属于某种数据类型，并按该类型进行操作，在一些情况下，并不能反映对象以及对对象操作的本质。

很多时候，我们实际上关心的，并==不是对象的类型，而是对象的能力==，只要能提供这个能力，类型并不重要。

比如要拍照，很多时候，只要能拍出符合需求的照片就行，至于是用手机拍，还是用Pad拍，或者是用单反相机拍，并不重要，即关心的是对象是否有拍出照片的能力，而并不关心对象到底是什么类型，手机、Pad或单反相机都可以。

又如要计算一组数字，只要能计算出正确结果即可，至于是由人心算，用算盘算，用计算器算，用计算机软件算，并不重要，即关心的是对象是否有计算的能力，而并不关心对象到底是算盘还是计算器。

再如要将冷水加热，只要能得到热水即可，至于是用电磁炉加热，用燃气灶加热，还是用电热水壶加热，并不重要，即重要的是对象是否有加热水的能力，而并不关心对象到底是什么类型。

对象的能力通过接口表示。

接口的概念

接口声明了一组能力，但它自己并没有实现这个能力，它只是一个约定。

接口涉及交互两方对象，一方需要实现这个接口，另一方使用这个接口，但双方对象并不直接互相依赖，它们只是通过接口间接交互。

拿USB接口来说，USB协议约定了USB设备需要实现的能力，每个USB设备都需要实现这些能力，计算机使用USB协议与USB设备交互，计算机和USB设备互不依赖，但可以通过USB接口相互交互。

定义接口

Java中接口的概念举例：

”比较“，很多时候不关心对象的类型，而是关系对象有没有可比较的能力。

Java API中提供了Comparable接口，以表示可比较的能力。

1
2
3

public interface MyComparable {
  int compareTo(Object other);
}

接口与类不同，它的方法没有实现代码。定义一个接口本身并没有做什么，也没有太大的用处，它还需要至少两个参与者：一个需要实现接口，另一个使用接口。

实现接口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

public class Point implements MyComparable{
    ...
      
    @Override
    public int comparableTo(Object other) {
        if (!(other instanceof Point)) {
            throw new IllegalArgumentException();
        }
        Point otherPoint = (Point) other;
        double delta = distance() - otherPoint.distance();

        if (delta < 0) {
            return -1;
        } else if (delta > 0) {
            return 1;
        } else {
            return 0;
        }
    }
}

一个类可以实现多个接口，表明类的对象具备多种能力，各个接口之间以逗号分隔。

使用接口

与类不同，接口不能new，不能直接创建一个接口对象，对象只能通过类来创建。但可以声明接口类型的变量，引用实现了接口的类对象。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class CompUtil {
    public static Object max(MyComparable[] objs){
        if(objs==null||objs.length==0){
            return null;
        }
        MyComparable max = objs[0];
        for(int i=1; i<objs.length; i++){
            if(max.compareTo(objs[i])<0){
                max = objs[i];
            }
        }
        return max;
    }
    public static void sort(MyComparable[] objs){
        for(int i=0; i<objs.length; i++){
            int min = i;
            for(int j=i+1; j<objs.length; j++){
                if(objs[j].compareTo(objs[min])<0){
                    min = j;
                }
            }
            if(min!=i){
                 Comparable temp = objs[i];
                 objs[i] = objs[min];
                 objs[min] = temp;
            }
        }
    }
}

==针对接口而非具体类型进行编程，是计算机程序的一种重要思维方式。==

接口更重要的是降低了耦合，提高了灵活性。

接口的细节

1. 接口中的变量。修饰符自动是public static final，可以不写，通过接口名.变量名方式使用。
2. 接口的继承，可以有多个父接口。
3. 类的继承与接口可以共存，关键字extends要放在implements之前。
4. instanceof也可用来判断一个对象是否实现了某接口。

使用接口替代继承❤️

继承至少有两个好处：一个是复用代码；另一个是利用多态和动态绑定统一处理多种不同子类的对象。

使用组合替代继承，可以复用代码，但不能统一处理。

使用接口替代继承，针对接口编程，可以实现统一处理不同类型的对象，但接口没有代码实现，无法复用代码。

将组合和接口结合起来替代继承，就既可以统一处理，又可以复用代码了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

public interface IAdd {
  void add (int number);
  void addAll(int[] numbers);
}

public class Base implements IAdd {
    private static final int MAX_NUM = 1000;
    private int[] arr = new int[MAX_NUM];
    private int count;
    @Override
    public void add(int number) {
        if (count < MAX_NUM) {
            arr[count++] = number;
        }
    }
    @Override
    public void addAll(int[] numbers) {
        for (int num : numbers) {
            add(num);
        }
    }
}

public class Child implements IAdd {
    private Base base;
    private long sum;
    public Child() {
        base = new Base();
    }

    @Override
    public void add(int number) {
        base.add(number);
        sum += number;
    }

    @Override
    public void addAll(int[] numbers) {
        base.addAll(numbers);
        for (int i = 0; i < numbers.length; i++) {
            sum += numbers[i];
        }
    }

    public long getSum() {
        return sum;
    }
}

Child复用了Base的代码，又都实现了IAdd接口，这样，既复用代码，又可以统一处理，还不用担心破坏封装。

Java 8和Java 9对接口的增强

在Java 8之前，接口中的方法都是抽象方法，都没有实现体，Java 8允许在接口中定义两类新方法：==静态方法和默认方法==，它们有实现体。

1
2
3
4
5
6
7
8
9

public interface IDemo {
  void hello();
  public static void test() {
    ...
  }
  default void hi() {
    ...
  }
}

在接口不能定义静态方法之前，相关的静态方法往往定义在单独的类中，比如，Java API中，Collection接口有一个对应的单独的类Collections，在Java 8中，就可以直接写在接口中了，比如Comparator接口就定义了多个静态方法。

默认方法有默认的实现，实现类可以改变它的实现，也可以不改变。引入默认方法主要是==函数式数据处理的需求，是为了便于给接口增加功能==。

在没有默认方法之前，Java是很难给接口增加功能的，比如List接口（第9章介绍），因为有太多非Java JDK控制的代码实现了该接口，如果给接口增加一个方法，则那些接口的实现就无法在新版Java上运行，必须改写代码，实现新的方法，这显然是无法接受的。

函数式数据处理需要给一些接口增加一些新的方法，所以就有了默认方法的概念，==接口增加了新方法，而接口现有的实现类也不需要必须实现==。

在Java 8中，静态方法和默认方法都必须是public的，Java 9去除了这个限制，它们都可以是private的，引入private方法主要是为了方便多个静态或默认方法复用代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public interface IDemoPrivate {
  private void common() {
    System.out.println("common");
  }
  default void actionA() {
    common();
  }
  default void actionB() {
    common();
  }
}

这里，actionA和actionB两个默认方法共享了相同的common()方法的代码。

针对接口而非具体类型进行编程，是计算机程序的一种重要思维方式。这种方式不仅可以复用代码，还可以降低耦合，提高灵活性，是分解复杂问题的一种重要工具。

5.2 抽象类

抽象类就是抽象的类。抽象是相对于具体而言的，一般而言，具体类有==直接对应的对象==，而抽象类没有，它表达的是==抽象概念==，一般是具体类的比较上层的父类。比如，狗是具体对象，而动物则是抽象概念；樱桃是具体对象，而水果则是抽象概念；正方形是具体对象，而图形则是抽象概念。

抽象方法和抽象类

定义了抽象方法的类必须被声明为抽象类，不过，抽象类可以没有抽象方法。抽象类和具体类一样，可以定义具体方法、实例变量等，它和具体类的核心区别是，抽象类不能创建对象(比如，不能使用new Shape())，而具体类可以。

一个类在继承抽象类后，必须实现抽象类中定义的所有抽象方法，除非它自己也声明为抽象类。

与接口类似，抽象类虽然不能使用new，但可以声明抽象类的变量，引用抽象类具体子类的对象：

1
2

Shape shape = new Circle();
shape.draw();

为什么需要抽象类

引入抽象方法和抽象类，是Java提供的一种语法工具，对于一些类和方法，引导使用者正确使用它们，减少误用。

使用抽象方法而非空方法体，子类就知道它必须要实现该方法，而不可能忽略，若忽略Java编译器会提示错误。使用抽象类，类的使用者创建对象的时候，就知道必须要使用某个具体子类，而不可能误用不完整的父类。

每个人都可能会犯错，减少错误不能只依赖人的优秀素质，还需要一些==机制==，使得一个普通人都容易把事情做对，而难以把事情做错。抽象类就是Java提供的这样一种机制。

抽象类和接口

类似处：都不能用于创建对象，接口中的方法其实都是抽象方法。

不同处：接口中不能定义实例变量，而抽象类可以；一个类可以实现多个接口，但只能继承一个类。

抽象类和接口是配合而非替代关系，它们经常一起使用，接口声明能力，抽象类提供默认实现，实现全部或部分方法，一个接口经常有一个对应的抽象类。比如，在Java类库中，有：

• Collection接口和对应的AbstractCollection抽象类。
• List接口和对应的AbstractList抽象类。
• Map接口和对应的AbstractMap抽象类。

对于需要实现接口的具体类而言，有两个选择：

1. 实现接口，自己实现全部方法；
2. 继承抽象类，然后根据需要重写方法。

继承只重写部分代码，但如果具体类已经有父类，就只能选择实现接口。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public abstract class AbstractAdder implements IAdd {
  @Override
  public void addAll(int[] numbers) {
    for(int num : numbers){
      add(num);
    }
  }
}


public class Base extends AbstractAdder {
  private static final int MAX_NUM = 1000;
  private int[] arr = new int[MAX_NUM];
  private int count;
  @Override
  public void add(int number){
    if(count<MAX_NUM){
      arr[count++] = number;
    }
  }
}

抽象类和接口经常相互配合，接口定义能力，而抽象类提供默认实现，方便子类实现接口。

5.3 内部类的本质

内部类与包含它的外部类有比较密切的关系，而与其他类关系不大，定义在类内部，可以实现对外部完全隐藏，可以有更好的封装性，代码实现上也往往更为简洁。

内部类只是Java编译器的概念，对于Java虚拟机而言，它是不知道内部类这回事的，==每个内部类最后都会被编译为一个独立的类==，生成一个独立的字节码文件。

内部类可以方便地访问外部类的私有变量，可以声明为private从而实现对外完全隐藏，相关代码写在一起，写法也更为简洁，这些都是内部类的好处。

静态内部类

静态内部类与静态变量和静态方法定义的位置一样，也带有static关键字。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

public class Outer {
  private static int shared = 100;
  public static class StaticInner {
    public void innerMethod() {
      System.out.println("inner " + shared);
    }
  }
  
  public void test() {
    StaticInner si = new StaticInner();
    si.innerMethod();
  }
}

静态内部类可以访问外部类的静态变量和方法，但不可以访问实例变量和方法。

public静态内部类可以被外部使用，只是需要通过“外部类.静态内部类”的方式使用。

静态内部类是怎么实现的？上面的代码实际生成两个类：Outer，Outer$StaticInner，大概代码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

public class Outer {
  private static int shared = 100;
  public void test() {
    Outer$StaticInner si = new Outer$StaticInner();
    si.innerMethod();
  }
  
  static int access$0() {
    return shared;
  }
}

public static class Outer$StaticInner {
  public void innerMethod() {
    System.out.println("inner " + Outer.access$0);
  }
}

私有变量是不能被类外部访问的，内部类能访问的解决方法就是，自动为Outer生成一个非私有访问法access$0，它返回这个私有静态变量shared。

**静态内部类的使用场景是很多的，如果它与外部类关系密切，且不依赖于外部类实例，则可以考虑定义为静态内部类。**比如，一个类内部，如果既要计算最大值，又要计算最小值，可以在一次遍历中将最大值和最小值都计算出来，但怎么返回呢？可以定义一个类Pair，包括最大值和最小值，但Pair这个名字太普遍，而且它主要是类内部使用的，就可以定义为一个静态内部类。

Java API中使用静态内部类的例子：

• Integer类内部有一个私有静态内部类IntegerCache，用于支持整数的自动装箱。
• 表示链表的LinkedList类内部有一个私有静态内部类Node，表示链表中的每个节点。
• Character类内部有一个public静态内部类UnicodeBlock，用于表示一个Unicode block。

成员内部类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public class Outer {
  private int a = 100;
  public class Inner {
    public void innerMethod() {
      System.out.println("outer a " + a);
      Outer.this.action();
    }

  }
  private void action() {
    System.out.println("action");
  }
  
  public void test() {
    Inner si = new Inner();
    si.innerMethod();
  }
}

除了静态变量和方法，成员内部类还可以直接访问外部类的实例变量和方法(Outer.this.action()，如果没有重名，可以直接省略Outer.this)。

与静态内部类不同，**==成员内部类对象总是与一个外部类对象相连==**的，在外部使用时，它不能直接通过new Outer.Inner()的方式创建对象，而是要先将创建一个Outer类对象（外部类对象.new 内部类()）：

1
2
3

Outer outer = new Outer();
Outer.Inner inner = outer.new Inner();
inner.innerMethod();

与静态内部类不同，成员内部类中不可以定义静态变量和方法（final变量例外，它等同于常量），下面介绍的方法内部类和匿名内部类也都不可以。Java为什么要有这个规定呢？

可以这么理解，这些内部类是与外部实例相连的，不应独立使用，而静态变量和方法作为类型的属性和方法，一般是独立使用的，在内部类中意义不大，而如果内部类确实需要静态变量和方法，那么也可以挪到外部类中。

成员内部类示例的内部实现:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class Outer {
  private int a = 100;
  private void action() {
    System.out.println("action");
  }
  public void test() {
    Outer$Inner inner = new Outer$Inner(this);
    inner.innerMethod();
  }
  static int access$0(Outer outer) {
    return outer.a;
  }               
  static void access$1(Outer outer) {
    outer.action();
  }
}
public class Outer$Inner {
  final Outer outer;
  public Outer$Inner(Outer outer){
    ths.outer = outer;
  }
  public void innerMethod() {
    System.out.println("outer a " + Outer.access$0(outer));
    Outer.access$1(outer);
  }
}

Outer$Inner类有个实例变量outer指向外部类的对象，它在构造方法中被初始化，Outer在新建Outer$Inner对象时给它传递当前对象，由于内部类访问了外部类的私有变量和方法，外部类Outer生成了两个非私有静态方法：access$0用于访问变量a, access$1用于访问方法action。

应用场景：如果内部类与外部类关系密切，需要访问外部类的实例变量或方法，则可以考虑定义为成员内部类。外部类的一些方法的返回值可能是某个接口，为了返回这个接口，外部类方法可能==使用内部类实现这个接口==，这个内部类可以被设为private，对外完全隐藏。

比如，在Java API的类LinkedList中，它的两个方法listIterator和descendingIterator的返回值都是接口Iterator，调用者可以通过Iterator接口对链表遍历，listIterator和descendingIterator内部分别使用了成员内部类ListItr和DescendingIterator，这两个内部类都实现了接口Iterator。

方法内部类

内部类还可以定义在一个方法体中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

public class Outer {
  private int a = 100;
  public void test(final int param){
    final String str = "hello";
    class Inner {
      public void innerMethod(){
        System.out.println("outer a " +a);
        System.out.println("param " +param);
        System.out.println("local var " +str);
      }
    }
    Inner inner = new Inner();
    inner.innerMethod();
  }
}

类Inner定义在外部类方法test中，方法内部类只能在定义的方法内被使用。

如果方法是实例方法，则除了静态变量和方法，内部类还可以直接访问外部类的实例变量和方法。

如果方法是静态方法，则方法内部类只能访问外部类的静态变量和方法。

方法内部类还可以直接访问方法的参数和方法中的局部变量，不过，这些变量必须被声明为final。

方法内部类的内部实现：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class Outer {
  private int a = 100;
  public void test(final int param) {
    final String str = "hello";
    OuterInner inner = new OuterInner(this, param);
    inner.innerMethod();
  }
  static int access$0(Outer outer){
    return outer.a;
  }
}
public class OuterInner {
  Outer outer;
  int param;
  OuterInner(Outer outer, int param){
    this.outer = outer;
    this.param = param;
  }
  public void innerMethod() {
    System.out.println("outer a " + Outer.access$0(this.outer));
    System.out.println("param " + param);
    System.out.println("local var " + "hello");
  }
}

与成员内部类类似，OuterInner类也有一个实例变量outer指向外部对象，在构造方法中被初始化，对外部私有实例变量的访问也是通过Outer添加的方法access$0来进行的。

方法内部类可以访问方法中的参数和局部变量，这是通过在构造方法中传递参数来实现的。

这也解释了为什么方法内部类访问外部方法中的参数和局部变量时，这些变量必须被声明为final，因为实际上，方法内部类操作的并不是外部的变量，而是它自己的实例变量，只是这些变量的值和外部一样，对这些变量赋值，并不会改变外部的值，为避免混淆，所以干脆强制规定必须声明为final。

如果的确需要修改外部的变量，那么可以将变量改为只含该变量的数组，修改数组中的值。

匿名内部类

匿名内部类没有单独的类定义，它在创建对象的同时定义类，语法如下：

1
2
3

new 父类(参数列表) {
  // 匿名内部类实现部分
}

或者

1
2
3

new 父接口() {
  // 匿名内部类实现部分
}

匿名内部类是与new关联的，在创建对象的时候定义类，new后面是父类或者父接口，然后是圆括号()，里面可以是传递给父类构造方法的参数，最后是大括号{}，里面是类的定义。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class Outer {
  public void test(final int x, final int y){
    Point p = new Point(2,3){
      @Override
      public double distance() {
        return distance(new Point(x, y));
      }
    };
    System.out.println(p.distance());
  }
}

创建Point对象的时候，定义了一个匿名内部类，这个类的父类是Point，创建对象的时候，给父类构造方法传递了参数2和3，重写了distance()方法，在方法中访问了外部方法final参数x和y。

匿名内部类只能被使用一次，用来创建一个对象。它没有名字，没有构造方法，但可以根据参数列表，调用对应的父类构造方法。

匿名内部类示例的内部实现:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

public class Outer {
  public void test(final int x, final int y){
    Point p = new Outer$1(this,2,3, x, y);
    System.out.println(p.distance());
  }
}
public class Outer$1 extends Point {
  int x2;
  int y2;
  Outer outer;
  Outer$1(Outer outer, int x1, int y1, int x2, int y2){
    super(x1, y1);
    this.outer = outer;
    this.x2 = x2;
    this.y2 = y2;
  }
  @Override
  public double distance() {
    return distance(new Point(this.x2, y2));
  }
}

与方法内部类类似，外部实例this、方法参数x和y都作为参数传递给了内部类构造方法。此外，new时的参数2和3也传递给了构造方法，内部类构造方法又将它们传递给了父类构造方法。

匿名内部类能做的，方法内部类都能做。但如果对象只会创建一次，且不需要构造方法来接受参数，则可以使用匿名内部类，这样代码书写上更为简洁。

1
2
3
4
5
6

Arrays.sort(strs, new Comparator<String>() {
  @Override
  public int compare(String o1, String o2) {
    return o1.compareToIgnoreCase(o2);
  }
});

1
2
3
4
5
6
7

Button bt = new Button();
bt.addActionListener(new ActionListener() {
  @Override
  public void actionPerformed(ActionEvent e) {
    // 处理事件
  }
});

调用addActionListener将事件处理程序注册到了Button对象bt中，当事件发生时，会调用actionPerformed方法，并传递事件详情ActionEvent作为参数。

以上Arrays.sort和Button都是针对接口编程的例子，另外，它们也都是一种回调的例子。所谓==回调==是相对于一般的==正向调==用而言的，平时一般都是正向调用，但Arrays.sort中传递的Comparator对象，它的compare方法并不是在写代码的时候被调用的，而是在Arrays. sort的内部某个地方回过头来调用的。Button的addActionListener中传递的ActionListener对象，它的actionPerformed方法也一样，是在事件发生的时候回过头来调用的。

==将程序分为保持不变的主体框架，和针对具体情况的可变逻辑，通过回调的方式进行协作，是计算机程序的一种常用实践==。匿名内部类是实现回调接口的一种简便方式。

内部类本质上都会被转换为独立的类，但一般而言，它们可以实现更好的封装，代码实现上也更为简洁。

5.4 枚举的本质

枚举是一种特殊的数据，它的取值是有限的，是可以枚举出来的，比如一年有四季、一周有七天。虽然使用类也可以处理这种数据，但枚举类型更为简洁、安全和方便。

1
2
3

public enum Size {
    SMALL, MEDIUM, LARGE
}

枚举类型可以定义为一个单独的文件，也可以定义在其他类内部。

枚举变量的toString方法返回其字面值，所有枚举类型也都有一个name()方法，返回值与toString()一样:

1
2
3
4

Size size = Size.MEDIUM;
System.out.println(size.toString());
System.out.println(size.name());
// MEDIUM

枚举变量可以使用equals和==进行比较，结果是一样的。

枚举值是有顺序的，可以比较大小。枚举类型都有一个方法int ordinal()，表示枚举值在声明时的顺序，从0开始。枚举类型都实现了Java API中的Comparable接口，都可以通过方法compareTo与其他枚举值进行比较。比较其实就是比较ordinal的大小。

枚举变量可以用于和其他类型变量一样的地方，如方法参数、类变量、实例变量等，还可以用于switch语句。

枚举类型也都有一个静态的values方法，返回一个包括所有枚举值的数组，顺序与声明时的顺序一致。

1
2
3

for (Size s : Size.values()) {
  System.out.println(s);
}

枚举的好处体:

• 定义枚举的语法更为简洁。
• 枚举更为安全。一个枚举类型的变量，它的值要么为null，要么为枚举值之一，不可能为其他值，但使用整型变量，它的值就没有办法强制，值可能就是无效的。
• 枚举类型自带很多便利方法（如values、valueOf、toString等），易于使用。

枚举类型实际上会被Java编译器转换为一个对应的类，这个类继承了java.lang.Enum类。

枚举类型本质上也是类，但由于编译器自动做了很多事情，因此它的使用更为简洁、安全和方便。

典型场景

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public enum Size {
  SMALL("S", "小号"),
  MEDIUM("M", "中号"),
  LARGE("L", "大号");
  private String abbr;
  private String title;
  private Size(String abbr, String title){
    this.abbr = abbr;
    this.title = title;
  }
  public String getAbbr() {
    return abbr;
  }
  public String getTitle() {
    return title;
  }
  public static Size fromAbbr(String abbr){
    for(Size size : Size.values()){
      if(size.getAbbr().equals(abbr)){
        return size;
      }
    }
    return null;
  }
}