1.2 Java“白皮书”的关键术语

• 11个关键术语：
  1. 简单性
  2. 面向对象
  3. 分布式
  4. 健壮性：
     • Java的设计目标之一在于使得Java编写的程序具有多方面的可靠性
     • Java和C++最大的不同在于Java采用的指针模型可以消除重写内存和损坏数据的可能性
  5. 安全性：
     • Java代码不论来自哪里，都不能脱离沙箱
     • 编译器生成一个体系结构中立的目标文件格式，这是一种编译过的代码，这些编译后的代码可以在许多处理器上运行
     • 解释虚拟机指令肯定会比全速运行机器指令慢很多
     • 即时编译：虚拟机的一个选项，可以将执行最频繁的字节码序列翻译成机器码
  6. 可移植性：
     • 数据类型具有固定的大小
     • 消除了代码移植时的问题
     • 二进制数据以固定的格式进行存储和传输，消除了字节顺序的困扰
     • 字符串是用标准的Unicode格式存储的
     • 除了与用户界面有关的部分外，所有其他Java库都能很好地支持平台独立性。可以处理文件、正则表达式、XML、日期和时间、数据库、网络连接、线程等，而不用操心底层操作系统。不仅程序是可移植的，Java API往往也比原生API质量更高
  7. 解释型
  8. 高性能
  9. 多线程
  10. 动态性

3 Java的基本程序设计结构

3.1 一个简单的Java应用程序

• 关键字class：
  • 关键字class后面紧跟类名,表明Java程序中的全部内容都包含在类中
  • 类作为加载程序逻辑的容器，程序逻辑定义了应用程序的行为。
  • 源代码的文件名必须与公共类的名字相同，并用.java作为扩展名
  • 运行已编译的程序时，JVM将从指定类中的main方法开始执行，main方法必须声明为public，且必须为静态static的
• Java的类与C++的类很相似，但Java中的所有函数都属于某个类的方法。因此，Java中的main方法必须有一个外壳类

3.2 注释

• 使用 //，其注释容从 // 开始到本行结尾。内
• 使用/*和 */ ：使用较长篇幅的注释
• 以 /** 开始，以 */ 结束：可以用来自动地生成文档
• 在Java中，/**/注释不能嵌套

3.3 数据结构

• Java是一种强类型语言，意味着必须为每一个变量声明一种类型
• 8种基本类型:
  • 4种整型 跳转至整型
  • 2种浮点类型 跳转至浮点
  • 1种用于表示Unicode编码的字符单元的字符类型char 跳转至char
  • 1种用于表示真值的boolean类型
• 另：Java有一个能够表示任意精度的算术包，通常称为“大数值”（为Java对象） 跳转至大数据类

3.3.1 整型

• 在Java中，整型的范围与运行Java代码的机器无关
• Java没有任何无符号(unsigned)形式的int、long、short或byte类型
  • 长整型数值有一个后缀L或l
  • 十六进制数值有一个前缀0x或0X
  • 八进制有一个前缀0
  • 加上前缀0b或0B就可以写二进制数
• 可以为数字字面量加下划线(如用1_000_000(或0b1111_0100_0010_0100_0000)表示一百万)

3.3.2 浮点类型

• 浮点数值存在舍入误差

  • 若不允许任何舍入误差，就应该使用BigDecimal类 跳转至大数据类

• double（绝大多数程序使用）表示这种类型的数值精度是float类型的两倍。

  • float类型的数值有一个后缀F或f
  • 没有后缀F的浮点数值，默认为double类型

• 使用十六进制表示浮点数值

  • 例如，0.125=1.0*2^(-3)可以表示成0x1.0p-3(尾数十六进制，指数十进制)
  • 在十六进制表示法中，使用p表示指数，而不是e

1
2
3
4
5
6
7

//表示溢出和出错情况的三个特殊的浮点数值：
//不可用于比较大小
Double.POSITIVE_INFINITY //正无穷大
Double.NEGATIVE_INFINITY //负无穷大
Double.NaN     //NaN(不是一个数字) 

if(Double.isNaN(x))  //需要使用该方法检测非数值

3.3.3 char类型

• 转义序列\u可以出现在加引号的字符常量或字符串之外(而其他所有转义序列不可以)

• 一定要当心注释中的\u

3.3.4 Unicode和char类型

• 在Java中，char类型描述了UTF-16编码中的一个代码单元

• 强烈建议不要在程序中使用char类型，除非确实需要处理UTF-16代码单元

• 设计Unicode编码的目的

  • 对于任意给定的代码值，在不同的编码方案下有可能对应不同的字母
  • 采用大字符集的语言其编码长度有可能不同。

• 码点是指与一个编码表中的某个字符对应的代码值。

  • 在Unicode标准中，码点采用十六进制书写，并加上前缀U+
  • Unicode的码点可以分成17个代码级别
    • 第一个代码级别称为基本的多语言级别(basic multilingual plane)，码点从U+0000到U+FFFF，其中包括经典的Unicode代码
    • 其余的16个级别码点从U+10000到U+10FFFF，其中包括一些辅助字符(supplementary character)。

• UTF-16编码采用不同长度的编码表示所有Unicode码点

• 在基本的多语言级别中，每个字符用16位表示，通常被称为代码单元

• 而辅助字符采用一对连续的代码单元进行编码

• 这样构成的编码值落入基本的多语言级别中空闲的2048字节内，通常被称为替代区域

• 可以从中迅速地知道一个代码单元是一个字符的编码，还是一个辅助字符的第一或第二部分。

3.3.5 boolean类型

• boolean类型有两个值：false,true 用来判定逻辑条件
• 整型值和布尔值之间不能进行相互转换

3.4 变量

• 声明变量时，变量的类型位于变量名之前
• 在Java中，不区分变量的声明与定义
• 声明一个变量之后，必须用赋值语句对变量进行显式初始化，不要使用未初始化的变量

3.4.2 常量

• 利用关键字final指示常量,常量名一般都是全大写
• 关键字final表示这个变量只能被赋值一次。一旦被赋值之后，就不能够再更改了
• 类常量：某个常量可以在一个类中的多个方法中使用。
  • 使用关键字static final设置一个类常量
  • 类常量的定义位于main方法的外部
    • 同一个类的其他方法中也可以使用这个常量
    • 一个常量被声明为public，其他类的方法也可以使用这个常量

3.5 运算符

除号/：

• 两个操作数都是整数时，表示整数除法

• 否则，表示浮点除法

  • 整数被0除将产生一个异常
  • 浮点数被0除将会得到无穷大或NaN结果

• 默认情况下，虚拟机设计者允许对中间计算结果采用扩展的精度

• 对于使用strictfp关键字标记的方法必须使用严格的浮点计算来生成可再生的结果

  • 如果将一个类标记为strictfp，这个类中的所有方法都要使用严格的浮点计算
  • 采用默认的方式不会产生溢出，而采用严格的计算有可能产生溢出

3.5.1 数学函数与常量

1
2
3
4

double x = 4;
double y = Math.sqrt(x);  //计算数值平方根
double y = Math.pow(x,4);  //计算幂运算
System.out.println(y);

Math类提供的各种各样的数学函数：

• 平方根 sqrt

• 幂 pow

• 取余 floorMod

• 三角函数

  • Math.sin
  • Math.cos
  • Math.tan
  • Math.atan
  • Math.atan2

• 自然对数运算

  • Math.exp
  • Math.log
  • Mtah.log10

• 结果比运行速度更重要，应该使用StrictMath类

• println方法和sqrt方法存在微小的差异

  • println方法处理System.out对象
  • Math类中的sqrt方法为静态方法，处理的不是对象

3.5.2 数值类型之间的类型转换

6个实心箭头，表示无信息丢失的转换；3个虚箭头，表示可能有精度损失的转换

3.5.3 强制类型转换

1
2
3

double x = 9.997;
int y = (int) x;  
//在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名

• 将一个数值从一种类型强制转换为另一种类型，而又超出了目标类型的表示范围，结果就会截断成一个完全不同的值
• 不要在boolean类型与任何数值类型之间进行强制类型转换
  • 极少数的情况才需要将布尔类型转换为数值类型,使用条件表达式 b?1:0
• 对浮点数进行舍入运算，使用Math.round方法

3.5.5 自增与自减运算符

后缀 i++ : 表示先使用当前值，在完成加一
前缀 ++i : 表示先完成加一，在使用变量值

3.5.6 关系和boolean变量

• == 检测相等性
• \ != 检测不相等
• && || ! 与或非运算符
• 三元操作符 ? :

3.5.7 位运算符

• & | ^ ~
• >> 左移运算符
• << 右移运算符
• >>> 左移 使用0填充最高位
• <<< 右移 使用0填充最低位
  • 移位运算符的右操作数要完成模32的运算(除非左操作数是long类型

3.5.9 枚举类型

• 需要定义枚举类，参考枚举类

1
2
3
4

// 可以自定义枚举类型
// 枚举类型包括有限个命名的值
enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE};  //声明枚举类型Size
Size s = Size.MEDIUM;   //声明枚举变量s

3.6 字符串

Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义类String

3.6.1 子串

1
2
3
4
5
6

String greeting = "Hello";

// String类的substring方法
// 可以从一个较大的字符串提取出一个子串
// 容易计算子串的长度。字符串s.substring(a,b)的长度为b-a
String s = greeting.substring(0,3);  //从位置0处开始提取到第 3 字符为止(0 1 2)

3.6.2 拼接

• 允许使用 + 进行拼接两个字符串
• 当将一个字符串与一个非字符串的值进行拼接时，后者被转换成字符串
• 把多个字符串拼接并用定界符分隔，可以使用静态join方法

1

String all = String.join("/" , "S", "M", "L", "XL");

3.6.3 不可变字符串

• String类没有提供修改字符串的方法（Java文档中将String类对象称为不可变字符串）
• 修改步骤：首先提取需要的字符，然后再拼接上替换的字符串
• 不可变字符串的优点：编译器可以让字符串共享
  • 各种字符串存放在公共的存储池中
  • 字符串变量指向存储池中相应的位置
  • 如果复制一个字符串变量，原始字符串与复制的字符串共享相同的字符
• Java字符串大致类似于char*指针

3.6.4 检测字符串是否相等

1
2
3
4
5
6

// 使用equals方法检测字符串是否相等（相等则返回true，否则返回false）
s.equals(t);  //用于检测可变字符串s与可变字符串t是否相等
"Hello".equals(greeting); //检测字符串常量与字符串变量greeting是否相等

//不区分大小写检测：使用equalsIgnoreCase方法
"Hello".equalsIgnoreCase("hello");

• 一定不要使用==运算符检测两个字符串是否相等
• 该运算符只能够确定两个字符串是否放置在同一个位置上
  • 若虚拟机始终将相同的字符串共享，就可以使用==运算符检测是否相等
  • 但实际上只有字符串常量是共享的，而+或substring等操作产生的结果并不是共享的

3.6.5 空串和Null串

1
2
3
4
5
6
7
8

// 空串是长度为0的字符串(一个Java对象,有自己的串长度(0)和内容(空))
if (str.length() ==0)
if (str.equals(""))

// String变量还可以存放一个特殊的值null
//这表示目前没有任何对象与该变量关联
if (str == null)
if (str != null && str.length() != 0)  //检测既不是空串也不是null

3.6.6 码点与代码单元

• char数据类型是一个采用UTF-16编码表示Unicode码点的代码单元
• length方法将返回采用UTF-16编码表示的给定字符串所需要的代码单元数量
  • 调用s.charAt(n)将返回位置n的代码单元，n介于0~s.length()-1之间
  • 使用codePoints方法，它会生成一个int值的“流”,每个int值对应一个码点
• 将码点数组转换为字符串，可以使用构造函数

1
2

//要想得到实际的长度，即码点数量，可以调用
int cpCount = greeting.codePointCount(0,greeting.length());

3.6.9 构建字符串

1
2
3
4

StringBulider builder = new StringBulider(); //构造空的字符串构造器
builder.append(ch);  //调用append方法添加内容
builder.append(str);  
String completedString = builder.toString(); //调用toString方法转换为字符串String

• 使用StringBuilder类适用于由较短的字符串构造较短的字符串
• 避免每次连接字符串，都会构建一个新的String对象，既耗时，又浪费空间
• StringBuilder类将所有的字符串在一个单线程中编辑
  • StringBuffer效率较低，但可以使用多线程方式执行添加或删除字符串的操作

3.7 输入与输出

3.7.1 读取输入

• 读取“标准输入流”操作

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

//使用Scanner类实现（输入是可见的）
//Scanner类定义在java.util包中

import java.util.*     //导入包

Scanner in = new Scanner(System.in); //构造Scanner对象，并且与标准输入流System.in关联
String name = in.nextline(); //使用nextline输入一行(输入行可能有空格)
String firstname = in.next(); //读取一个单词输入(空格作为分隔符)
int age = in.nextInt();  //读取一个整数
Double times = in.nextDouble();  //读取一个浮点数

//输入不可见，用于从控制台读取密码
Console cons = System.console();  //Console实现
String username = Cons.readLine( "User name; ");
char[] passwc = cons.readPassword("Password: ");

• 返回的密码存放在一维字符数组中
• 在对密码进行处理之后，应该马上用一个填充值覆盖数组元素.
• 采用Console对象处理输入不如采用Scanner方便（每次只能读取一行输入，而没有能够读取一个单词或一个数值的方法）

3.7.2 格式化输出

• 每一个以%字符开始的格式说明符都用相应的参数替换。

  • 用于print的转换符：
    
  • 用于print的标志：
    

• 可以使用s转换符格式化任意的对象

• 对于任意实现了Formattable接口的对象都将调用formatTo方法

• 否则将调用toString方法，它可以将对象转换为字符串

• 可以使用静态的String.format方法创建一个格式化的字符串，而不打印输出：

1

String message = String.format("Hello, %s. Next year, you'll be %d", name, age); 

日期和时间：

