Java核心技术卷I(原书第9版)个人笔记（u9 2015-10-17 14:40:51）

第一章
1. Java可移植性（p5）
Java中的int永远为32位的整数。而在c/c++中，int可能是16位整数、32位整数，也可能是编译器提供商指定的其他大小。

2.Java与JavaScript（p12）
JavaScript的语法类似Java，除此之外，两者无任何关系。

第二章
1.SDK：Software Development Kit

2.设置执行路径(环境变量)时，如果想要保留Program Files目录，则要把整个路径用双引号引起来，如:“c:\Program Files\jdk1.7.0_02\bin";other stuff。

第三章
1.一个简单的Java应用程序
public class FirstSample
{
public static void main(String[] args)
{
System.out.println("we will not use 'Hello,World!'");
}
}
从类名FirstSample可以看出，标准的命名规范为：类名是以大写字母开头的名词，如果名字由多个单词组成，每个单词的第一个字母都应该大写（这种在一个单词中间使用大写字母的方式称为骆驼命名法。以其自身为例，应该写成CamelCase）。

2.main方法必须声明为public
在JavaSE1.4及以后的版本中将强制main方法是public的。

3.花括号的使用风格问题p31

4.println 与print
每次调用println都会在新的一行上显示输出
System.out还有一个print方法，它在输出之后不换行。
例如 System.out.print("Hello")打印“Hello”之后不换行，后面的输出紧跟在字符“o”之后。

5.从Java7开始，加上前缀0b就可以写二进制数。例如，0b1001就是9。另外，同样也是从Java7开始，还可以为数字字面加下划线，如用1_000_000(或者0b1111_0100_0010_0100_0000)表示一百万。这些下划线只是为了让人更容易读。Java编译器会去除这些下划线。

6.注意，Java没有任何无符号类型(unsigned)。

7.在c++中，数值和指针可以代替boolean值。值0相当于布尔值false，非0值相当于布尔值true。在Java中则不是这样。因此，Java应用程序员不会遇到下述麻烦：
if(x=0)// oops...meant x == 0
在c++中这个测试可以编译运行，其结果总是false。而在Java中，这个测试将不能通过编译，其原因是整数表达式x=0不能转换为布尔值。

8.在Java中，利用关键字final指示常量。
final double CM_PER_INCH = 2.54;
const是Java保留的关键字，但目前并没有使用。在Java中，必须使用final定义常量。

9.&&和 || 是按照“短路”方式求值的，如果第一个操作数已经能够确定表达式的值，第二个操作数就不必计算了。

10.Java中，>>>运算符将用0填充高位；>>运算符用符号位填充高位。没有<<<运算符。
在c/c++中，无法确定>>操作执行的是算术移位（扩充符号位）还是逻辑移位（高位填0）。Java消除了这种含糊性。

11.强制类型转换
强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名。
例如：
double x = 9.997;
int nx = (int) x;
这样，变量nx的值为9。强制类型转换通过截断小数部分将浮点值转换为整型。
如果想对浮点数进行舍入运算，以便得到最接近的整数，那就需要使用Math.round方法：
double x = 9.997;
int nx = (int)Math.round(x);
然而，调用round的时候，仍然需要使用强制类型转换(int)。

12.运算符优先级问题
由于&&的优先级比 || 的优先级高，所以表达式
a&&b || c
等价于
(a&&b) || c
又因为+=是右结合运算符，所以表达式
a+=b+=c
等价于
a+=(b+=c)
也就是将b+=c的结果（加上c之后的b）加到a上。

13.Java不使用逗号运算符。

14.定义枚举类型的目的：有时候，变量的取值只在一个有限的集合内（取值不绝对连续）。比如，星期一，二，三，四，五，六，七，没有零，也没有八，，更没有八点五。披萨饼只有小中大和超大四中尺寸。

15.每个用双引号括起来的字符串都是String类的一个实例；

16.子串
String类的substring方法可以从一个较大的字符串提取出一个子串。
例如:
String greeting = "Hello";
String s = greeting.substring(0, 3);
创建了一个由字符“Hel”组成的字符串。
注意的问题：
在substring中从0开始计数，直到3为止，但不包含3；

substring优点：容易计算子串的长度，字符串s.substring(a,b)的长度为b-a。例如，子串“Hel”的长度为3-0=3。

