Java编程思想读书笔记（第2－7章）一

第2章　　万事万物皆对象

一．所有对象都必须由你建立

1．　　存储在哪里

1.　　寄存器：我们在程序中无法控制

2.　　stack：存放基本类型的数据和对象的reference，但对象本身不存放在stack中，而是存放在Heap中

3.　　Heap：存放用new产生的数据

4.　　Static storage：存放在对象中用static定义的静态成员

5.　　Constant storage：存放常量

6.　　NON-RAM：硬盘等永久存储空间

2．　　特例：基本型别

基本类型数据存放在Stack中，存放的是数据。而产生对象时，只把对象的reference存放在stack中，用于指向某个对象，对象本身存放在Heap中。

3．　　Java中的数组

当你产生某个存储对象的数组时，真正产生的其实是存储reference的数组。引数组建立后，其中的每一个reference都会被自动设为null，表示“不指向任何对象”。

二．建立新的数据型别：Class

1．　　数据成员和函数

1.1　　基本成员的缺省值

1）　　当class的某个成员属于基本型别时，即使你没有为它提供初值，Java仍保证它有一个缺省值。

2）　　只有当变量身份是“class内的成员时，Java才保证为该变量提供初值。

三．函数（Mehtods），引数（arguments），返回值（return values）

1．　　引数列

当引数传递的是对象时，传递的是对象的reference。

四．注解用内嵌式文档

Java提供两种注解风格：/*XXXX*/、//XXXX

第3章　　控制程序流程

一．使用Java运算符

1.关系运算符

1.） 当对两个对象运用关系运算符进行比较时，比较的是object reference，如：

java/lang/Integer.java.html" target="_blank">Integer n1 = new java/lang/Integer.java.html" target="_blank">Integer(3);
java/lang/Integer.java.html" target="_blank">Integer n2 = new java/lang/Integer.java.html" target="_blank">Integer(3);
java/lang/System.java.html" target="_blank">System.out.println(n1==n2);

结果为false，因为两个object reference（n1和n2）值是不同的

2） quals()的缺省行为也是拿referenct来比较。不过Java中的class覆写了equals方法，如：

java/lang/Integer.java.html" target="_blank">Integer n1 = new java/lang/Integer.java.html" target="_blank">Integer(3);
java/lang/Integer.java.html" target="_blank">Integer n2 = new java/lang/Integer.java.html" target="_blank">Integer(3);
java/lang/System.java.html" target="_blank">System.out.println(n1.quals(n2));//值为true

2．　　逻辑运算符

1）　　只能将and、or、not施用于boolean值身上。如果逻辑运算符两边的值存在non-boolean值，将会出错，如：

int test1 = 1;
java/lang/System.java.html" target="_blank">System.out.println((test && 1<2);//编辑出错，test是non-boolean值

3．　　位移运算符

如果所操作的位移对象是char、byte、short，位移动作发生之前，其值会先被晋升为int，运算结果会是int。

二．流程控制

1．　　迭代（iteration）

1.1　　逗号运算符

逗号运算符只能用于for循环的控制表达式中的initialization和step两部分中，如：for(int i=0, j=I+1; I<5; i++, j=I*2)

1.2　　break和continue

break表示退出循环；continue表示退出本次循环，回来循环起始位置。

1.3　　label

label只有放在迭代语句之前才起作用，在label和迭代语句之间插入任何语句都不会起作用。

2．　　Switch

switch中的选择器必须是int或char型，如：

float i = 2;

switch ( i )//将出错，因为i不是int或char之一

3．　　计算细节

1）　　从float或double转为整数值，总是以完全舍弃小数的方式进行。

4．　　Math.random()的输出范围是[0, 1]。

第4章　　初始化和清理

一．以构造函数（constructor）确保初始化的进行

如果某个class具备构造函数，Java便会在对象生成之际，使用者有能力加以操作之前，自动调用其构造函数，于是便能名确保初始化动作一定被执行。