• 可以采用一个格式化的字符串指出要被格式化的参数索引
• 索引必须紧跟在%后面，并以$终止。

1
2
3
4

System.out.printf("%1$s %2$tB %2$te, %2$tY", "Due date;",new Date());
System.out.printf("%s %tB %<te, %<tY", "Due date:",new Date()); 
//<标志前面格式说明中的参数将被再次使用。
//参数索引值从1开始，而不是从0开始，%1$...对第1个参数格式化。这就避免了与0标志混淆。

3.7.3 文件输入与输出

1
2
3
4
5
6

Scanner in = new Scanner(Paths.get("myfile.txt"),"UTF-8");
//对文件进行读取，就需要一个用File对象构造一个Scanner对象
Scanner in = new Scaner("myfile.txt"); 
//构造一个带有字符串参数的Scanner，但这个Scanner将字符串解释为数据，而不是文件名。
PrintWriter out = new PrintWriter(' myfile.txt","UTF-8");
//写入文件，就需要构造一个PrintWriter对象

• 如果用一个不存在的文件构造一个Scanner，或者用一个不能被创建的文件名构造一个PrintWriter，那么就会发生异常

1
2
3
4
5
6
7

//告知编译器：已经知道有可能出现“输入/输出”异常
//需要在main方法中用throws子句标记
public static void main(String[] args) throws IOException
{
  Scanner in = new Scanner(Paths.get("myfi1e.txt"),"UTF8");
}

3.8 控制流程

• Java的控制流程结构没有goto语句，但break语句可以带标签，可以利用它实现从内层循环跳出的目的
• 不能在嵌套的两个块中声明同名的变量

3.8.4 确定循环

• 在循环中，检测两个浮点数是否相等需要格外小心
  • 由于舍入的误差，最终可能得不到精确值
  • 例如，因为0.1无法精确地用二进制表示，所以，x将从9.99999999999998跳到10.09999999999998
• 如果在for语句内部定义一个变量，这个变量就不能在循环体之外使用
  • 如果希望在for循环体之外使用循环计数器的最终值，就要确保这个变量在循环语句的前面且在外部声明
• 可以在各自独立的不同for循环中定义同名的变量。

3.8.5 多重选择：switch语句

• switch语句将从与选项值相匹配的case标签处开始执行直到遇到break语句，或者执行到switch语句的结束处为止
• 有可能触发多个case分支。如果在case分支语句的末尾没有break语句，那么就会接着执行下一个case分支语句
• 编译代码时可以考虑加上==-Xlint:fallthrough选项，如果某个分支最后缺少一个break语句，编译器就会给出一个警告消息==
• 当在switch语句中使用枚举常量时，不必在每个标签中指明枚举名，可以由switch的表达式值确定

1
2
3
4
5
6
7
8

Size SZ =...;
switch (sz)
{
 case SMALL: // no need to use Size.SMALL
  ...
  break;
 ...
}

3.8.6 中断控制流程语句

• 标签必须放在希望跳出的最外层循环之前，并且必须紧跟一个冒号
• continue语句越过了当前循环体的剩余部分，立刻跳到循环首部
• continue语句用于for循环中，就可以跳到for循环的“更新”部分

3.9 大数值

• java.math包中的两个很有用的类：BigInteger和BigDecimal
  • 可以处理包含任意长度数字序列的数值
  • BigInteger类实现了任意精度的整数运算
  • BigDecimal实现了任意精度的浮点数运算。

1
2
3
4
5

//静态的valueOf方法可以将普通的数值转换为大数值
BigInteger a = BigInteger.value0f(100);
BigInteger c = a.add(b);
BigInteger d = c.multiply(b.add(BigInteger.vale0f(2)));
// 不可以使用+，*表示加法和乘法，只可以使用add和multiply方法进行

3.10 数组

• 声明数组变量时，需要指出数组类型(数据元素类型紧跟[])和数组变量的名字

1
2
3
4
5
6
7
8
9

//使用new运算符创建数组
int [] a;  //声明数组变量
int[] a = new int[100];  //创建长度为100的数组
//创建一个数字数组时，所有元素都初始化为0
//boolean数组的元素会初始化为false
//对象数组的元素则初始化为一个特殊值null，这表示这些元素(还)未存放任何对象

for (int i =0; i < a.length; i++) //获得数组元素个数(length方法)
 System.out.println(a[i]);

• 一旦创建了数组，就不能再改变它的大小(尽管可以改变每一个数组元素)
• 需要在运行过程中扩展数组的大小，使用数组列表(array list)

3.10.1 for each循环

• for each循环可以用来依次处理数组中的每个元素而不必指定下标值

1
2

//collection集合表达式必须是一个数组或者是一个实现了Iterable接口的类对象
for (variable:collection) statement  语句格式

• 调用Arrays.toString(a)，返回一个包含数组元素的字符串，可以打印数组中的所有值

3.10.2 数组初始化以及匿名数组

1
2
3
4
5
6
7
8
9

//创建数组对象并同时赋予初始值的简化书写(不需要使用new)
int[] smallPrimes = { 2, 3, 5, 7, 11, 13 ]; 
//匿名数组
new int[] { 17, 19, 23, 29, 31, 37 }; 
//在不创建新变量的情况下重新初始化一个数组
smallPrimes = new int[] { 17, 19, 23, 29, 31, 37 };  
//简化写法
int[] anonynous = { 17, 19, 23, 29, 31, 37 };  
smaPrimes = anonynous;

3.10.3 数组拷贝

• 在Java中，允许将一个数组变量拷贝给另一个数组变量,两个变量将引用同一个数组
• 将一个数组的所有值拷贝到一个新的数组中去，就要使用Arrays类的copyOf方法

1
2
3
4
5
6
7

int[] luckyNumbers = smallPrimes; //数组拷贝
luckyNunbers[5] = 12;

int[] copiedLuckyNunbers = Arrays.copyOf(luckyNumbers,luckyNumbers.length); 
//第2个参数是新数组的长度
//可用来调整数组的大小
//如果长度小于原始数组的长度，则只拷贝最前面的数据元素

3.10.4 命令行参数

• 每一个Java应用程序都有一个带String arg[]参数的main方法
• 这个参数表明main方法将接收一个字符串数组，也就是命令行参数。

3.10.5 数组排序

• 对数值型数组进行排序，使用Arrays类中的sort方法

3.10.6 多维数组

• 与一维数组一样，在调用new对多维数组进行初始化之前不能使用它
• 若知道数组元素，就可以不调用new，而直接使用简化的书写形式对多维数组进行初始化

1
2
3
4
5
6
7
8
9
10
11

balances = new double[NYEARS] [NRATES];

int[][] magicSquare =
{
 16, 3, 2, 13},
 {5，10，11, B},
 {9; 6, 7, 12},
 {4，15，14, 1}
};

System.out. println(Arrays.deepToString(a)); //快速地打印一个二维数组的数据元素列表

• 快速地打印一个二维数组的数据元素列表Arrays.deepToString方法
• for each循环语句处理二维数组的每一个元素(需要使用两个嵌套的循环)
• for each循环语句对二维数组按照行(一维数组)处理

3.10.7 不规则数组

1
2
3
4
5

double[] temp = balances[i];  //数组两行交换
balances[i] = balances[i + 1];
balances[i + 1] = temp;

//构造“不规则”数组，即数组的每一行有不同的长度。

4 对象与类

4.1.1 类

• 封装是与对象有关的一个重要概念
  • 从形式上看，封装不过是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式
  • 对象中的数据称为实例域，操纵数据的过程称为方法
  • 对于每个特定的类实例(对象)都有一组特定的实例域值。这些值的集合就是这个对象的当前状态
  • 无论何时，只要向对象发送一个消息，它的状态就有可能发生改变。

4.1.2 对象

• 对象状态的改变必须通过调用方法实现
• 如果不经过方法调用就可以改变对象状态，只能说明封装性遭到了破坏
• 需要注意，作为一个类的实例，每个对象的标识永远是不同的，状态常常也存在着差异

4.1.4 类之间的关系

• 依赖：如果一个类的方法操纵另一个类的对象，我们就说一个类依赖于另一个类。
• 聚合：意味着类A的对象包含类B的对象。
• 继承：是一种用于表示特殊与一般关系的。

4.2 使用预定类

• Math类只封装了功能，它不需要也不必隐藏数据
• 由于没有数据，因此也不必担心生成对象以及初始化实例域

4.2.1 对象与对象变量

• 在Java程序中，使用构造器构造新实例
  • 构造器是一种特殊的方法，用来构造并初始化对象
  • 构造器的名字应该与类名相同
  • 在构造器前面加上new操作符,new操作符的返回值是一个引用
• 定义对象变量后必须初始化对象变量,所有的Java对象都存储在堆中
  • 一个对象变量并没有实际包含一个对象，而仅仅引用一个对象
  • 任何对象变量的值都是对存储在另外一个地方的一个对象的引用
• 如果将一个方法应用于一个值为null的对象上，那么就会产生运行时错误
• 局部变量不会自动地初始化为null，而必须通过调用new或将它们设置为null进行初始化
• 当一个对象包含另一个对象变量时，这个变量依然包含着指向另一个堆对象的指针
• 在Java中，必须使用clone方法获得对象的完整拷贝

1
2
3
4

Date deadline;  //定义对象变量
deadline = new Date();  //初始化对象变量
deadline = birthday;  //或者引用一个存在的对象
Date deadline = new Date();  //定义并初始化对象

4.2.2 Java类库中的LocalDate类

• Date类:表示时间点
• LocalDate类:日历表示法
  • 不要使用构造器来构造LocalDate类的对象
  • 使用静态工厂方法代表调用构造器

1
2
3
4
5
6
7
8
9

LocalDate.now(); //构造新对象，表示构造这个对象时的日期
LOcalDate.of(1999, 12, 31);  //构造特定日期的对象
//不可以使用构造器方法构造LocalDate对象
LocalDate newYearsEve = LocalDate.of(1998, 12, 31);  //用静态工厂方法构造对象
int year = newYearsEve.getYear();    //返回年
int month = newYearsEve.getMonthVa1ue();  //月
int day = nenYearsEve.getDayOfMonth();   //日
//返回一个新的LocalDate对象，为距当前对象之情天数的日期
LocalDate aThousandDaysLater = newYearsEve.plusDays(1000);  

4.2.3 更改器方法与访问器方法

• 访问器方法:只访问对象而不修改对象的方法,如LocalDate.getYear()
• 更改器方法:访问对象并修改对象的方法,如GregorianCalendar.add()
• 在C++中，带有const后缀的方法是访问器方法;默认为更改器方法

4.3 用户自定义类

在Java中，最简单的类定义形式：

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

class ClassName
{
 field1
 field2
 ...
 constructor1
 constructor2
 ...
 method1
 method2
 ...
}

4.3.2 多个源文件的使用

• 使用通配符调用Java编译器:java Employee*.java
• 或编译 java EmployeeTest.java

4.3.3 剖析Employee类

• 关键字private确保只有Employee类自身的方法能够访问这些实例域，而其他类的方法不能够读写这些域
• 可以用public标记实例域（一种极为不提倡的做法）
  • public数据域允许程序中的任何方法对其进行读取和修改（完全破坏了封装）

4.3.4 从构造器开始

• 构造器与类同名,可以拥有0个、1个或多个参数，没有返回值
• 构造器总是伴随着new操作符的执行被调用，而不能对一个已经存在的对象调用构造器来达到重新设置实例域的目的
• 每个类可以有一个以上的构造器
• 不要在构造器中定义与实例域重名的局部变量
• 必须注意在所有的方法中不要命名与实例域同名的变量

4.3.5 隐式参数与显式参数

• 在每一个方法中，关键字this表示隐式参数
• 在Java中，所有的方法都必须在类的内部定义，但并不表示它们是内联方法

4.3.6 封装的优点

• 需要获得或设置实例域的值，应该提供下面三项内容：
  • 一个私有的数据域
  • 一个公有的域访问器方法
  • 一个公有的域更改器方法
• 更改器方法可以执行错误检查，然而直接对域进行赋值将不会进行这些处理
• 注意不要编写返回引用可变对象的访问器方法
  • 如果需要返回一个可变对象的引用，应该首先对它进行克隆(clone)
    • 对象clone是指存放在另一个位置上的对象副本。
    • Date类存在更改器方法setTime,因此Date对象是可变的，破坏了封装性
    • 如需要使用Date类，返回时返回Date类的clone对象（使用clone方法）

4.3.7 基于类的访问权限

• 一个方法可以访问所属类的所有对象的私有数据

4.3.8 私有方法

• 在Java中，为了实现一个私有的方法，只需将关键字public改为private即可
• 对于私有方法，如果改用其他方法实现相应的操作，则不必保留原有的方法

4.3.9 final实例域

• 将实例域定义为final，构建对象时必须初始化这样的域
  • 即必须确保在每一个构造器执行之后，这个域的值被设置，并且值不能改变
• final修饰符大都应用于基本类型域或不可变类的域
• 对于可变的类，使用final修饰符表示对象引用不会指向其他对象，但对象是可以改变的

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

class Employee {  
    //instance fields  
  private final String name;  
 ...
}

//final关键字只是表示存储在evaluations变量中的对象引用不会再指示其他StringBuilder对象
//不过这个对象可以更改
private final StringBuilder evaluations; 
evaluations = new StringBuilder(); //构造器中初始化操作

public void giveColdStar()  //但可以修改该对象的值
{
 evaluations.append(LocalDate.nowO + ": Cold star!\n");
}

4.4 静态域与静态方法

4.4.1 静态域

• 如果将域定义为static，每个类中只有一个这样的域
• 每一个对象对于所有的实例域却都有自己的一份拷贝
• 静态域属于类而不属于任何独立的对象，所有该类的对象共享一个静态域

4.4.2 静态常量

• 在常量的声明中,添加关键词static表示静态常量
  • 如Math类，若关键字static被省略，PI就变成了Math类的一个实例域
  • 需要通过Math类的对象访问PI，并且每一个Math对象都有它自己的一份PI拷贝