17.不可变字符串
String类没有提供修改字符串的方法，若要将greeting的内容“Hello”修改为“Help！”，
如果是c语言，没办法实现，但在Java中比较容易（拼接字符串）
greeting = greeting.substring(0,3) + "p!";

updated-2015年9月2日17:51:59

补：NULL C语言用大写
null Java用小写

1.Java中的格式化输出
Java SE
5.0沿用了C语言库函数中的 printf 方法。例如，调用
System.out.printf("%8.2f", x);
另外，还可以给出控制格式化输出的各种标志。
例如，逗号标志增加了分组的分隔符。即
System.out.printf("%,.2f", 10000.0/3.0);
打印
3,333.33
printf标志
标志 目的 举例
#(对于f格式) 包含小数点 3,333.
#(对于x或0格式) 添加前缀0x或 0 0xcafe

2.文件输入与输出
如果文件名中包含反斜杠符号，就要记住在每个反斜杠之前再加一个额外的反斜杠：
“c:\\mydirectory\\myfile.txt”

3.控制流程
Java没有goto语句，但break语句可以带标签，可以利用它实现从内层循环跳出的目的。
Java不允许在嵌套的块中重定义一个变量。（C语言可以）

4.循环
for循环
for语句的第一部分通常用于对计数器初始化；第二部分给出每次新一轮循环执行前要检测的循环条件；
第三部分指示如何更新计数器。
与c++一样，尽管Java允许在for循环的各个部分放置任何表达式，但有一条不成文的规则：for语句的三部分应该对同一个计数器变量进行初始化、检测和更新。
update 2015年9月4日17:19:40

1.for语句
(1) for(int i = 1; i <= 10; i++)
{
……
}
//i no longer defined here
(2)int i;
for(i = 1; i <= 10; i++)
{
……
}
//i is still defined here

2."通用for循环"（又被称为for each循环），这是 Java SE 5.0 新增加的一种循环结构。
例
for(int element : a )
System.out.println(element);
打印数组a的每一个元素，一个元素占一行
for each循环语句的循环变量将会遍历数组中的每个元素，而不需要使用下标值

3.switch语句的case标签
case标签可以是（类型）char、byte、short、或 int的常量表达式。
从Java SE 7开始，case标签还可以是字符串字面量。
例如：
String input = . . . ;
switch (input.toLowerCase( ) )
{
case "yes": //Ok since Java SE 7
. . .
break;
. . .
}

4.与c++不同，Java还提供了一种带标签的break语句，用于跳出多重嵌套的循环语句。
标签必须放在希望跳出的最外层循环之前。并且必须紧跟一个冒号。
示例：
……
read_data:
while(……)
{
for(……)
{
……
if(……)
break read_data;
//break out of read_data loop
……
}
}

5.数组
创建一个数字数组时，所有元素都初始化为0。boolean数组的元素会初始化为false。对象数组的元素则初始化为一个特殊值null，这表示这些元素（还）未存放任何对象。
String[ ] names = new String[10];会创建一个包含10个字符串的数组，所有字符串都为null。
在Java中，允许数组长度为0.
注意，数组长度为0与null不同。

Java中的 int[ ] a = new int [100]; 等同于c++中的int *a = new int[100];
Java中的[ ]运算符被预定义为检查数组边界，而且没有指针运算，即不能通过a加1得到数组的下一个元素；

在c++中，Java的声明double[ ][ ] balances = new double[10][6]; 等同于double**balances = new double*[10];(也就是说，分配了一个包含10个指针的数组)
然后，指针数组的每一个元素被填充了一个包含6个数字的数组：
for(i = 0; i < 10; i++)
balances[i] = new double[6];
注意：当创建new double[10][6]时，这个循环将自动执行。
当需要不规则的数组时，只能单独地创建行数组。
例如：
//allocate triangular array (分配)
int[ ][ ] odds = new int[NMAX+1][ ];
for(int n = 0; n <= NMAX; n++)
odds
= new int[n+1];

第4章 对象与类
类似构造对象的模板或蓝图。我们可以将类想象为***小甜饼的切割机，将对象想象为小甜饼。
封装(encapsulation,有时称为数据隐藏)
所有的类源自于一个“神通广大的超类”------Object
通过扩展一个类来建立另外一个类的过程称为继承；
对象的改变必须通过调用方法实现。
Java中，使用构造器(constructor)构造新实例。构造器是一种特殊的方法，用来构造并初始化对象。
构造器的名字与类名相同。
new Date( ); Date 构造器，这个表达式构造了一个新对象
如果希望构造的对象多次使用，需将对象存放在一个变量中：
Date birthday = new Date( );
Date deadline; //定义了一个对象变量deadline；
//注意：一个对象变量并没有实际包含一个对象，而仅仅引用一个对象。
在Java中，任何对象变量的值都是对存储在另外一个地方的一个对象的引用
将对象变量设置为null，表明这个对象变量目前并没有引用任何对象。
Java的对象变量等同于c++的对象指针。