二．函数重载（Method overloading）

1．　　区分重载函数

由于只能从函数名和函数的引数列来区分两个函数，而重载函数具有相同的函数名称，所以每个重载函数都必须具备独一无二的引数列。

2．　　Default构造函数

1）　　default构造函数是一种不带任何引数的构造函数。如果你所开发的class不具任何构造函数，编译器会自动为你生成一个default构造函数。

2）　　如果你自行定义了任何一个构造函数（不论有无引数），编译器就不会为你生成default构造函数。

3）　　如果定义了一个class，如

class Bush{
Bush(int I){}
}

当想用new Bush();来产生class的实例时，会产生错误。因为在定义class时已定义了构造函数，所以编译器就不会为class生成default构造函数。当我们用new Bush()来产生实例时，会尝试调用default构造函数，但在class中没有default构造函数，所以会出错。如：

class Sundae
{
Sundae(int i) {}
}
public class IceCream
{
public static void main(java/lang/String.java.html" target="_blank">String[] args)
{
//Sundae x = new Sundae();会编译出错，无构造函数Sundae()
Sundae y = new Sundae(1);
}
}

＊：在定义一个class时，如果定义了自己的构造函数，最好同时定义一个default构造函数

3．　　关键字this

1）　　this仅用于函数之内，能取得“唤起此一函数“的那个object reference。

2）　　在构造函数中，通过this可以调用同一class中别的构造函数，如

public class Flower{
Flower (int petals){}
Flower(java/lang/String.java.html" target="_blank">String ss){}
Flower(int petals, Sting ss){
//petals++;调用另一个构造函数的语句必须在最起始的位置
this(petals);
//this(ss);会产生错误，因为在一个构造函数中只能调用一个构造函数
}
}

＊＊：1）在构造调用另一个构造函数，调用动作必须置于最起始的位置

2）不能在构造函数以外的任何函数内调用构造函数

3）在一个构造函数内只能调用一个构造函数

4．　　Static的意义

无法在static函数中调用non-static函数（反向可行）。为什么不能呢，我们看下面的例子。

例4.2.4.1

假设能在static函数中调用non-static函数，那么（a）处就将出错。因为在没有产生Movie class实例之前，在就不存在Movie class内的name实例，而在getName()中却要使用name实例，显然的错误的。

class Movie{
java/lang/String.java.html" target="_blank">String name = “”;
Movie(){}
public Movie(java/lang/String.java.html" target="_blank">String name) { this.name = name; }
public static java/lang/String.java.html" target="_blank">String getName() { return name; }
}
public class Test{
public static void main(java/lang/String.java.html" target="_blank">String[] args){
//下面两名先产生实例后再调用getName()没有问题
//Movie movie1 = new Movie(“movie1”);
//String name1 = movie1.getName();
//下面一名将出错
//String name2 = Movie.getname(); （a）
}
}

三．清理（cleanup）：终结（finalization）与垃圾回收（garbage collection）

1）你的对象可能不会被回收

只有当程序不够内存时，垃圾回收器才会启动去回收不再被使用的对象的内存空间。某个对象所占用的空间可能永远不会被释放掉，因为你的程序可能永远不会逼近内存用完的那一刻，而垃圾回收器完全没有被启动以释放你的对象所占据的内存，那些空间便会在程序终止时才一次归还给操作系统

3）　　只有在采用原生函数（native methods）时，才使用finalize()。

四．成员初始化（member initialization）

1）　　函数中的变量不会被自动初始化，如

void f(){
int i;
i++;
}

将发生编译错误，因为i没有被初始化。

2）　　class的数据成员会被自动初始化，具体情况如下（见P220例子）：

基本型别：boolean：false、char：null（/u0000）、byte：0、short：0、int：0、

long：0 、float：0、double：0

对象（reference）：null

1．　　初始化次序

1）　　所有变量一定会在任何一个函数（甚至是构造函数）被调用之前完成初始化（见P233例子）

2）　　在产生一个class的对象（包含static成员的class的代码被装载）时，首先自动初始化class中的static成员变量，再执行所有出现于static数据定义处的初始化动作，最后执行static block，所有这些初始化操作只在第一次生成该对象时进行。

3）　　自动初始化class中的其它成员变量。

4）　　执行所有出现于数据定义处的初始化动作。如：int i=1；的执行顺序是先把I自动初始化为0，再执行数据定义处的初始化动作，初始化为1。

5）　　执行non-static block

6）　　调用构造函数。

例：

class Cup{
Cup(int marker){
java/lang/System.java.html" target="_blank">System.out.println("Cup(" + marker + ")");
}
void f(int marker){
java/lang/System.java.html" target="_blank">System.out.println("f(" + marker + ")");
}
}

class Cups{
static Cup c1 = new Cup(11);
static Cup c2;
Cup c3 = new Cup(33);
Cup c4;
{
c3 = new Cup(3);
c4 = new Cup(4);
}
static{
c1 = new Cup(1);
c2 = new Cup(2);
}
Cups(){
java/lang/System.java.html" target="_blank">System.out.println("Cups()");
}
}

public class ExplicitStatic{
public static void main(java/lang/String.java.html" target="_blank">String[] args){
java/lang/System.java.html" target="_blank">System.out.println("Inside main()");
Cups.c1.f(99);
}
static Cups x = new Cups();
static Cups y = new Cups();
}

结果为：
Cup(11)
Cup(1)
Cup(2)
Cup(33)
Cup(3)
Cup(4)
Cups()
Cup(33)
Cup(3)
Cup(4)
Cups()
Inside main()
f(99)

2．　　Array的初始化

1）　　定义数组时不能指定大小。如int[4] iArr = {0, 1, 2, 3};，由于指定了数组的大小，会编译出错。

2）　　数组只是存放reference的数组。Array与non-array的结构图如下：

a）对于基本型别数据，存放的是数据。如
int i = 5;

b）对于class变量，存放的是reference，这个reference指向一个存有class实例的内存空间。如
java/lang/String.java.html" target="_blank">String s = “hello”;

变量s存放的是一个reference，这个reference指向一个存有String实例的内存空间。

c）对于基本型别数组，存放的是reference数组，数组中的每一个reference都指向一个class实例的内存空间。如
int[] ia = {10, 11, 12};

数组ia存放的是一个reference数组，数组中的每一个reference都指向一个的int实例的内存空间。

d）对于class数组，存放的是reference数组，数组中的每一个reference都指向一个的class实例的内存空间。如
java/lang/String.java.html" target="_blank">String[] sa = {“hello1”, “hello2”, “hello3”};

数组sa存放的是一个reference数组，数组中的每一个reference都指向一个的String实例的内存空间。

3）　　任何数组都要进行初始化，使用没有进行初始化的数组会产生运行时错误，如：
int[] iArr;
java/lang/System.java.html" target="_blank">System.out.pritnln(iArr[0]);//产生错误，因为iArr还未初始化

数组初始化可在任何地方，可用以下方法来对数组进行初始化：

a）　　int[] iArr = {1,1,1,1};//数组的长度为{}元素的个数
b）　　int i = 10;

int[] iArr = new int[i];//数组的长度可为变量（这在C/C++中不行）

java/lang/System.java.html" target="_blank">System.out.println(iArr[0]);//iArr[0]是一个int，自动初始化值为0
java/lang/Integer.java.html" target="_blank">Integer[] iArr2 = new java/lang/Integer.java.html" target="_blank">Integer[i];
java/lang/System.java.html" target="_blank">System.out.println(iArr2[0]);//iArr[0]是一个reference，自动初始为null

I）　　对于基本型别数组，new产生的是用于存放数据的数组；否则，产生的只是存放reference的数组。

II）　　new可用来初始化基本型别的数组，但不能产生non-array的　　基本型别数据。

c）　　int[] iArr = new int[]{1,1,1,1};

java/lang/Integer.java.html" target="_blank">Integer[] iArr2 = new java/lang/Integer.java.html" target="_blank">Integer[]{new java/lang/Integer.java.html" target="_blank">Integer(1), new java/lang/Integer.java.html" target="_blank">Integer(2)};

3．　　多维数组（Multidimensional）arrays

多维数组每一维的大小可以不一样，如：

java/lang/Integer.java.html" target="_blank">Integer[][][] a5;
a5 = new java/lang/Integer.java.html" target="_blank">Integer[3];
for(int i=0; i<a5.length; i++)
a5[i] = new java/lang/Integer.java.html" target="_blank">Integer[i+1];
for(int j=0; j<a5[i].length
a5[i][j] = new java/lang/Integer.java.html" target="_blank">Integer[i+j+1];

第5章　　隐藏实现细节

一．Java访问权限饰词（access specifiers）

Java有public、protect、friendly、private四种访问权限，并且这四访问权限的访问范围越来越小。

1．　　friendly

1）　　果一个class内的数据成员或方法没有任何权限饰词，那么它的缺省访问权限就是friendly。同一个package内的其它所有classes都可以访问friendly成员，但对package以外的classes则形同private。

2）　　对于同一个文件夹下的、没有用package的classes，Java会自动将这些classes初见为隶属于该目录的default package，可以相互调用class中的friendly成员。如以下两个class分别在同一个文件夹的两个文件中，虽然没有引入package，但隶属于相同的default package。

class Sundae{
//以下两个方法缺省为friendly
Sundae(){}
java/lang/Void.java.html" target="_blank">Void f() {java/lang/System.java.html" target="_blank">System.out.println(“Sundae.f()”);
}
public class IceCream{
public static void main(java/lang/String.java.html" target="_blank">String[] args){
Sundae x = new Sundae();
x.f();
}
}

2．　　public：可以被任何class调用

3．　　private：private成员只能在成员所属的class内被调用，如：

class Sundae{
private Sundae(){}//只能在Sundae class中被调用
Sundae(int i) {}
static Sundae makASundae()　　{
return new Sundae();
}
}
public class IceCream{
public static void main(java/lang/String.java.html" target="_blank">String[] args){
// Sundae class中构造函数Sundae()是private，
// 所以不能用它进行初始化
//Sundae x = new Sundae();
Sundae y = new Sundae(1);//Sundae(int)是friendly，可以在此调用
Sundae z = Sundae.makASundae();
}
}

4．　　protected：具有friendly访问权限的同时，又能被subclass（当然包括子孙类，即子类的子类）所访问。即，既能被同一package中的classes访问，又能被protected成员所在class的subclass访问。

二．Class的访问权限

1．Class同样具有public、protect、friendly、private四种访问访问权限：

1）public：在任何地方都可被使用

2）protect、private：除了它自己，没有任何class可以使用，所以class不能是

protected或private（inner class除外）

3）　　friendly：同一个package中的classes能用

2．　　如何调用构造函数被声明为private的class

1）　　用static函数

2）　　用Singteton模式

class Soup{
private Soup(){}
//（1）静态函数方法
public static Soup makeSout(){
return new Soup();
}
//（2）The "Singleton" pattern:
private static Soup ps1 = new Soup();
public static Soup access(){
return ps1;
}
public void f(java/lang/String.java.html" target="_blank">String msg){
java/lang/System.java.html" target="_blank">System.out.println("f(" + msg + ")");
}
}
public class Lunch{
public static void main(java/lang/String.java.html" target="_blank">String[] args){
//Soup priv1 = new Soup();编译错误
Soup priv2 = Soup.makeSout();
Soup priv3 = Soup.access();
priv2.f("priv2");
priv3.f("priv3");
}