• 由于每个类对象都可以对公有域进行修改，所以，最好不要将域设计为public.然而，公有常量(即final域)却没问题
  • 静态常量System.out,out被声明为final,故不允许再将其他打印流赋给它
  • System类有一个setOut方法可以将System.out设置为不同的流
  • ==为什么这个方法可以修改final变量的值?
    • 原因在于，setOut方法是一个本地方法，而不是用Java语言实现的==,可以绕过Java语言的存取控制机制

4.4.3 静态方法

• 静态方法是一种不能向对象实施操作的方法
  • 静态方法是没有this参数的方法(在一个非静态的方法中，this参数表示这个方法的隐式参数
  • 建议使用类名，而不是对象来调用静态方法,可以使用对象名进行调用静态方法

在下面两种情况下使用静态方法：

• 一个方法不需要访问对象状态，其所需参数都是通过显式参数提供(例如：Math.pow)。
• 一个方法只需要访问类的静态域(例如：Employee.getNextId)

4.4.4 工厂方法

• 工厂方法用于生成不同风格的格式化对象(静态方法的另一种用途[静态工厂方法])
• 为什么NumberFormat类不利用构造器完成构建对象操作
• 原因：
  • 无法命名构造器。构造器的名字必须与类名相同。但是，这里希望将得到的货币实例和百分比实例采用不用的名字
  • 当使用构造器时，无法改变所构造的对象类型。而工厂方法将返回一个DecimalFormat类对象，这是NumberFormat的子类

4.4.5 main方法

• main方法不对任何对象进行操作
  • 事实上，在启动程序时还没有任何一个对象。静态的main方法将执行并创建程序所需要的对象。
• 每一个类可以有一个main方法(常用于对类进行单元测试)

4.5 方法参数

• Java程序设计语言总是采用按值调用
• 方法得到的是所有参数值的一个拷贝,方法不能修改传递给它的任何参数变量的内容
• 方法可以通过对象引用的拷贝修改所引用的对象状态

总结一下Java中方法参数的使用情况：

• 一个方法不能修改一个基本数据类型的参数(即数值型或布尔型)
• 一个方法可以改变一个对象参数的状态
• 一个方法不能让对象参数引用一个新的对象

4.6 对象构造

4.6.1 重载

• 如果多个方法有相同的名字、不同的参数，便产生了重载
  • 重载解析:编译器必须挑选出具体执行哪个方法，它通过用各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法;如果编译器找不到匹配的参数，就会产生编译时错误
• Java允许重载任何方法(包括构造器方法)
• 方法的签名:方法名以及参数类型

4.6.2 默认域初始化

• 如果在构造器中没有显式地给域赋予初值，那么就会被自动地赋为默认值
  • 数值为0
  • 布尔值为false
  • 对象引用为null

4.6.3 无参数的构造器

• 对象由无参数构造函数创建时，其状态会设置为适当的默认值
• 如果类提供了至少一个构造器，但是没有提供无参数构造器，在构造对象时必须提供参数
• 仅当类没有提供任何构造器的时候，系统才会提供一个默认的构造器

4.6.4 显式域初始化

• 可以在类定义中，直接将一个值赋给任何域
• 初始值不一定是常量值

4.6.5 参数名

• 参数变量用同样的名字将实例域屏蔽起来
  • 例如，如果将参数命名为salary，salary将引用这个参数，而不是实例域
  • 但是，可以采用this.salary的形式访问实例域
• this指示隐式参数，也就是所构造的对象

4.6.6 调用另一个构造器

• 如果构造器的第一个语句形如this(…)，这个构造器将调用同一个类的另一个构造器。

1
2
3
4
5
6

public Employee (double s)
{
 // calls Employee(String, double)
 this("Employee #" + nextId, s);  //调用Employee(String, double) 构造器
 nextId++;
}

4.6.7 初始化块

初始化数据块的方法：

• 在构造器中设置值
• 在声明中赋值
• 初始化代码块：只要构造类的对象，这些块就会执行

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

class Employee
{
 private static int nextId;
 
 private int id;
 private String name;
 private double salary;
 
 //初始化代码块
 {
  id = nextId;
  nextId++;
 }
 public Employee(String n, double s)
 {
  name = n;
  salary = s;
 }
...
}

• 通常会直接将初始化代码放在构造器中
• 调用构造器的具体处理步骤：
  1. 所有数据域被初始化为默认值(0、false或null)
  2. 按照在类声明中出现的次序，依次执行所有域初始化语句和初始化块
  3. 如果构造器第一行调用了第二个构造器，则执行第二个构造器主体
  4. 执行这个构造器的主体

4.6.8 对象析构与finalize方法

• 由于Java有自动的垃圾回收器，不需要人工回收内存，所以Java不支持析构器
• 可以为任何一个类添加finalize方法。finalize方法将在垃圾回收器清除对象之前调用。在实际应用中，不要依赖于使用finalize方法回收任何短缺的资源
  • 有个名为System.runFinalizersOnExit(true)的方法能够确保finalizer方法在Java关闭前被调用。不过，这个方法并不安全，也不鼓励使用
  • 有一种代替的方法是使用方法Runtime.addShutdownHook添加“关闭钩”(shutdown hook)
• 对象用完时，可以应用一个close方法来完成相应的清理操作

4.7 包

• 使用包的主要原因是确保类名的唯一性
• 一个类可以使用所属包中的所有类，以及其他包中的公有类
• 访问方法
  1. 在每个类名之前添加完整的包名
  2. 使用import语句：import语句应该位于源文件的顶部(但位于package语句的后面)
• import语句不仅可以导入类，还可以导入静态方法和静态域

1
2
3
4
5
6

//要想将一个类放入包中，就必须将包的名字放在源文件的开头，包中定义类的代码之前
package com.horstmann.corejava;
public class Employee
{
 ...
}

• 编译器对文件(带有文件分隔符和扩展名.java的文件)进行操作
• 而Java解释器加载类(带有.分隔符)

4.8 类路径

• 类存储在文件系统的子目录中
  • 类的路径必须与包名匹配
• 类文件也可以存储在JAR(Java归档)文件中
  • 在一个JAR文件中，可以包含多个压缩形式的类文件和子目录，这样既可以节省又可以改善性能
  • 在程序中用到第三方(third-party)的库文件时，通常会给出一个或多个需要包含的JAR文件。
• 为了使类能够被多个程序共享，需要做到下面几点
  1. 把类放到一个目录中，需要注意，这个目录是包树状结构的基目录
     • 如果希望将com.horstmann.corejava.Employee类添加到其中，这个Employee.class类文件就必须位于子目录/home/user/classdir/com/horstmann/corejava中
  2. 将JAR文件放在一个目录中
  3. 设置类路径(类路径是所有包含类文件的路径的集合)
• 最好采用-classpath(或-cp)选项指定类路径

4.9 文档注释

• javadoc实用程序从下面几个特性中抽取信息，并编写注释
  • 包
  • 公有类与接口
  • 公有的和受保护的构造器及方法
  • 公有的和受保护的域
• 注释应该放置在所描述特性的前面,以/**开始，并以*/结束
• 标记由@开始
  • 用于强调的＜em＞…＜/em＞
  • 用于着重强调的＜strong＞…＜/strong＞以及包含图像的＜img…＞
  • 不过，一定不要使用＜h1＞或＜hr＞，因为它们会与文档的格式产生冲突;若要键入等宽代码，需使用{@code…}
• 如果文档中有到其他文件的链接，就应该将这些文件放到子目录doc-files中
• javadoc实用程序将从源目录拷贝这些目录及其中的文件到文档目录中。在链接中需要使用doc-files目录，例如：＜img src=“doc-files/uml.png”alt=“UML diagram”＞

4.9.3 方法注释

• 每一个方法注释必须放在所描述的方法之前
• 除了通用标记之外，还可以使用下面的标记：
  • @param变量描述：这个标记将对当前方法的“param”(参数)部分添加一个条目。这个描述可以占据多行，并可以使用HTML标记。一个方法的所有@param标记必须放在一起。
  • @return描述：这个标记将对当前方法添加“return”(返回)部分。这个描述可以跨越多行，并可以使用HTML标记。
  • @throws类描述：这个标记将添加一个注释，用于表示这个方法有可能抛出异常。
• @version文本：这个标记将产生一个“version”(版本)条目(通用注释)

4.9.6 包与概述注释

• 可以直接将类、方法和变量的注释放置在Java源文件中，只要用/**…*/文档注释界定就可以了
• 要想产生包注释，就需要在每一个包目录中添加一个单独的文件
  1. 提供一个以package.html命名的HTML文件: 在标记＜body＞…＜/body＞之间的所有文本都会被抽取出来
  2. 提供一个以package-info.java命名的Java文件: 文件必须包含一个初始的以/**和*/界定的Javadoc注释，跟随在一个包语句之后。它不应该包含更多的代码或注释

4.9.7 注释的抽取

• 注释的抽取步骤：
  1. 切换到包含想要生成文档的源文件目录
     • 如果有嵌套的包要生成文档，例如com.horstmann.corejava，就必须切换到包含子目录com的目录(如果存在overview.html文件的话，这也是它的所在目录)
  2. 如果是一个包，应该运行命令：javadoc -d docDirectory nameOfPackage;对于多个包生成文档，运行：javadoc -d docDirectory nameOfPackage1 nameOfPackage2 …;如果文件在默认包中，就应该运行：javadoc -d docDirectory *.java

4.10 类设计技巧

1. 一定要保证数据私有
2. 一定要对数据初始化
3. 不要在类中使用过多的基本类型
4. 不是所有的域都需要独立的域访问器和域更改器
5. 将职责过多的类进行分解
6. 类名和方法名要能够体现它们的职责
7. 优先使用不可变的类

5 继承

• 继承已存在的类就是复用(继承)这些类的方法和域，在此基础上，还可以添加一些新的方法和域，以满足新的需求
• 反射是指在程序运行期间发现更多的类及其属性的能力

5.1 类、超类和子类

5.1.1 定义子类

• 关键字extends表示继承
• 关键字extends表明正在构造的新类派生于一个已存在的类
• 已存在的类称为超类、基类或父类;新类称为子类、派生类

1
2
3
4
5

//Manager继承Employee类
public class Manager extends Employee
{
 添加方法和域
}

5.1.3 子类构造器

• 覆盖方法：提供一个与超类方法同名的方法进行覆盖
  • 在子类中可以增加域、增加方法或覆盖超类的方法，绝对不能删除继承的任何域和方法
• 可以使用super关键字调用超类
  • super与this的区别
    • super只是指示编译器调用超类方法的特殊关键字,不是一个对象的引用,不能将super赋给另一个对象变量
    • this关键字有两个用途:(1)引用隐式参数 (2)调用该类其他的构造器
    • super关键字两个用途:(1)调用超类的方法 (2)调用超类的构造器
• 调用构造器的语句只能作为另一个构造器的第一条语句出现,使用super调用超类构造器的语句必须是子类构造器的第一条语句
  • 如果子类的构造器没有显式地调用超类的构造器，则将自动地调用超类默认(没有参数)的构造器
• 构造参数既可以传递给本类(this)的其他构造器,也可以传递给超类(super)的构造器
• 在Java中，虚拟机知道对象实际引用的对象类型，能够正确地调用相应的方法
  • 多态:一个对象变量可以指示多种实际类型的现象
  • 动态绑定:在运行时能够自动地选择调用哪个方法的现象
• 在Java中，不需要将方法声明为虚拟方法,动态绑定是默认的处理方式.如果不希望让一个方法具有虚拟特征，可以将它标记为final

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

//Manager子类的构造器方法
public Manager(String name, double salary, int year, int month, int day)
{
  //由于Manager类的构造器不能访问Employee类的私有域，所以必须利用Employee类的构造器对这部分私有域进行初始化
 super(name, salary, year, month, day);
 bonus = 0;
}

//主程序
Manger boss = new Manger("Carl", 8000, 1987, 12, 15);
boss.setBonus(5000);
staff[0] = boss;
staff[1] = new Employee("Harry", 5000, 1989, 10, 1);
staff[2] = new Employee("Tony", 4000, 1990, 3, 15);
for(Employee e : staff)
 System.out.println(e.getSalary());
//对staff[0]，其为Manger类对象，调用的为Manger类的getSalary方法
//对staff[1]，其为Employee类对象，调用的为Employee类的getSalary方法

5.1.4 继承层次

• 继承层次：由一个公共超类派生出来的所有类的集合
  • 继承并不仅限于一个层次，可以由子类再次派生出其他类
• 在继承层次中，从某个特定的类到其祖先的路径被称为该类的继承链
• Java不支持多继承(但可以利用接口实现)

5.1.5 多态

• 不能将一个超类的引用赋给子类变量
• 在Java中，子类数组的引用可以转换成超类数组的引用，而不需要采用强制类型转换
  • 需要注意子类数组的引用与超类数组的引用，引用同一个对象时，调用子类的方法可能调用一个不存在的实例域
  • 为了确保不发生这类错误，所有数组都要牢记创建它们的元素类型，并负责监督仅将类型兼容的引用存储到数组中
• 判断是否可以设计为继承关系的简单规则
  • “is-a”规则:表明子类的每个对象也是超类的对象
  • 置换法则:程序中出现超类对象的任何地方都可以用子类对象置换
• 在Java程序设计语言中，对象变量是多态的
  • 一个Employee变量既可以引用一个Employee类对象，也可以引用一个Employee类的任何一个子类的对象

5.1.6 理解方法调用

• 方法调用流程:
  1. 编译器查看对象的声明类型和方法名。编译器获得所有可能被调用的候选方法
  2. 编译器将查看调用方法时提供的参数类型。编译器已获得需要调用的方法名字和参数类型
  3. 如果是private方法、static方法、final方法或者构造器，那么编译器将可以准确地知道应该调用哪个方法(静态绑定)。与此对应的是，调用的方法依赖于隐式参数的实际类型，并且在运行时实现动态绑定
  4. 当程序运行，并且采用动态绑定调用方法时，虚拟机一定调用与所引用对象的实际类型最合适的那个类的方法
• 在运行时，调用e.getSalary()的解析过程为：
  1. 虚拟机提取e的实际类型的方法表。既可能是Employee、Manager的方法表，也可能是Employee类的其他子类的方法表
  2. 虚拟机搜索定义getSalary签名的类,虚拟机已经知道应该调用哪个方法
  3. 虚拟机调用方法
• 动态绑定有一个非常重要的特性：无需对现存的代码进行修改，就可以对程序进行扩展
  • 假设增加一个新类Executive，并且变量e有可能引用这个类的对象，我们不需要对包含调用e.getSalary()的代码进行重新编译
  • 如果e恰好引用一个Executive类的对象，就会自动地调用Executive.getSalary()方法
• 在覆盖一个方法的时候，子类方法不能低于超类方法的可见性
  • 特别是，如果超类方法是public，子类方法一定要声明为public

5.1.7 组织继承:final类和方法

• 不允许扩展的类被称为final类,用于阻止利用该类定义子类
  • 在定义类的时候使用final修饰符就表明这个类是final类,该类不可以被继承
• 类中的方法也可以被声明为final
  • 子类不能覆盖该方法
  • final类，只有其中的方法自动转换为final,域不进行转换
  • 声明final域 (final域在构造对象之后不允许被改变)

5.1.8 强制类型转换

跳转至强制类型转换

• 将某个类的对象引用转换成另外一个类的对象引用
  • 仅需要用一对圆括号将目标类名括起来，并放置在需要转换的对象引用之前(与数值类型转换类似)
• 进行类型转换的唯一原因是：在暂时忽视对象的实际类型之后，使用对象的全部功能
• 在Java中，每个对象变量都属于一个类型(类型描述了这个变量所引用的以及能够引用的对象类型)
• 将一个值存入变量时，编译器将检查是否允许该操作
  • 子类的引用赋给超类变量，编译器允许
  • 超类的引用赋给子类变量，必须进行类型转换(为通过运行时的检查)
    • 只能在继承层次内进行类型转换
    • 在超类转换成子类之前，使用instanceof操作符查看一下是否能够成功地转换
• 实际上，通过类型转换调整对象类型并不是好的做法(因为多态性的动态绑定机制能够自动地找到相应的方法)
  • 只有在使用Manager中特有的方法时才需要进行类型转换

1
2
3
4
5

if(staff[1] instanceof manager)
{
   boss = (Manager) staff[1];
   ...
}

5.1.9 抽象类

• 建议将通用的域和方法放在超类中
• 抽象方法充当着占位的角色，具体的实现在子类中
• 扩展抽象类可以有两种选择：
  • 一种是在抽象类中定义部分抽象类方法或不定义抽象类方法
  • 另一种是定义全部的抽象方法
• 抽象类不能被实例化
  • 不能创建abstract类的对象
  • 可以定义一个抽象类的对象变量，但是只能引用非抽象子类的对象
• 在接口中大量使用抽象方法
• 在抽象类定义的抽象方法
  • 若在超类中不定义该方法，则不可以通过抽象类对象变量调用类的方法
  • 若超类定义了该方法，则可以通过抽象类的对象变量调用超类的方法

1
2
3
4
5
6
7
8

//使用abstract关键字不需要实现方法
//包含一个或多个抽象方法的类本身必须声明为抽象abstract的
//抽象类Person
public abstract class Person
{
 ...
 public abstract String getDescription();
}

5.1.10 受保护访问

• 4个访问修饰符
  • 仅对本类可见——private
  • 对所有类可见——public
  • 对本包和所有子类可见——protected
  • 对本包可见——默认，不需要修饰符

5.2 Object：所有类的超类

• Object类是Java中所有类的始祖(每个类都是由它扩展而来的)
• 在Java中，只有基本类型不是对象

5.2.1-2 equals方法_相等测试与继承

• Object类中的equals方法用于检测一个对象是否等于另外一个对象
• 在Object类中，equals方法将判断两个对象是否具有相同的引用(如果两个对象具有相同的引用，它们一定是相等的),但该方法没有实际意义,需要在自己的类中重写该方法
• getClass()方法将返回一个对象所属的类,其进行相等检测的思考
  • 如果子类能够拥有自己的相等概念，则对称性需求将强制采用getClass进行检测
  • 如果由超类决定相等的概念，那么就可以使用instanceof进行检测，这样可以在不同子类的对象之间进行相等的比较
• 隐式参数和显示参数不属于同一个类，如何进行比较？
  • 使用equals方法，类不匹配则不相同
  • 若使用instanceof进行检测(if(!(otherObject instanceof Employee)) return false;)不能解决otherObject是子类的问题，且还会带来新的麻烦

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

//超类Employee的equals方法
public class Employee {
  ...
  public boolean equals(Object otherObject)
  {
      if(this == otherObject) return true;
      if(otherObject == null) return false;
      if(this.getClass() != otherObject.getClass())   return false;

      Employee other = (Employee) otherObject;
      return Objects.equals(name,other.name) && salary == other.salary && Objects.equals(hireDay,other.hireDay);
  }
  ...
}
//在子类中定义equals方法时，首先调用超类的equals==
//如果检测失败，对象就不可能相等
//如果超类中的域都相等，就需要比较子类中的实例域
public class Manager extends Employee {
  private double bonus;
  ...
  public boolean equals(Object otherObject){
      if (!super.equals(otherObject)) return false;
      Manager other = (Manager) otherObject;
      return bonus == other.bonus;
  }
  ...
}

• 语言规范要求equals方法应具有的特性
  1. 自反性：对于任何非空引用x，x.equals(x)应该返回true
  2. 对称性：对于任何引用x和y，当且仅当y.equals(x)返回true，x.equals(y)也应该返回true
  3. 传递性：对于任何引用x、y和z，如果x.equals(y)返回true，y.equals(z)返回true，x.equals(z)也应该返回true
  4. 一致性：如果x和y引用的对象没有发生变化，反复调用x.equals(y)应该返回同样的结果
  5. 对于任意非空引用x，x.equals(null)应该返回false
• 完美equals方法的建议
  1. 显式参数命名为otherObject(稍后需要类型转换)
  2. 检测this与otherObject是否引用同一个对象:(if(this == otherObject) return true;)实际上，这是一种经常采用的形式。因为计算这个等式要比一个一个地比较类中的域所付出的代价小得多
  3. 检测otherObject是否为null，如果为null，返回false(必要)
  4. 比较this与otherObject是否属于同一个类
     • 如果equals的语义在每个子类中有所改变，就使用getClass检测
     • 如果所有的子类都拥有统一的语义，就使用instanceof检测
  5. 将otherObject转换为相应的类类型变量
  6. 现在开始对所有需要比较的域进行比较了。使用==比较基本类型域，使用equals比较对象域。如果所有的域都匹配，就返回true；否则返回false

5.2.3 hashCode方法

• 散列码是由对象导出的一个整型值:
  • 散列码没有规律(如果x和y是两个不同的对象,x.hashCode()与y.hashCode()基本上不会相同)
  • 在String类中，可以使用hashCode()方法获取散列码
  • hashCode方法定义在Object类中，每个对象都有一个默认的散列码，其值为对象的存储地址
• 若重新定义equals方法，必须重新定义hashCode方法，以便将对象插入到散列表中
  • Equals与hashCode的定义必须一致(如果x.equals(y)返回true，那么x.hashCode()就必须与y.hashCode()具有相同的值)
• hashCode方法应该返回一个整型数值(也可以是负数)，并合理地组合实例域的散列码，以便能够让各个不同的对象产生的散列码更加均匀。
• 定义hashCode方法的注意事项：
  • 最好使用null安全的方法Objects.hashCode
    • 如果其参数为null，其结果为0
  • 使用静态的Double.hashCode方法类避免创建Double对象
  • 组合多个散列值，可以使用Objects.hash并提供多个参数
    • 该方法会对各个参数调用Objects.hashCode，并组合这些散列值

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

//Employee类的hashCode方法
public class Employee
{
 public int hashCode()
 {
  return 7*name.hashCode()
    + 11*new Double(salary).hashCode()
    + 13*hireDay.hashCode();
 }
 ...
}

//Employee类的优化hashCode方法
public class Employee
{
 public int hashCode()
 {
  return Object.hash(name, salary, hireDay);
 }
 ...
}

5.2.4 toString方法

• 在Object中toString方法，用于返回表示对象值的字符串
  • 绝大多数的toString方法都采用的格式：类的名字，随后是一对方括号括起来的域值
  • Object类定义了toString方法，用来打印输出对象所属的类名和散列码
• 子类需要定义自己的toString方法，并将子类域的描述添加进去
  • 如果超类使用了getClass().getName()，那么子类只要调用super.toString()
  • 随处可见toString方法的主要原因（只要对象与一个字符串通过操作符“+”连接起来，Java编译就会自动地调用toString方法，以便获得这个对象的字符串描述）
• 数组继承了object类的toString方法，数组按照旧的格式打印
  • 使用静态方法Arrays.toString可以获得数组字符串
    • 多维数组使用Arrays.deepToString方法
• 可以使用该toString方法进行调试信息输出

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

//Employee类的toString方法
public String toString()
{
  //使用getClass.getName方法获得类名的字符串
  return getClass.getName()
      + "[name=" + name
      + ",salary=" + salary
      + "hireDay=" + hireDay
      + "]"; 
}
//输出java.io.PrintStream@2f6684
//PrintStream类没有覆盖toString方法
System.out.println(System.out);

//打印调试信息的方法:使用Logger.global.info方法
//需要结合日志使用
Logger.global.info("Current position = " + position);

5.3 泛型数组列表

• Java支持数组在运行时确定数组的大小，即将一个变量赋值给数组大小
• Java具有ArrayList的类
  • 类似数组，但在添加或删除元素时，具有自动调节数组容量的功能
  • ArrayList是一个采用类型参数的泛型类
  • 为了指定数组列表保存的元素对象类型，需要用一对尖括号将类名括起来加在后面(ArrayList<Employee>)
• 数组列表的容量与数组的大小有一个非常重要的区别
  • 如果为数组分配100个元素的存储空间，数组就有100个空位置可以使用
  • 容量为100个元素的数组列表只是拥有保存100个元素的潜力(实际上，重新分配空间的话，将会超过100)
  • 但是在最初，甚至完成初始化构造之后，数组列表根本就不含有任何元素
• 一旦能够确认数组列表的大小不再发生变化，就可以调用trimToSize方法(将存储区域的大小调整为当前元素数量所需要的存储空间数目)
  • 一旦整理了数组列表的大小，添加新元素就需要花时间再次移动存储块(应该在确认不会添加任何元素时，再调用trimToSize)

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

//声明和构造保存Employee对象的数组列表
ArrayList<Employee> staff = new ArrayList<Employee>();
//在JavaSE7中，可以省略右边的类型参数
ArrayList<Employee> staff = new ArrayList<>();

//使用add方法将元素添加到数组列表中
//如果调用add且内部数组已经满了，数组列表就将自动地创建一个更大的数组，并将所有的对象从较小的数组中拷贝到较大的数组中
staff.add(new Employee("Harry",...));

//如果已经清楚或能够估计出数组可能存储的元素数量
//在填充数组之前调用ensureCapacity方法
staff.ensureCapacity(100);  //分配100个对象的内部数组
//可以将初始容量传递至ArrayList构造器
ArrayList<Employee> staff = new ArrayList<>(100);

//size方法返回数组列表中包含的实际元素数目
staff.size();
//在数组列表的中间插入元素使用带参数的add方法
//为了插入一个新元素，位于n之后的所有元素都要向后移动一个位置
//如果插入新元素后，数组列表的大小超过了容量，数组列表就会被重新分配存储空间
staff.add(n,new Employee("Harry",...));
//可以从数组列表中删除一个元素
//位于这个位置之后的所有元素都向前移动一个位置，并且数组的大小减1
Employee e = staff.remove(n);

5.3.1 访问数组列表元素

• 使用get和set方法实现访问或改变数组元素的操作
  • 不使用[]语法格式进行索引元素
• 使用add方法为数组添加新元素，而不要使用set方法
  • set方法只能替换数组中已经存在的元素内容
• get方法可获得数组列表的元素
  • 没有泛型类时，原始的ArrayList类的get方法只能返回Object，因此还需要对返回值进行类型转换
  • add方法和set方法允许接受任何类型对象
• 对数组实施插入和删除元素的操作其效率比较低
  • 对于小型数组来说，这一点不必担心
  • 但如果数组存储的元素数比较多，又经常需要在中间位置插入、删除元素，就应该考虑使用链表了

5.3.2 类型化与原始数组列表的兼容性

• 只要在与遗留的代码进行交叉操作时，研究一下编译器的警告性提示，并确保这些警告不会造成太严重的后果就行了。
• 一旦能确保不会造成严重的后果，可以用@SuppressWarnings(“unchecked”)标注来标记这个变量能够接受类型转换。

1
2
3

@SuppressWarnings(" unchecked") ArrayList<Employee> result =
(ArrayList<Employee>) emoloyeeDB.find(query); 
// yields another warning

5.4 对象包装器与自动装箱

• 所有的基本类型都有一个与之对应的类，这些类称为包装器
  • Integer,Long,Float,Double,Short,Byte,Character,Void和Boolean(前6个类派生于公共的超类Number)
  • 对象包装器类是不可变的，即一旦构造了包装器，就不允许更改包装在其中的值
  • 对象包装器类还是final，不能定义它们的子类
• 由于每个值分别包装在对象中，ArrayList<Integer>的效率远远低于int[]数组
• 自动装箱:
  • 便于添加int类型的元素到ArrayList<Integer>中
  • 要求boolean、byte、char≤127，介于-128~127之间的short和int被包装到固定的对象中
• 在算术表达式中也能够自动地装箱和拆箱
  • 在自增自减操作中，编译器将自动地插入一条对象拆箱的指令，然后进行自增(自减)计算，最后再将结果装箱
• 基本类型与它们的对象包装器是一样的，只是它们的相等性不同
  • ==运算符也可以应用于对象包装器对象，只不过检测的是对象是否指向同一个存储区域
  • 在两个包装器对象比较时调用equals方法
• 自动装箱的问题说明：
  • 由于包装器类引用可以为null，所以自动装箱有可能会抛出一个NullPointerException异常
  • 如果在一个条件表达式中混合使用Integer和Double类型，Integer值就会拆箱，提升为double，再装箱为Double
  • 使用数值对象包装器还有另外一个好处。Java设计者发现，可以将某些基本方法放置在包装器中，例如，将一个数字字符串转换成数值

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

//自动转换(自动装箱)
list.add(3);
//等效于
list.add(Integer.valueOf(3));
//当将一个Integer对象赋给一个int值时(自动拆箱)
int n = list.get(i);
//等效于
int n = list.get(i).intValue();
//将字符串转换为整数
//与Integer对象没有任何关系，parseInt是一个静态方法
//Integer类是放置这个方法的一个好地方
int x = Integer.parseInt(s);

• Integer对象是不可变的：包含在包装器中的内容不会改变
  • 不能使用这些包装器类创建修改数值参数的方法
• 如果想编写一个修改数值参数值的方法，就需要使用在org.omg.CORBA包中定义的持有者(holder)类型，包括IntHolder、BooleanHolder等。每个持有者类型都包含一个公有(！)域值，通过它可以访问存储在其中的值

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

//按值传递，故x不会发生改变
public static void triple(int x)
{
  x = 3*x;
}
//Integer对象不可变
public static void triple(Integer x)
{
  x = 3*x;
}
//使用IntHolder改变对象中的内容
public static void triple(IntHolder x)
{
  x.value = 3*x.value;
}

5.5 参数数量可变的方法

• 提供了可以用可变的参数数量调用的方法(变参方法),利用…符号表示参数数量可变
• 省略号…是Java代码的一部分，它表明这个方法可以接收任意数量的对象
• printf方法接收两个参数，一个是格式字符串，另一个是Object[]数组，其中保存着所有的参数
  • 对于printf的实现者来说，Object…参数类型与Object[]完全一样
  • 编译器需要对printf的每次调用进行转换，以便将参数绑定到数组上，并在必要的时候进行自动装箱
• 可以定义可变参数的方法，并将参数指定为任意类型，甚至是基本类型
• 允许将一个数组传递给可变参数方法的最后一个参数
  • 可以将已经存在且最后一个参数是数组的方法重新定义为可变参数的方法，而不会破坏任何已经存在的代码

1
2
3
4
5

public class PrintStream
{
  public PrintStream printf(String fmt,Object... args)
    return format(fmt,args);
}

5.6 枚举类

• 比较两个枚举类型的值，不需要调用equals，而直接使用“==”就可以了
• 可以在枚举类型中添加一些构造器、方法和域(构造器只是在构造枚举常量的时候被调用)

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

public enum Size
{
  SMALL("S")，MEDIUM("W"), LARGE("L")，EXTRA_ LARGE("XL");
  private String abbreviation;
  private Size(String abbreviation) 
  {
    this.abbreviation = abbreviation;
  }
  public String getAbbreviation() 
  {
     return abbreviation;
  }
}

• 所有的枚举类型都是Enum类的子类
  • 继承了Enum类的许多方法
    • 其中最有用的一个是toString，这个方法能够返回枚举常量名
    • toString的逆方法是静态方法valueOf
    • 每个枚举类型都有一个静态的values方法，它将返回一个包含全部枚举值的数组
  • ordinal方法返回enum声明中枚举常量的位置，位置从0开始计数
• 同Class类一样，鉴于简化的考虑，Enum类省略了一个类型参数(实际上，应该将枚举类型Size扩展为Enum<Size>
• 类型参数在compareTo方法中使用(compareTo方法 类型参数)

5.7 反射

• 反射库提供了一个非常丰富且精心设计的工具集，以便编写能够动态操纵Java代码的程序
• 能够分析类能力的程序称为反射，反射机制可以用来：
  1. 在运行时分析类的能力
  2. 在运行时查看对象，例如，编写一个toString方法供所有类使用
  3. 实现通用的数组操作代码
  4. 利用Method对象，这个对象很像C++中的函数指针

5.7.1 Class类

• 在程序运行期间，系统始终为所有的对象维护一个运行时的类型标识，该标识的信息跟踪着每个对象所属的类。虚拟机利用运行时类型信息选择相应的方法执行
• 可以通过专门的Java类访问这些信息(保存这些信息的类被称为Class)
• 一个Class对象实际上表示的是一个类型，而这个类型未必一定是一种类，且Class类实际上是一种泛型类
• 相关方法:
  • 利用Object类中的getClass()方法获得Class类型的实例(获得class对象)
  • T.class可获得匹配的类对象(T为任意的java类型)(获得class对象)
    • Class类的forName()方法可以获得类名对应的Class对象(全路径名)
    • Class类的getName()方法获得返回类的名字
    • newInstance()方法可以创建一个类的实例
      • 配合forName()和newInstance()方法可以根据储存在字符串中的类名动态创建一个对象

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

//一个Class对象将表示一个特定类的属性
//Object类中的getClass()方法会返回一个Class类型的实例
Employee e;
Class cl = e.getClass();
//最常用的方法时getName，该方法将返回类的名字
//如果类在一个包中，则包的名字也作为类名的一部分
System.out.println(e.getClass.getName);
//可以使用静态的forName方法获得类名对应的Class对象
//该方法只有在className是类名或者接口名时才能够执行
//若类名保存在字符串中，可以在运行中改变
String className = "java.util.Random";
Class cl = Class.forName(className);
//可以使用T.class获得匹配的类对象（T为任意的java类型）
class cl1 = Random.class;
//newInstance方法调用默认的构造器初始化新创建的对象(若该类没有默认的构造器，就会抛出checked exception异常)
//该方法创建一个与e具有相同类型的实例
e.getClass.newInstance();
//可以将forName和newInstance配合起来使用，可以根据储存在字符串中的类名创建一个对象
String s = "java.util.Random";
Object m = Class.forName(s).newInstance();

5.7.2 捕获异常

• 异常有两种类型：
  1. 未检查异常
  2. 已检查异常
     • 对于已检查异常，编译器将会检查是否提供了处理器
     • 使用try_catch语句

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

//将可能抛出已检查异常的一个或多个办法调用代码放在try块中
//在catch子句中提供处理器代码
try
{
  String name = ...// get class name
  Class cl = Class.forName(name); // might throw exception
  do something with cl
}
catch (Exception e)
{
  e. printStackTrace();
}
//如果类名不存在，则将跳过try块中的剩余代码，程序直接进入catch子句

5.7.3 利用反射分析类的能力

• Class类中的getFields,getMethods和getConstructors方法分别返回类提供的public域,方法和构造器数组(包括超类的公有成员)
• Class类的getDeclareFields,getDeclareMethods和getDeclaredConstructors方法分别返回类中声明的全部域、方法和构造器(包括私有和受保护成员,但不包括超类的成员)
• 在java.lang.reflect包中有三个类Field,Method和Constructor分别用于描述类的域、方法和构造器
  • Method和Constructor类有能够报告参数类型的方法，Method类还有一个可以报告返回类型的方法
  • 三个类都有getName方法(返回项目的名称)
  • 三个类都有getModifiers方法(返回整型数值，用不同的位开关描述public和static这样的修饰符使用状况)
    • 可利用java.lang.reflect包中的Modifier类的静态方法分析getModifiers返回的整型数值
  • Field类有getType方法(返回描述域所属类型的Class对象)

5.7.4 在运行时使用反射分析对象

• 查看对象域的关键方法是Field类中的get方法
• 只有利用get方法才能得到可访问域的值。除非拥有访问权限，否则Java安全机制只允许查看任意对象有哪些域，而不允许读取它们的值
• setAccessible方法是AccessibleObject类中的一个方法,是Field、Method和Constructor类的公共超类
  • 该特性是为调试、持久存储和相似机制提供的

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

Employee harry = new Employee("Harry Hacker", 35000, 10，1, 1989);
Class cl = harry.getClass();
Field f = cl.getDeclaredField("name");
Object v = f.get(harry);
//name是一个私有域，get方法将会抛出IllegalAccessException
//反射机制的默认行为受限于Java的访问控制
//然而，如果一个Java程序没有受到安全管理器的控制，就可以覆盖访问控制
//需要调用Field、Method或Constructor对象的setAccessible方法设置访问权限
f.serAccessible(true);

//name域是一个String作为Object返回没有问题
//但是,假定查看salary域(double类型,不是对象)，使用Field类中的getDouble方法，也可以调用get方法
//反射机制将会自动地将这个域值打包到相应的对象包装器中，这里将打包成Double
//调用f.set(obj, value)可以将obj对象的f域设置成新值

5.7.5 使用反射编写泛型数组代码

• java.lang.reflect包中的Array类允许动态地创建数组
• getLength()是Array类的方法，而getCOmponentType()是Class类的方法

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

//将Employee[]数组转换为Object[]数组
public static Object[] badCopyOf(Object[] a, int newLength) {
  Object[] newArray = new Object[newLength];
  System.arraycopy(a, 0, newArray, 0, Math.min(a.length,newLength));
  return newArray;
}
//该段代码,在实际使用时返回Object[]类型
  //一个对象数组不能转换为Employee[],会产生CLassCastException异常
  //将一个Employee[]临时地转换成Object[]数组，然后再把它转换回来是可以的，但一个从开始就是Object[]的数组却永远不能转换成Employee[]数组

//为解决该问题，编写通用的数组代码
  //Array类中的静态方法newInstance能够构造新数组。在调用它时必须提供两个参数，一个是数组的元素类型，一个是数组的长度
  //可以通过调用Array.getLength(a)获得数组的长度，也可以通过Array类的静态getLength方法的返回值得到任意数组的长度
//获得新数组元素类型，就需要进行以下工作：
  //1)首先获得a数组的类对象。
  //2)确认它是一个数组。
  //3)使用Class类(只能定义表示数组的类对象)的getComponentType方法确定数组对应的类型
public static Object goodCopy0f(Object a, int newLength)
{ 
  Class c1 = a.getClass();
  if (!cl.isArray()) return null;
  Class componentType = cl.getConponentType();
  int length = Array.getLength(a);
  Object newArray = Array. newInstance(componentType，newLength);
  System.arraycopy(a, 0, newArray, 0, Math.min(length, newLength));
  return newArray;
}

5.7.6 调用任意方法

• 反射机制允许调用任意方法
• 在Method类中有一个invoke方法(允许调用包装在当前Method对象中的方法)
  • invoke的参数和返回值必须是Object类型(必须进行多次的类型转换)

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

//invoke方法签名
//第一个参数是隐式参数，其余的对象提供了显式参数
//对于静态方法，第一个参数可以被忽略，即可以将它设置为null
Object invoke(Object obj, Object... args)
//假设用ml代表Employee类的getName方法
//如果返回类型是基本类型，invoke方法会返回其包装器类型
String n = (String) ml.invoke(harry);
//如果返回类型是基本类型，invoke方法会返回其包装器类型
//假设m2表示Employee类的getSalary方法，那么返回的对象实际上是一个Double，必须相应地完成类型转换。可以使用自动拆箱将它转换为一个double：
double n = (Double) m2.invoke(harry);
//如何得到Method对象呢？
  //当然，可以通过调用getDeclareMethods方法，然后对返回的Method对象数组进行查找，直到发现想要的方法为止
  //也可以通过调用Class类中的getMethod方法得到想要的方法。它与getField方法类似(getField方法根据表示域名的字符串，返回一个Field对象)
  //然而，有可能存在若干个相同名字的方法，因此要格外小心，以确保能够准确地得到想要的那个方法。有鉴于此，还必须提供想要的方法的参数类型
//getMethods的签名
Method getMethod(String name, Class... parameterTypes)
//获取Employee类的getName方法和raiseSalary方法指针
Method m1 = Employee.class.getMethod("getName");
Method m2 = Employee.class.getMethod("raiseSalary", double, class);

5.8 继承的设计技巧

1. 将公共操作和域放在超类
2. 不要使用受保护的域
   • protected机制并不能够带来更好的保护
   • 1.子类集合是无限制的，任何一个人都能够由某个类派生一个子类，并编写代码以直接访问protected的实例域，从而破坏了封装性。
   • 2.在Java程序设计语言中，在同一个包中的所有类都可以访问proteced域，而不管它是否为这个类的子类
   • protected方法对于指示那些不提供一般用途而应在子类中重新定义的方法很有用
3. 使用继承实现“is-a”关系
4. 除非所有继承的方法都有意义，否则不要使用继承
   • 如果扩展LocalDate就不会出现这个问题。由于这个类是不可变的，所以没有任何方法会把假日变成非假日
5. 在覆盖方法时，不要改变预期的行为
6. 使用多态，而非类型信息
   • action1与action2表示的是相同的概念吗？如果是相同的概念，就应该为这个概念定义一个方法，并将其放置在两个类的超类或接口中
   • 可以调用以便使用多态性提供的动态分派机制执行相应的动作
7. 不要过多地使用反射

6 接口,Lambda表达式与内部类

• 接口技术，主要用来描述类具有什么功能，而并不给出每个功能的具体实现
  • 一个类可以实现一个或多个接口，并在需要接口的地方，随时使用实现了相应接口的对象
• 使用lambda表达式，可以用一种精巧而简洁的方式表示使用回调或变量行为的代码
• 内部类机制
  • 内部类定义在另外一个类的内部，其中的方法可以访问包含它们的外部类的域
  • 内部类技术主要用于设计具有相互协作关系的类集合
• 代理(实现任意接口的对象),代理是一种非常专业的构造工具，可以用来构建系统级的工具

6.1 接口

6.1.1 接口概念

• 在Java程序设计语言中，接口不是类，而是对类的一组需求描述，这些类要遵从接口描述的统一格式进行定义

• 一个具体的示例

  • Arrays类的sort方法可以对对象数组进行排序
    • 但对象所属的类必须实现了Comparable接口
    • 任何实现Comparable接口的类都需要包含compareTo方法
    • 在调用x.compareTo(y)的时候，compareTo方法必须比较两个对象的内容，并返回比较的结果
      • 当x小于y时，返回一个负数
      • 当x等于y时，返回0；否则返回一个正数

• 接口可能包含多个方法

  • 接口中的所有方法默认为public(在声明方法时，不必提供关键字public)
  • 接口还可以定义常量

• 提供实例域和方法实现的任务应该由实现接口的那个类来完成

  • 接口看成是没有实例域的抽象类

• 让类实现接口，需要两个步骤：

  1. 将类声明为实现给定的接口
  2. 对接口中的所有方法进行定义

• 使用implements关键字将类声明为实现某个接口

• 让一个类使用排序服务必须让它实现compareTo方法

• 两个整数利用减法操作进行大小比较

  • 整数的范围不能过大，以避免造成减法运算的溢出
  • 如果能够确信ID为非负整数，或者它们的绝对值不会超过(Integer.MAX_VALUE-1)/2，就不会出现问题
  • 否则，调用静态Integer.compare方法
  • 相减技巧不适用于浮点值

• 为什么不能在类中直接提供一个compareTo方法，而必须使用接口

  • Java程序设计语言是一种强类型语言。在调用方法的时候，编译器将会检查这个方法是否存在
  • 如果a是一个Comparable对象的数组，就可以确保拥有compareTo方法，因为每个实现Comparable接口的类都必须提供这个方法的定义
  • 将Arrays类中的sort方法定义为接收一个Comparable[]数组就可以在使用元素类型没有实现Comparable接口的数组作为参数调用sort方法时，由编译器给出错误报告，但事实并非如此。在这种情况下，sort方法可以接收一个Object[]数组，并对其进行笨拙的类型转换

• 语言标准规定

  • 对于任意的x和y，实现必须能够保证sgn(x.compareTo(y))=-sgn(y.compareTo(x))
  • 即y.compareTo(x)抛出一个异常，x.compareTo(y)也应该抛出一个异常
  • 这里的“sgn”是一个数值的符号：如果n是负值，sgn(n)等于-1；如果n是0，sgn(n)等于0；如果n是正值，sgn(n)等于1。简单地讲，如果调换compareTo的参数，结果的符号也应该调换(而不是实际值)

• 如果子类之间的比较含义不一样，那就属于不同类对象的非法比较参考第五章equals方法

  • 通用算法(能够对两个不同的子类对象进行比较)，应该在超类中提供一个final常量的compareTo方法

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

//Comparable接口的代码
  //任何实现Comparable接口的类都需要包含compareTo方法
  //并且这个方法的参数必须是一个Object对象，返回一个整型数值
public interface Comparable
{
    int CompareTo(Object other);
}
//可使用泛型类型进行
public interface Comparable<T> {
  int CompareTo(T other);
}
//在实现Compareable<Employee>接口的类中，必须提供方法
int CompareTo(Employee other)
{
  ...
}
//还可以使用不带类型参数的“原始”Comparable类型
//其CompareTo方法就有一个Object类型参数
//必须手动将CompareTo方法的参数强制转换至所需要的类型

//将类声明为实现Comparable接口
class Employee implements Comparable
{
  //在实现接口时，必须把方法声明为public
  //否则，编译器将认为这个方法的访问属性是包可见性，即类的默认访问属性
  //之后编译器就会给出试图提供更严格的访问权限的警告信息
  public int compareTo(Object otherObject) {
    Employee other = (Employee) otherObject;
    return Double.compare(salary, other.salary);
  }

}
//使用泛型提供类型参数
class Employee implements Comparable<Employee>
{
  public int compareTo(Employee otherObject) {
    return Double.compare(salary, other.salary);
  }
}

6.1.2 接口的特性

• 接口不是类，尤其不能使用new运算符实例化一个接口
• 尽管不能构造接口的对象，却能声明接口的变量,接口变量必须引用实现了接口的类对象
• 可以使用instance检查一个对象是否实现了某个特定的接口
• 接口中可以包含常量，但不可以包含实例域和静态方法
  • 与接口中的方法都自动地被设置为public一样，接口中的域将被自动设为public static final

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

//定义接口变量
Comparable x;
//接口变量必须引用实现了接口的类对象
x = new Employee(...);
//可以使用instanceof检查一个对象是否实现了某个特定的接口
if (anObject instanceof Comparable)
{
  ...
}
//允许存在多条从具有较高通用性的接口到较高专用性的接口的链
public interface Moveable
{
  void move(double x, double y);
}
public interface Powered extends Moveable
{
  double milesPerCallon();
  double SPEED_LIMIT = 95;
}
//如果希望自己设计的类拥有克隆和比较的能力，只要实现这两个接口就可以了
//使用逗号将实现的各个接口分隔开
class Employee implements Cloneable,Comparable

6.1.3 接口与抽象类

• 使用抽象类表示通用属性存在这样一个问题
  • 每个类只能扩展于一个类。假设Employee类已经扩展于一个类，例如Person，它就不能扩展第二个类了
  • 但每个类可以实现多个接口
  • Java的不支持多继承，其主要原因是多继承会让语言本身变得非常复杂(如同C++)，效率也会降低
  • 接口可以提供多重继承的大多数好处，同时还能避免多重继承的复杂性和低效性

6.1.4 静态方法

• 通常静态方法放在伴随类中，例如Collection/Collections或Path/Paths
• 在Java SE 8中，允许在接口中增加静态方法
• 实现自己的接口不再需要为实用工具方法另外提供一个伴随类

6.1.5 默认方法

• 可以用default修饰符为接口方法提供一个默认方法
• 默认方法可以调用任何其他方法
• 默认方法的一个重要用法是“接口演化”
  • 假设stream方法不是一个默认方法。那么Bag类将不能编译，因为它没有实现这个新方法。为接口增加一个非默认方法不能保证“源代码兼容”
  • 不过，假设不重新编译这个类，而只是使用原先的一个包含这个类的JAR文件。这个类仍能正常加载，尽管没有这个新方法。程序仍然可以正常构造Bag实例，不会有意外发生。
  • 如果程序在一个Bag实例上调用stream方法，就会出现一个AbstractMethodError
  • 将方法实现为一个默认方法就可以解决这两个问题。Bag类又能正常编译了。另外如果没有重新编译而直接加载这个类，并在一个Bag实例上调用stream方法，将调用Collection.stream方法

1
2
3
4
5

public interface Comparable<T>
{
  default int compareTo(T other){return 0;}
  //可以为接口方法提供一个默认实现。必须用default修饰符标记这样一个方法
}

6.1.6 解决默认方法冲突

• 如果先在一个接口中将一个方法定义为默认方法，然后又在超类或另一个接口中定义了同样的方法，会发生什么情况？
  • 超类优先。如果超类提供了一个具体方法，同名而且有相同参数类型的默认方法会被忽略
  • 一个类扩展了一个超类，同时实现了一个接口，并从超类和接口继承了相同的方法
    • 在这种情况下，只会考虑超类方法，接口的所有默认方法都会被忽略
      • “类优先”规则可以确保与Java SE 7的兼容性
      • 如果为一个接口增加默认方法，这对于有这个默认方法之前能正常工作的代码不会有任何影响
    • 千万不要让一个默认方法重新定义Object类中的某个方法
      • 例如，不能为toString或equals定义默认方法，尽管对于List之类的接口这可能很有吸引力.由于“类优先”规则，这样的方法绝对无法超越Object.toString或Objects.equals
  • 接口冲突。如果一个超接口提供了一个默认方法，另一个接口提供了一个同名而且参数类型(不论是否是默认参数)相同的方法，必须覆盖这个方法来解决冲突(解决二义性问题)

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

interface Named
{
  default String getName() { return getClass().getName() + "_" + hashCode); 
}
//类会继承Person和Named接口提供的两个不一致的getName方法,出现二义性问题
//Java设计者更强调一致性
//两个接口如何冲突并不重要。如果至少有一个接口提供了一个实现，编译器就会报告错误，而程序员就必须解决这个二义性
class Student implements Person, Named
{
  public String getName(){
    return Person.super.getName();
  }
  ...
}
//如果两个接口都没有为共享方法提供默认实现，那么就与Java SE 8之前的情况一样，这里不存在冲突
//实现类可以有两个选择：实现这个方法，或者干脆不实现。如果是后一种情况，这个类本身就是抽象的

6.2 接口示例

6.2.1 接口与回调

• 回调(是一种常见的程序设计模式)
• 在这种模式中，可以指出某个特定事件发生时应该采取的动作

6.2.2 Comparator接口

• 假设我们希望按长度递增的顺序对字符串进行排序，而不是按字典顺序进行排序
• Arrays.sort方法还有第二个版本，有一个数组和一个比较器(comparator)作为参数，比较器是实现了Comparator接口的类的实例

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

//Comparator接口
public interface Comparator<T> {
  int compare(T first, T second);
}
//实现按长度比较字符串的类
class LengthComparator implements Comparator<String>{
  public int compare(String first, String second) {
    return first.length()-second.length();
  }
}
//建立实例进行比较
//尽管LengthComparator对象没有状态，不过还是需要建立这个对象的一个实例
//需要这个实例来调用compare方法(不是一个静态方法)
Comparator<String> comp = new LengthComparator();
if(comp.compare(words[i],words[j])>0)...
//对数组排序
//为Arrays.sort方法传入LengthComparator对象
String[] friends = {"Peter","Paul"};
Arrays.sort(friends,new LengthComparator());

6.2.3 对象克隆

• Cloneable接口(指示一个类提供了一个安全的clone方法)
  • Cloneable接口是Java提供的一组标记接口(标记接口不包含任何方法,唯一的作用是允许在类型查询中使用instanceof)之一
  • Comparable等接口的通常用途是确保一个类实现一个或一组特定的方法
• clone方法是Object的一个protected方法(不能直接调用anObject.clone())
  • 只有Employee类可以克隆Employee对象
  • 限制的原因：
    • 如果对象中的所有数据域都是数值或其他基本类型，拷贝没有问题
    • 如果对象包含子对象的引用，拷贝域就会得到相同子对象的另一个引用，原对象和克隆的对象仍然会共享一些信息
• 默认的克隆操作是“浅拷贝”，并没有克隆对象中引用的其他对象
  • 浅拷贝的影响
    • 如果原对象和浅克隆对象共享的子对象是不可变的，共享是安全的
    • 如果子对象属于一个不可变的类，如String。或者在对象的生命期中，子对象一直包含不变的常量，没有更改器方法会改变它，也没有方法会生成它的引用，安全
    • 通常子对象是可变的，必须重新定义clone方法来建立深拷贝，同时克隆所有子对象
• 对于每一个类，需要确定
  1. 默认的clone方法是否满足要求
  2. 是否可以在可变的子对象上调用clone来修补默认的clone方法
  3. 是否不该使用clone
• 第3个选项是默认选项;如果选择第1项或第2项，类必须：
  1. 实现Cloneable接口
  2. 重新定义clone方法，并指定public访问修饰符
• clone方法实现的注意事项：
  • 必须重新定义clone为public才能允许所有方法克隆对象(子类只能调用受保护的clone方法来克隆它自己的对象)
• Cloneable接口的出现与接口的正常使用并没有关系
  • 具体来说，它没有指定clone方法，这个方法是从Object类继承的
  • Cloneable接口只是作为一个标记，指示类设计者了解克隆过程。对象对于克隆很“偏执”，如果一个对象请求克隆，但没有实现这个接口，就会生成一个受查异常

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

//即使clone的默认(浅拷贝)实现能够满足要求，还是需要实现Cloneable接口
//将clone重新定义为public，再调用super.clone()
//与Object.clone提供的浅拷贝相比，该clone方法并没有增加任何功能
//只是让clone方法是公有的
class Employee implements Cloneable
{
  // raise visibility level to public, change return type
  public Employee clone() throws CloneNotSupportedException
  return (Employee) super.clone();
}
//深拷贝
class Employee implements Cloneable
{
  //声明了这个异常:如果在一个对象上调用clone，但这个对象的类并没有实现Cloneable接口，Object类的clone方法就会抛出一个CloneNotSupportedException
  public Employee clone() throws CloneNotSupportedException
  Employee cloned = (Employee) super.clone();
  cloned.hireDay = (Date) hireDay.clone();
  return cloned;
}
//使用异常捕获,非常适用于final类
//否则，最好还是保留throws说明符(允许子类在不支持克隆时选择抛出一个CloneNotSupportedException)
try
{
  Employee cloned = (Employee) super.clone();
}catch (CloneNotSupportedException e) { return null; }
//必须当心子类的克隆
//例如，一旦为Employee类定义了clone方法，任何人都可以用它来克隆Manager对象
//出于这个原因，在Object类中clone方法声明为protected
//不过，如果你希望类用户调用clone，就不能这样做。

//所有数组类型都有一个public的clone方法，而不是protected
//可以用这个方法建立一个新数组，包含原数组所有元素的副本
int[] luckyNumbers = { 2, 3, 5, 7, 11, 13 };
int[] cloned = luckyNumbers.clone(); 

6.3 Lambda表达式

6.3.1_2 引入Lambda表达式及语法

• lambda表达式是一个可传递的代码块，可以在以后执行一次或多次
• 语法：参数，箭头(->)以及一个表达式
• 如果代码要完成的计算无法放在一个表达式中，就可以像写方法一样，把这些代码放在{}中，并包含显式的return语句
  • 即使lambda表达式没有参数，仍然要提供空括号，就像无参数方法一样
  • 如果可以推导出一个lambda表达式的参数类型，则可以忽略其类型
  • 无需指定lambda表达式的返回类型(返回类型会由上下文推导得出)
  • 如果一个lambda表达式只在某些分支返回一个值，在另外一些分支不返回值(不合法)

1
2
3
4
5
6

(String first, String second) ->
{
  if (first.length() < second.length()) return -1;
  else if (first.length() > second.length()) return 1;
  else return 0;
}

6.3.3 函数式接口

• 函数式接口：对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式
• 为什么函数式接口必须有一个抽象方法：
  • 接口中的方法并不是完全抽象的
  • 接口完全有可能重新声明Object类的方法，如toString或clone，这些声明有可能会让方法不再是抽象的
  • 在JavaSE8中，接口可以声明非抽象方法
• 在Java中，对lambda表达式所能做的也只是能转换为函数式接口
• 不能把lambda表达式赋给类型为Object的变量，Object不是一个函数式接口

1
2
3
4
5
6

//展示如何转化为函数式接口
//考虑Arrays.sort方法
//第二个参数需要一个Comparator实例，Comparator就是只有一个方法的接口，所以可以提供一个lambda表达式
Arrays.sort(words,
  (first,second) -> first.length() - second.length());
//在底层，Arrays.sort方法会接收实现了Comparator＜String＞的某个类的对象。在这个对象上调用compare方法会执行这个lambda表达式的体

6.3.4 方法引用

• 表达式System.out::println是一个方法引用，等价于lambda表达式x->System.out.println(x)
  • 要用::操作符分隔方法名与对象或类名。主要有3种情况:
    • object::instanceMethod
    • Class::staticMethod
    • Class::instanceMethod
    • 前2种情况中，方法引用等价于提供方法参数的lambda表达式
    • 对于第3种情况，第1个参数会成为方法的目标。例如，String::compareToIgnoreCase等同于(x，y)->x.compareToIgnoreCase(y)
• 如果有多个同名的重载方法，编译器就会尝试从上下文中找出你指的那一个方法
• 类似于lambda表达式，方法引用不能独立存在，总是会转换为函数式接口的实例
• 可以在方法引用中使用this参数。例如，this::equals等同于x->this.equals(x)
  • ==使用super也是合法的,super::instanceMethod
  • 使用this作为目标，会调用给定方法的超类版本

6.3.5 构造器引用

• 构造器引用与方法引用很类似，只不过方法名为new
  • Person::new是Person构造器的一个引用
• 可以用数组类型建立构造器引用
  • 例如，int[]::new是一个构造器引用，它有一个参数:即数组的长度。这等价于lambda表达式x->new int[x]

1
2
3
4
5
6
7

//Java有一个限制，无法构造泛型类型T的数组。数组构造器引用对于克服这个限制很有用
//表达式new T[n]会产生错误，因为这会改为new Object[n]
//假设我们需要一个Person对象数组。Stream接口有一个toArray方法可以返回Object数组
Object[] people = stream.toArray();
//流库利用构造器引用解决了这个问题。可以把Person[]::new传入toArray方法
Person[] people = stream.toArray(Person[]::new);
//toArray方法调用这个构造器来得到一个正确类型的数组。然后填充这个数组并返回

6.3.6变量作用域

• lambda表达式有3个部分:
  1. 一个代码块
  2. 参数
  3. 自由变量的值(指非参数而且不在代码中定义的变量)
• 关于代码块以及自由变量值有一个术语：闭包
• lambda表达式可以捕获外围作用域中变量的值
• 在Java中，要确保所捕获的值是明确定义的，在lambda表达式中，只能引用值不会改变的变量,如果在lambda表达式中引用变量，而这个变量可能在外部改变，这也是不合法的
• lambda表达式中捕获的变量必须实际上是最终变量
  • 最终变量是指，这个变量初始化之后就不会再为它赋新值
  • 在lambda表达式中声明与一个局部变量同名的参数或局部变量是不合法的
  • 在方法中，不能有两个同名的局部变量，因此，lambda表达式中同样也不能有同名的局部变量
  • 在一个lambda表达式中使用this关键字时，是指创建这个lambda表达式的方法的this参数

1
2
3
4
5
6
7
8
9

//表达式this.toString()会调用Application对象的toString方法，而不是ActionListener实例的方法
public class Application()
{
  public void init()
  ActionListener listener = event ->
  {
    System.out.println(this, toString());
  }
}

6.3.7 处理lambda表达式

• 使用lambda表达式的重点是延迟执行
• 大多数标准函数式接口都提供了非抽象方法来生成或合并函数
• 已经提供了默认方法and、or和negate来合并谓词
• 如果设计你自己的接口，其中只有一个抽象方法，可以用@FunctionalInterface注解来标记这个接口
  • 优点：
    • 如果你无意中增加了另一个非抽象方法，编译器会产生一个错误消息
    • 另外javadoc页里会指出你的接口是一个函数式接口
• 任何有一个抽象方法的接口都是函数式接口

1
2
3
4
5
6
7

//假设重复一个动作n次
repeat(10，() -> System.out.println("He11o, Wor1d!"));
//可以使用Runnable接口,调用action.run()时会执行这个lambda表达式的主体
public static void repeat(int n, Runnable action)
{
  for (int i =0; i < n; i++) action.run();
}

6.4 内部类

• 内部类是定义在另一个类中的类
  • 内部类方法可以访问该类定义所在的作用域中的数据，包括私有的数据
  • 内部类可以对同一个包中的其他类隐藏起来
  • 当想要定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷
• 相较于C++嵌套类的好处
  • 内部类的对象有一个隐式引用，它引用了实例化该内部对象的外围类对象。通过这个指针，可以访问外围类对象的全部状态

6.4.1 使用内部类访问对象状态

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

public class TalkingClock
{
  private int interval;
  private boolean beep;
  public TalkingClock(int interval, boolean beep) {...}
  public void start() {...}
  //定义一个内部类  
  //TimePrinter类位于TalkingClock类内部。这并不意味着每个TalkingClock都有一个TimePrinter实例域
  
//TimePrinter类的详细内容
//需要注意一点，actionPerformed方法在发出铃声之前检查了beep标志
public class TimePrinter implements ActionListener
{
  public void actionPerformed(ActionEvent event)
  {
    System.out.println("At the tone, the time is" + new Date());
    if (beep) Toolkit.getDefaultToolkit().beep();
  }
}

• TimePrinter类没有实例域或者名为beep的变量
  • 取而代之的是beep引用了创建TimePrinter的TalkingClock对象的域
• 一个方法可以引用调用这个方法的对象数据域
  • 内部类既可以访问自身的数据域，也可以访问创建它的外围类对象的数据域
• 内部类的对象总有一个隐式引用，它指向了创建它的外部类对象

6.4.2 内部类的特殊语法规则

• 内部类中声明的所有静态域都必须是final
  • 原因:静态域只有一个实例，不过对于每个外部对象，会分别有一个单独的内部类实例(若不是final，它可能就不是唯一的)
• 内部类不能有static方法,可以允许有静态方法，但只能访问外围类的静态域和方法

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

//外围类引用的表达式
OuterClass.this
//TimePrinter内部类的actionPerformed方法
public void actionPerformed(ActionEvent event)
{
  ...
  if (TalkingClock.this.beep) Toolkit.getDefaultToolkit().beep();
}
//编写内部对象的构造器
outerObject.new InnerClass(construction paraments)
//最新构建的TimePrinter对象的外围类引用被设置为创建内部类对象的方法中的this引用
ActionListener listener = this.new TimePrinter();
//如果TimePrinter是一个公有内部类，对于任意的语音时钟都可以构造一个TimePrinter
TalkingClock jabberer = new TakingClock(1000, true);
TalkingClock.TimePrinter listener = jabberer.new TimePrinter();

//在外围类的作用域之外，可以这样引用内部类
OuterClass.InnerClass

6.4.3 内部类是否有用_必要和安全

• 内部类是一种编译器现象，与虚拟机无关
• 编译器将会把内部类翻译成用$(美元符号)分隔外部类名与内部类名的常规类文件，而虚拟机则对此一无所知
  • 如果内部类访问了私有数据域，就有可能通过附加在外围类所在包中的其他类访问它们，但做这些事情需要高超的技巧和极大的决心
  • 程序员不可能无意之中就获得对类的访问权限，而必须刻意地构建或修改类文件才有可能达到这个目的

6.4.4 局部内部类

• 可以在方法中定义局部类
  • 局部类不能用public或private访问说明符进行声明
  • 它的作用域被限定在声明这个局部类的块中
  • 局部类有一个优势，即对外部世界可以完全地隐藏起来

6.4.5 由外部方法访问变量

• 局部类还有一个优点。
  • 它们不仅能够访问包含它们的外部类，还可以访问final局部变量
    • 局部变量必须事实上为final(一旦赋值就绝不会改变)

6.4.6 匿名内部类

• 匿名内部类：假如只创建这个类的一个对象，就不必命名了
  • 匿名类不能有构造器(构造器的名字必须与类名相同，匿名类没有类名)
  • 将构造器参数传递给超类构造器。尤其是在内部类实现接口的时候，不能有任何构造参数
• Java程序员习惯的做法是用匿名内部类实现事件监听器和其他回调。如今最好还是使用lambda表达式。

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

public void start(int interval, boolean beep)
{
  //匿名内部类
  //含义：创建一个实现ActionListener接口的类的新对象，需要实现的方法actionPerformed定义在括号{}内
  Actionlistener listener = new ActionListener ()
  {
    public void actionPerformed (ActionEvent event)
    System.out.println("At the tone, the time is " + new Date());
    if (beep) Too1kit.getDefaultTookit().beep();
  };
  Timer t = new Timer(interval, listener);
  t.start();
}
//匿名内部类的常见定义
//SuperType可以是ActionListener这样的接口，于是内部类就要实现这个接口
//SuperType也可以是一个类，于是内部类就要扩展它
new Super Type(construction parameters)
{
  inner class methods and data
}

6.4.7 静态内部类

• 静态内部类：为了把一个类隐藏在另外一个类的内部，并不需要内部类引用外围类对象
• 将内部类声明为static，以便取消产生的引用
  • 内部类在静态方法中构造，必须将内部类声明为静态内部类

6.5 代理

• 利用代理可以在运行时创建一个实现了一组给定接口的新类
• 这种功能只有在编译时无法确定需要实现哪个接口时才有必要使用

6.5.1 何时使用代理

• 假设有一个表示接口的Class对象(有可能只包含一个接口)，它的确切类型在编译时无法知道
  • 要想构造一个实现这些接口的类，就需要使用newInstance方法或反射找出这个类的构造器
  • 但是，不能实例化一个接口，需要在程序处于运行状态时定义一个新类
• 代理类可以在运行时创建全新的类，能够实现指定的接口
• 尤其是，它具有下列方法：
  • 指定接口所需要的全部方法
  • Object类中的全部方法，例如，toString、equals等。
• 不能在运行时定义这些方法的新代码，而是要提供一个调用处理器
  • 调用处理器是实现了InvocationHandler接口的类对象
  • 调用处理器必须给出处理调用的方式
  • 无论何时调用代理对象的方法，调用处理器的invoke方法都会被调用，并向其传递Method对象和原始的调用参数

1
2

//InvocationHandler接口的唯一方法
Object invoke(Object proxy, Method method, Object[] args)

6.5.2 创建代理对象

• 使用Proxy类的newProxyInstance方法创建代理对象
• 参数
  • 一个类加载器
  • 一个Class对象数组，每个元素都是需要实现的接口
  • 一个调用处理器

6.5.3 代理类的特性

• 代理类是在程序运行过程中创建的
• 代理类一旦被创建，就变成了常规类，与虚拟机中的任何其他类没有什么区别
• 所有的代理类都扩展于Proxy类,一个代理类只有一个实例域—(调用处理器，它定义在Proxy的超类中)
• 所有的代理类都覆盖了Object类中的方法toString、equals和hashCode
• Object类中的其他方法(如clone和getClass)没有被重新定义=
  • 没有定义代理类的名字，Sun虚拟机中的Proxy类将生成一个以字符串$Proxy开头的类名
  • 对于特定的类加载器和预设的一组接口来说，只能有一个代理类（如果使用同一个类加载器和接口数组调用两次newProxyInstance方法的话，那么只能够得到同一个类的两个对象，也可以利用getProxyClass方法获得这个类）
• 代理类一定是public和final
  • 如果代理类实现的所有接口都是public，代理类就不属于某个特定的包
  • 否则，所有非公有的接口都必须属于同一个包，同时，代理类也属于这个包
• 通过调用Proxy类isProxyClass方法检测一个特定的Class对象是否代表一个代理类

7 异常_断言和日志

7.1 处理错误

7.1.1 异常分类

• 异常对象都是派生于Throwable类的一个实例
  • 所有的异常都是Throwable继承下而来的,但分解为Error和Exception
    • Error类层次结构描述了Java运行时系统的内部错误和资源耗尽错误(应用程序不应该抛出这种类型的对象)
    • 需要关注Exception层次该层次结构又分解为两个分支：一个分支派生于RuntimeException;另一个分支包含其他异常
    • 划分两个分支的规则是：
      • 程序错误导致的异常属于RuntimeException
      • 程序本身没有问题,但由于像I/O错误这类问题导致的异常属于其他异常
• Java语言规范将派生于Error类或RuntimeException类的所有异常称为非受查异常，所有其他的异常称为受查异常
  • 编译器将核查是否为所有的受查异常提供了异常处理器

7.1.2 声明受查异常

• 方法应该在其首部声明所有可能抛出的异常

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

//例
//标准类库中提供的FileInputStream类的一个构造器的声明
public FileInputStream (String name) throws FileNotFoundExpection
//这个声明表示这个构造器将根据给定的String参数产生一个FileInputStream对象，但也有可能抛出一个FileNotFoundException异常

//对于那些可能被他人使用的Java方法
//应该根据异常规范，在方法的首部声明这个方法可能抛出的异常
class MyAnimation
{
    ...
    public Image loadImage(String s) throws IOException
    {
        ...
    }
}

//一个方法有可能抛出多个受查异常类型
class MyAnimation
{
    ...
    public Image loadImage(String s) throws FileNotFoundException,EOFException
    {
        ...
    }
}

• 在自己写的方法中.需要抛出异常的4种情况：

  1. 调用一个抛出受查异常的方法，例如，FileInputStream构造器
  2. 程序运行过程中发现错误，并且利用throw语句抛出一个受查异常
  3. 程序出现错误，例如，a[–1]=0会抛出一个ArrayIndexOutOfBoundsException这样的非受查异常
  4. Java虚拟机和运行时库出现的内部错误

• 不需要声明Java的内部错误，即从Error继承的错误

• 一个方法必须声明所有可能抛出的受查异常，而非受查异常要么不可控制(Error)，要么就应该避免发生(RuntimeException)

• 如果在子类中覆盖了超类的一个方法，子类方法中声明的受查异常不能比超类方法中声明的异常更通用

  • 也就是说，子类方法中可以抛出更特定的异常，或者根本不抛出任何异常

• 如果超类方法没有抛出任何受查异常，子类也不能抛出任何受查异常

• 如果类中的一个方法声明将会抛出一个异常，而这个异常是某个特定类的实例时，则这个方法就可能抛出一个这个类的异常，或者这个类的任意一个子类的异常

7.1.3 如何抛出异常

• 对于一个已经存在的异常类,抛出方法：
  • 找到一个合适的异常类
  • 创建这个类的一个对象
  • 将对象抛出

1
2
3
4
5
6
7
8
9
10
11

//EOFException异常描述的是“在输入过程中遇到了一个未预期的EOF后的信号”
//抛出异常的语句
throw new EOFException();
//or
EOFException e = new EOFException();
throw e;

//EOFException类还有一个含有一个字符串型参数的构造器
//这个构造器可以更加细致的描述异常出现的情况
String gripe = "Content Length: " + len + ", Received: " + n;
throw new EOFException(gripe);

7.1.4 创建异常类

• 需要做的只是定义一个派生于Exception的类，或者派生于Exception子类的类
  • 例如，定义一个派生于IOException的类
  • 习惯上，定义的类应该包含两个构造器
    • 一个是默认的构造器
    • 另一个是带有详细描述信息的构造器(超类Throwable的toString方法将会打印出这些详细信息，这在调试中非常有用)

1
2
3
4
5
6
7
8
9
10

//定义自己的异常类
class FileFormatException extends IOException
{
    public FileFormatException() {}
    public FileFormatException(String gripe) {
        super(gripe);
    }
}
//抛出
throw new FileFormatException();

7.2 捕获异常

7.2.1 捕获异常

• 要想捕获一个异常，必须设置try/catch语句块
  • 如果在try语句块中的任何代码抛出了一个在catch子句中说明的异常类
    • 程序将跳过try语句块的其余代码
    • 程序将执行catch子句中的处理器代码
  • 如果在try语句块中的代码没有抛出任何异常，那么程序将跳过catch子句
  • 如果方法中的任何代码抛出了一个在catch子句中没有声明的异常类型，那么这个方法就会立刻退出
• 如果编写一个覆盖超类的方法，而这个方法又没有抛出异常，那么这个方法就必须捕获方法代码中出现的每一个受查异常
  • 不允许在子类的throws说明符中出现超过超类方法所列出的异常类范围

1
2
3
4
5
6
7

//try/catch语句
try {
    code
    morecode
} catch (ExceptionType e) {
    //TODO: handle exception
}

7.2.2 捕获多个异常

• 捕获多个异常时，异常变量隐含为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
25
26
27
28
29
30
31
32
33
34
35
36

//捕获多个异常类型，并对不同类型的异常做出不同的处理
try {
    code
    morecode
}
catch (FileNotFoundException e) 
{
    //TODO: handle exception
}
catch (UnknownHostException e) 
{
    //TODO: handle exception
}
catch (IOException e) 
{
    //TODO: handle exception
}

//获得异常对象的更多信息
e.getMessage();
//获得更详细的错误信息
e.getClass().getName();

//在Java SE 7中，同一个catch子句中可以捕获多个异常类型
try {
    code
    morecode
}
catch (FileNotFoundException | UnknownHostException e) 
{
    //TODO: handle exception
}
catch (IOException e) 
{
    //TODO: handle exception
}

7.2.3 再次抛出异常与异常链

• 在catch子句中可以抛出一个异常，这样做的目的是改变异常的类型

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

//捕获异常并将它再次抛出的基本方法
try {
    code
    morecode
} catch (SQLException e) {
    throw new ServletException("database error: " + e.getMessage());
}

//更好的处理方式，并且将原始异常设置为新异常的原因
try {
    code
    morecode
} catch (SQLException e) {
    Throwable se = new ServletException("database erroe:");
    se.initCause(e);
    throw se;
}
//当捕获到异常时，就可以使用下面这条语句重新得到原始异常
Throwable e = se.getCause();

//只想记录一个异常，再将它重新抛出，而不做任何改变
try {
    code
    morecode
} catch (Exception e) {
    logger.log(level,message, e);
    throw e;
}

7.2.4 finally子句

• 如果方法获得了一些本地资源，并且只有这个方法自己知道，又如果这些资源在退出方法之前必须被回收，那么就会产生资源回收问题
  • 一种解决方案是捕获并重新抛出所有的异常(需要在正常的代码中和异常代码中清除所分配的资源)
  • 一种更好的解决方案，finally子句
    • 不管是否有异常被捕获，finally子句中的代码都被执行
• finally中的代码总会执行
• 当finally子句包含return语句时，将会出现错误的结果
  • 假设利用return语句从try语句块中退出
  • 在方法返回前，finally子句的内容将被执行
  • 如果finally子句中也有一个return语句，这个返回值将会覆盖原始的返回值
• 清理资源的方法也有可能抛出异常
  • close方法本身也有可能抛出IOException异常。当出现这种情况时，原始的异常将会丢失，转而抛出close方法的异常
  • 可以使用带资源的try语句解决

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

//try语句可以只有finally子句,而没有catch子句

InputStream in = new FileInputStream(...)
try {
    try {
    //code
    } finally{
    //code
      in.close();
    }
} catch (IOException e) {
    //show error message
} 
//内层的try语句块只有一个职责，就是确保关闭输入流
//外层的try语句块也只有一个职责，就是确保报告出现的错误

public static int f(int n) {
    try {
        int r = n * n;
        return r;
    }   finally{
        if (n==2)   return 0;
    }
}
//如果调用f(2)，那么try语句块的计算结果为r=4，并执行return语句
//然而，在方法真正返回前，还要执行finally子句。finally子句将使得方法返回0，这个返回值覆盖了原始的返回值4

7.2.5 带资源的try语句

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

//带资源的try语句的简单形式
try (Resource res = ...) {
    //work with res    
}
//try块退出时，会自动调用res.close()

//可以指定多个资源
try (Scanner in = new Scanner(new FileInputStream("user/share/dict/words"),"UTF-8");
    PrintWriter out = new PrintWriter("out.txt")) 
{
    while(in.hasNext())
        out.println(in.next().toUpperCase());    
}

• 带资源的try语句可以很好地处理:try块抛出一个异常，而且close方法也抛出一个异常
  • 原来的异常会重新抛出，而close方法抛出的异常会“被抑制”
  • 这些异常将自动捕获，并由addSuppressed方法增加到原来的异常
  • 如果对这些异常感兴趣，可以调用getSuppressed方法，它会得到从close方法抛出并被抑制的异常列表
• 只要需要关闭资源,就要尽可能使用带资源的try语句
  • 带资源的try语句的catch子句和一个finally子句在关闭资源之后执行

7.2.6 分析堆栈轨迹元素

• 堆栈轨迹是一个方法调用过程的列表，它包含了程序执行过程中方法调用的特定位置
• 可以调用Throwable类的printStackTrace方法访问堆栈轨迹的文本描述信息
  • 使用getStackTrace方法得到StackTraceElement对象的一个数组，可以在程序中分析这个对象数组
    • StackTraceElement类含有能够获得文件名和当前执行的代码行号的方法;同时,还含有能够获得类名和方法名的方法
    • 使用toString方法将产生一个格式化的字符串，其中包含所获得的信息
  • 静态的Thread.getAllStackTrace方法可以产生所有线程的堆栈轨迹

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

Throwable t = new Throwable();
StringWriter out = new StringWriter();
t.printStackTrace(new PrintWriter(out));
String description = out.toString();

StackTraceElement[] frams = t.getStackTrace();
for (StackTraceElement frame : frames)
    //analyze frame

Map<Tread, StackTraceElement[]> map = Tread.getAllStackTrace();
for (Tread t :map.keySet())
{
    StackTraceElement[] frames = map.get(t);
    //analyze frames
}

7.3 使用异常的技巧

1. 异常处理不能代替简单的测试：只在异常情况下使用异常机制
2. 不要过分地细化异常
3. 利用异常层次结构
   1. 不要只抛出RuntimeException异常。应该寻找更加适当的子类或创建自己的异常类
   2. 不要只捕获Thowable异常，否则，会使程序代码更难读、更难维护
4. 不要压制异常
5. 在检测错误时，“苛刻”要比放任更好
6. 不要羞于传递异常

7.4 使用断言

7.4.1 断言的概念

• 断言机制允许在测试期间向代码中插入一些检查语句
  • 当代码发布时，这些插入的检测语句将会被自动地移走

1
2
3
4
5
6

//两种形式:
assert 条件
//or
assert 条件:表达式;
//这两种形式都会对条件进行检测，如果结果为false，则抛出一个AssertionError异常
//在第二种形式中，表达式将被传入AssertionError的构造器，并转换成一个消息字符串

7.4.2 启用和禁用断言

• 默认情况下，断言被禁用
  • 可以在运行程序时用-enableassertions或-ea选项启用
  • 在启用或禁用断言时不必重新编译程序
    • 启用或禁用断言是类加载器的功能。当断言被禁用时，类加载器将跳过断言代码，因此，不会降低程序运行的速度
  • 可以用选项-disableassertions或-da禁用某个特定类和包的断言
• 启用和禁用所有断言的-ea和-da开关不能应用到那些没有类加载器的“系统类”上
  • 对于这些系统类来说，需要使用-enablesystemassertions/-esa开关启用断言

1
2
3
4
5
6
7

//启用断言
java -enableassertions MyApp
//在某个类或整个包中使用断言
java -ea:MyClass -ea:com.mycompany.mylib...MyApp

//禁用断言
java -ea:... -da:MyClass MyApp

7.4.3 使用断言完成参数检查

使用断言的情况：

• 断言失败是致命的、不可恢复的错误
• 断言检查只用于开发和测阶段

7.5 记录日志

• 记录日志API的优点:
  • 可以很容易地取消全部日志记录,或者仅仅取消某个级别的日志,而且打开和关闭这个操作也很容易
  • 可以很简单地禁止日志记录的输出
  • 日志记录可以被定向到不同的处理器.用于在控制台中显示,用于存储在文件中等
  • 日志记录器和处理器都可以对记录进行过滤.过滤器可以根据过滤实现器制定的标准丢弃那些无用的记录项
  • 日志记录可以采用不同的方式格式化
  • 应用程序可以使用多个日志记录器，它们使用类似包名的这种具有层次结构的名字
  • 在默认情况下，日志系统的配置由配置文件控制

7.5.1 基本日志

1
2
3
4

//使用全局日志记录器并调用其info方法,可以生成简单的日志记录
Logger.getGlobal().info("File->Open menu item selected");
//在适当的地方调用将会取消所有的日志
Logger.getGlobal().setLevel(Level.OFF);

7.5.2 高级日志

• 使用getLOgger方法创建或获取记录器
  • 未被任何变量引用的日志记录可能会被垃圾回收,需要用静态变量存储日志记录器的一个引用
• 日志的七个等级：
  • SEVERE
  • WARNING
  • INFO
  • CONFIG
  • FINE
  • FINER
  • FINEST

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
51
52

//创建或获取记录器
public static final Logger myLogger = Logger.getLogger("com.mycompany.myapp");

//设置日记等级只记录前三个等级
Logger.setLevel(Level.FINE);
//可以使用Level.ALL开启所有级别的记录
Logger.setLevel(Level.ALL);
//使用Level.OFF关闭所有级别的记录
Logger.setLevel(Level.OFF);
//对于所有的级别有下面几种记录方法
logger.warning(message);
logger.fine(message);

//使用logger指定等级
logger.log(Level.FINE, message);

//默认的日志记录将显示包含日志调用的类名和方法名,如同堆栈所显示的那样
//如果虚拟机对执行过程进行了优化，就得不到准确的调用信息
//此时,可以调用logp方法获得调用类和方法的确切位置,这个方法的签名:
void logp(Level 1, String className, String methodName, String message)

//用来跟踪流程执行的方法
void entering(String ClassName, String methodName)
void entering(String className, String methodName, 0bject param)
void entering(String className, String methodName, Object[] params)
void exiting(String className, String methodName)
void exiting(String classNare, String methodName, 0bject result)

//未来，带Object[]参数的日志记录方法可能会被重写，以便支持变量参数列表(“varargs”)
//此后就可以用logger.entering(“com.mycompany.mylib.Reader”，“read”，file，pattern)格式调用这个方法了

//记录日志的常见用途是记录那些不可预料的异常
//可以使用下面两个方法提供日志记录中包含的异常描述内容
void throwing(String classNare, String methodName, Throwable t)
void log(Level 1, String message, Throwable t)

//典型用途
if (...)
{
  IOException exception = new IOException("...");
  logger.throwing('com.mycompany.mylib.Reader', "read", exception);
  throw exception;
}

//or
try {
    ...
} catch (IOException e) {
    Logger.getLogger("com.mycompany.myapp").log(Level.WARNING, "Reading image", e);
}

//调用throwing可以记录一条FINER级别的记录和一条以THROW开始的信息