2.用户自定义类p106~107
注意:要想创建一个完整的程序，应该将若干类组合在一起，其中只有一个类有main方法。
在一个源文件中，只能有一个公有类。但可以有任意数目的非公有类。

3.构造器
构造器与类同名。在构造Employee类的对象时，构造器会运行。
构造器与其他的方法有一个重要的不同。构造器总是伴随着new操作符 的执行而被调用。
构造器没有返回值，可以有0个、1个或多个参数

4.(p119)每一个类可以有一个main方法。这是一个常用于对类进行单元测试的技巧。例如，可以在Employee类中添加一个main方法——如果想要独立地测试Employee类，只需要执行
java Employee
如果Employee类似一个更大型应用程序的一部分，就可以使用下面的语句运行程序
java Applicaton
并且Employee类的main方法永远不会执行。

5.方法参数(p121~124)
Java程序设计语言总是采用按值调用。方法得到的是所有参数值的一个拷贝。方法不能修改传递给它的任何参数变量的内容。
Java程序设计语言对对象采用的不是引用调用，实际上，对象引用进行的是值传递。
update 2015-9-17 13:05:54

6.重载(p126)
如果多个方法有相同的名字、不同的参数，便产生了重载。

7.初始化块(p131)
首先运行初始化块，然后才运行构造器的主体部分
可以使用Java编写一个没有main方法的“Hello,World”程序。
public class Hello
{
static
{
System.out.println("Hello,World");
}

}
当java Hello 调用这个类时，这个类就会加载，静态初始化块就会打印“Hello,World”
在此之后，会得到一个"main is not defined(没有定义)"错误信息。可以在静态初始化块的尾部调用System.exit(0)避免这一缺陷。

8.类路径p141
从java SE 6开始，可以在JAR文件目录中指定通配符，如下：
/home/user/classdir:.:/home/user/archives/'*'
9.类注释
类注释必须放在import语句之后，类定义之前。

第5章 继承
1.已存在的类称为超类(superclass)、基类(base class)或父类(parent class); 新类称为子类(subclass)、派生类(derived class)或孩子类(child class).
2.子类比超类拥有的功能更加丰富。
3.在设计类的时候，应该将通用的方法放在超类中，而将具有特殊用途的方法放在子类中。
4.子类可以提供一个新的方法来覆盖(override)超类中的这个方法:
5.this关键字有两个用途:一是引用隐式参数，二是调用该类其他的构造器。。
super关键字两个用途:一是调用超类的方法，二是调用超类的构造器。p153

6.重载(p126)
如果多个方法有相同的名字、不同的参数，便产生了重载。

7.初始化块(p131)
首先运行初始化块，然后才运行构造器的主体部分
可以使用Java编写一个没有main方法的“Hello,World”程序。
public class Hello
{
static
{
System.out.println("Hello,World");
}

}
当java Hello 调用这个类时，这个类就会加载，静态初始化块就会打印“Hello,World”
在此之后，会得到一个"main is not defined(没有定义)"错误信息。可以在静态初始化块的尾部调用System.exit(0)避免这一缺陷。

8.类路径p141
从java SE 6开始，可以在JAR文件目录中指定通配符，如下：
/home/user/classdir:.:/home/user/archives/'*'
9.类注释
类注释必须放在import语句之后，类定义之前。

第5章 继承
1.已存在的类称为超类(superclass)、基类(base class)或父类(parent class); 新类称为子类(subclass)、派生类(derived class)或孩子类(child class).
2.子类比超类拥有的功能更加丰富。
3.在设计类的时候，应该将通用的方法放在超类中，而将具有特殊用途的方法放在子类中。
4.子类可以提供一个新的方法来覆盖(override)超类中的这个方法:
5.this关键字有两个用途:一是引用隐式参数，二是调用该类其他的构造器。。
super关键字两个用途:一是调用超类的方法，二是调用超类的构造器。p153
update 2015年9月25日00:08:42

6.一个对象变量可以指示多种实际类型的现象被称为多态。在运行时能够自动地选择调用哪个方法的现象称为动态绑定。
7.is-a规则的另外一种表述法是置换法则。它表明程序中出现超类对象的任何地方都可以用子类对象置换。（p157）
例如：可以将一个子类的对象赋值给超类变量
Employee e;
e = new Employee(.....);
e = new Manager(......);
在java中，对象变量是多态的。一个Employee变量既可以引用一个Employee类对象，也可以引用Employee类的任何一个子类的对象（例如Manager、Secretary）。
但是，不能将一个超类的引用赋给子类变量。(也就是说，小的可以赋值给大的，大的不可以赋值给小的)
8.方法的名字和参数列表称为方法的签名。如：f(String)和f(int)具有相同的名字，不同签名的方法。
9.类中的特定方法可以被声明为final，这样，子类就不可以覆盖这个方法(final类中的所有方法自动地成为final方法)
class Employee
{

……
public final String getName()
{
return name;
}
……
}

10.抽象类(p164--p165)
类即使不含抽象方法，也可以将类声明为抽象类。
抽象类不能被实例化。如果将一个类声明为abstract，就不能创建这个类的对象。(但可以创建一个具体子类的对象)

11.受保护访问
protected
java中的protected概念要比c++中的安全性差。
12.Java用于控制可见性的4个访问修饰符：(p169)
1)仅对本类可见---private。
2)对所有类可见---public。
3)对本包和所有子类可见----protected。
4)对本包可见---默认，不需要修饰符。
13.在Java中，只有基本类型不是对象，例如数值、字符和布尔类型的值都不是对象。所有的数组类型，不管是对象数组还是基本类型的数组都扩展于Object类。
Employee[] staff = new Employee[10];
obj = staff; //ok
obj = new int[10]; //ok

14.toString方法 p175
随处可见toString方法的主要原因是：只要对象与一个字符串通过操作符"+"连接起来，Java编译就会自动地调用toString方法，以便获得这个对象的字符串描述。
例如
Point p = new Point(10, 20);
String message = "The current position is " + p;
//automatically invokes p.toString()

注意：在调用x.toString(）的地方可以用""+x替代，这条语句将一个空字符串与x的字符串表示相连接。(x如果是基本类型，这条语句依然可以执行)。
如果x是任意一个对象，并调用
System.out.println(x);
println方法就会直接调用 x.toString(),并打印输出得打的字符串。

注意:数组有点不一样。数组要调用静态方法Arrays.toString。
例如
int[] luckyNumbers = {2, 3, 5, 7, 11, 13};

String s = Arrays.toString(luckyNumbers);

将生成字符串"[2, 3, 5, 7, 11, 13]"。
而要想打印多维数组（数组的数组）则需要调用 Arrays.deepToString方法。

15.泛型数组列表 p181

在Java中有一个被称为ArrayList的类，它使用起来有点像数组，但在添加或删除元素的时候，具有自动调节数组容量的功能。 ArrayList---泛型类。ArrayList<Employee> staff = new ArrayList<Employee>();
在Java 7中，可以省去右边的类型参数。
ArrayList<Employee> staff = new ArrayList<>();

注意：JavaSE 5.0以前的版本没有提供泛型类。
如果数组列表(ArrayList)的内部已经满了，数组列表就将自动地创建一个更大的数组，并将所有的对象从较小的数组中拷贝到较大的数组中。
如果可以估计数组的元素数量，可以在填充数组之前调用ensureCapacity方法：
staff.ensureCapacity(100);
另外，还可以把初始容量传递给ArrayList构造器
ArrayList<Employee> staff = new ArrayList<Employee>(100);

16.对i象包装器，自动装箱 p187
Integer类对应基本类型int ，这些类就叫包装器
JavaSE 5.0 改进：便于添加或获得数组元素
list.add(3);
自动转换为
list.add(Integer.valueOf(3));
这种变换称作自动装箱。
自动拆箱(Integer->int)
int n = list.get(i);
翻译为 int n = list.get(i).inValue();

17.参数数量可变的方法 p189
用户可以定义可变参数的方法，并将参数指定为任意类型，甚至是基本类型。
简单示例：其功能为计算若干个数值的最大值
public static double max(double... values)
{
double largest = Double.MIN_VALUE;
for(double v: values)
if(v > largest)
largest = v;
return largest;
}
然后可以这样调用方法
double m = max(3.1, 40,4, -5);