java编程思想

Chap1 对象简介

       1.抽象的过程

       Alan Kay总结了Smalltalk的五项基本特征。这些特征代表了纯的面向对象的编程方法：

       (1).万物皆对象。将对象想成一种特殊的变量；它存储数据，而且还可以让你“提要求”，命令它进行某些操作。从理论上讲，你可以把所有待解决的问题中的概念性组件（狗，建筑，服务等）都标识成程序里的对象。

       (2).程序就是一组相互之间传递消息的对象。你只要向那个对象“发一个消息”，就能向它提出要求。更确切的说，你可以这样认为，消息是调用专属某个对象的方法的请求。

       (3).每个对象都利用别的对象来组建它自己的记忆。换言之，你通过将已有的对象打成一个包，来创建新的对象。由此，你可以将程序的复杂性，隐藏在对象的简单性之下。

       (4).对象都有类型。任何对象都是某个类的实例(instance of a class)。用以区分类的最突出的特点就是“你能传给它什么消息？”

       (5).所有属于同一类型的对象能接受相同的消息。这种互换性(substitutability)是OOP最强大的功能之一。

       Booch还给对象下了个更为简洁的定义：

       对象有状态，行为和标识。

       这就是说，对象可以有内部数据（状态），有方法（因而产生了行为），以及每个对象都能同其它对象区分开来－－具体而言，每个对象在内存里都有唯一的地址。

       这句话或许有点太过了。因为对象还能存在于另一台及其上以及不同的内存空间中，此外还能保存在硬盘上。在这种情况下，对象的身份就不能用内存地址，而必须要用别的方法来确定。

     

       2.可凭借多态性相互替换的对象

       非OOP的编译器的做法称为前绑定(early binding)。编译器会产生那个名字的函数的调用，而连接器负责将这个调用解析成须执行的代码的绝对地址。在OOP中，不到运行的时候，程序没法确定代码的地址，所以向泛型对象发送一个消息的时候，就要用到一些特别的手段。

       OOP语言用了后绑定(late binding)的概念。当你向某个对象送了一个消息后，不到运行时，系统不能确定到底该调用哪段代码。编译器只保证这个方法存在，并且检查参数和返回值的类型（不这么做的语言属于弱类型weakly typed），但是它并不知道具体执行的是哪段代码。

       在有些语言中，你必须明确申明，某个方法要用到后绑定的灵活性（C++用virtual关键字）。在这些语言中，方法不是默认地动态绑定的。而动态绑定是 Java的缺省行为，因此无需添加什么额外的关键词就能获得多态性。

       将派生类当作它的基类来用的过程称为上传（upcast），反之称为下传（downcast）。下传所需的运行时检查会引起程序运行效率的降低，也加重了编程的负担。解决方案就是参数化类型(parameterized type)机制，即泛型。

     

       3.Collection和迭代器

       ArrayList和LinkedList，都是简单的线性序列，具有相同的接口和外部行为。对于ArrayList，随机访问是一种时间恒定的操作。然而对于LinkedList，随机访问和选取元素的代价会很大。另一方面，如果要在序列中插入元素，LinkedList的效率会比ArrayList的高出许多。

＝＝＝＝＝＝＝＝＝＝＝＝＝

Chap2 万物皆对象

       1.数据存在哪里

       数据可以存储在以下六个地方：

       (1).寄存器(registers)。这是反应最快的存储，因为它处在CPU里。但寄存器数量有限，由编译器分配，你不能直接控制。

       (2).栈(stack)。位于常规内存区里，CPU可以通过栈指针对它进行直接访问。栈指针下移就创建新的存储空间，上移就释放内存空间。这是仅次于寄存器的最快、最有效率的分配内存的方法。由于Java编译器必须生成能控制栈指针上下移的代码，所以程序编译的时候，那些将被存储在栈中的数据的大小和生命周期必须是已知的。Java把对象的reference存放在栈里。

       (3).堆(heap)。这是一段多用途的内存池，所有Java对象都保存在这里。在堆中分配空间时，编译器无需知道该分配多少空间，或数据会在堆里待多长时间。但是其速度比分配栈的慢些。

       (4).静态存储(static storage)。这里“静态”的意思是“在固定的位置”(尽管还是在RAM里面)。静态存储里面的数据在整个程序运行期间都能访问到。可以用 static关键词指明对象的某个元素是静态的，但是Java对象本身是决不会放到静态存储中去的。

       (5).固定存储(constant storage)。常量值通常直接放在程序里。有时常量还能为自己设置界限，这样在嵌入式系统中，就能选择是不是把它们放到ROM里面去。

       (6).非内存的存储(Non-RAM storage)。如果数据完全独立于程序，那么即使程序不运行，它也应该还在。对象被转化成某种能保存在其它介质上的东西，要用的时候，又能在内存里重建。Java提供了轻量级persistence的支持。

     

       特例：primitive类型

       primitive(原始)类型的变量直接保存值，并且存储在栈中。

     

       高精度的数值

       Java还包括两个能进行高精度算术运算的类：BigInteger和BigDecimal。

     

       作用域

       int x = 12;

       {

       int x = 100;//illegal

       }

     

       2.创建新的数据类型：类

       只有在“变量被用作类的成员”时，Java才能确保它获得默认值。本地变量，没有这种保障。

       不管在哪种情况下，Java在传递对象的时候，实际上是在传递reference。

     

     

     

＝＝＝＝＝＝＝＝＝＝＝＝

Chap3 控制程序流程

       1.运算符

       逗号运算符

       Java里面，唯一一个把逗号当运算符用的地方是for循环。

     

       String的+运算符

       加号(+)用在String上的时候，如果表达式中有String，那么Java编译器会把其他的操作数都转换成String。

       Java没有sizeof

       C和C++的sizeof()用于获取数据要占用多少字节的内存，需要sizeof的主要原因是为了移植。相同的数据类型在不同的机器上占用的内存长度可能会不一样。

       Java没有移植的问题，因此不需要sizeof，所有数据类型在所有的机器上都是相同的。

       运算符的总结

       在进行数学运算或混和赋值的时候，char，byte，short，都会先进行提升，运算结果也是int。如果要把结果赋给原先那个变量，就必须明确地进行类型转换。

       除了boolean之外，所有的primitive类型都能被转换成其它的primitive类型。

     

       2.执行控制

       Java不允许把数字当作boolean用，尽管C和C++允许这么做（非零值表示true，零表示false）。

     

       Java里，唯一能放标签的地方，就是在循环语句的外面。而且必须直接放－－在循环语句和标签之间不能有任何东西。而这么做的唯一理由就是，你会嵌套多层循环或选择。因为通常情况下break和continue关键词只会中断当前循环，而用了标签后，就会退到label所在的地方。

       label1:

       outer-iteration{

              inner-iteration{

                     break;//中断内循环，退到外循环

                     continue;//中断本次内循环，重新移到内循环开始处，执行下次内循环

                     continue label1;//中断本次外循环，移到外循环开始处，重新执行下次外循环

                     break label1;//退出外循环，执行循环以后的语句

              }

       }

       如果退出循环或选择的同时，还要退出方法，可以直接使用return。

       continue，break以及label的规则：

       (1).普通的continue会退到内部循环的最开始，然后继续执行内部循环。

       (2).带标签的continue会跳转到标签，并且重新进入直接跟在标签后面的循环。

       (3).break会从循环的“底部溜出去”。

       (4).带标签的break会从由这个标签标识的循环的“底部溜出去”。

       在Java里能使用标签的唯一理由就是，在嵌套循环的同时要用break和continue退出多层循环。

     

       3.switch

       switch会根据整数表达式的值（可以是char）决定应该运行哪些代码。

       找到匹配的值后，就会执行相应的case语句，不会再进行比较。通常case语句应该以break结束。否则会直接执行下一个case语句，而不会再次进行匹配。如果没有匹配的case，则执行default语句。

     

       计算细节

       将float或double转换成整数的时候，它总是将后面的小数截去。

       Math.random()会生成一个double，值域是[0,1)。

＝＝＝＝＝＝＝＝＝＝＝＝

Chap4 初始化与清理

       1.用构造函数确保初始化

       构造函数的名字必须与类的名字大小写完全相同。构造函数本身没有返回值，虽然new表达式会返回新创建对象的reference。

     

       2.默认的构造函数

       如果你写了一个没有构造函数的类，编译器会自动创建一个默认的构造函数（不带参数）。但是，只要你定义了构造函数，不管带不带参数，编译器就不会再自动合成默认构造函数了。

     

       3.this关键字与构造函数

       在类的构造函数中，可以用this(arg)调用另一个构造函数，但是不能调用两个构造函数（即this()在构造函数中只能出现0或1次）。此外，必须在程序代码的最前面调用构造函数。在非构造函数的方法里，不能用this()调用同一个类的构造函数。

     

       4.static的含义

       类的static方法只能访问其他的static方法和static数据成员，不能在static方法调用非static方法，但是反过来是可以的。

       但是，如果可以传一个对象的reference给static方法，就可以通过这个reference调用非static方法和非static数据成员。但要达到这个目的，通常应该使用非static的方法。

     

       5.清理：finalize和垃圾回收

       java提供finalize()方法，垃圾回收器准备释放内存的时候，会先调用finalize()。

       (1).对象不一定会被回收。

       (2).垃圾回收不是拆构函数。

       (3).垃圾回收只与内存有关。

       (4).垃圾回收和finalize()都是靠不住的，只要JVM还没有快到耗尽内存的地步，它是不会浪费时间进行垃圾回收的。

     

       6.成员的初始化

       方法中的局部变量，使用前必须进行初始化，否则编译器会给出错误消息。

       类的成员数据会被自动初始化，对于primitive变量，会被清零（char型也为0）；对于对象reference，会被赋值为null。

     

       7.指定初始化

       对类成员数据进行初始化时，可以调用方法获取初始值，该方法如果有参数，参数不能是类的其他尚未初始化的数据成员。可以这样：

       class Test{

              int i=f();

              int j=g(i);

       }

       不能这样：

       class Test{

              int j=g(i);//i尚未初始化

              int i=f();

       }

     

       8.初始化的顺序

       对类而言，初始化的顺序是由变量在类里定义的顺序决定的，变量的初始化会优先于任何方法，包括构造函数。

       创建对象的过程（小结,以Dog类为例）

       (1).第一次创建Dog类的对象（构造函数实际上是static方法），或者第一次访问Dog类的static的方法或字段的时候，Java解释器会搜寻classpath,找到Dog.class.

       (2).装载了Dog.class之后，（创建了Class对象之后），会对所有的static数据进行初始化。这样第一个装载Class对象的时候，会先进行static成员的初始化。

       (3).用new Dog()创建新对象的时候，Dog对象的构建进程会先在堆(heap)里为对象分配足够的内存。

       (4).这块内存先被清零，自动把Dog对象的primitive类型的成员赋缺省值（对于数字是零，或是相应的boolean和char），将 reference设成null。

       (5).执行定义成员数据时所作的初始化。

       (6).执行构造函数。可能牵涉到继承关系的很多活动。

     

       9.非静态的实例初始化

       实例初始化（instance initialization）语句，除了没有static关键字，其他与静态初始化没有两样。这种语法为匿名内部类(anonymous inner class)的初始化提供了必不可少的支持。

     

       10.数组的初始化

       Java可以将一个数组赋给另外一个，实际上是复制reference.

       可以用花括号括起来的对象列表初始化对象数组。有两种形式：

       Integer[] a = {

              new Integer(1),

              new Integer(2),

       };

       Integer[] b = new Integer[]{

              new Integer(1),

              new Integer(2),

       };

       列表的最后一个逗号是可选的，这个特性能使长列表的维护工作变得简单一些。  

     

     

     

＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝  

Chap5 隐藏实现

       1.package:类库的单元

       Java的源代码文件通常被称为编译单元(compilation unit)，必须是一个以.java结尾的文件，其中必须有一个与文件名相同的public类（大小写也必须相同，但不包括.java扩展名）。每个编译单元只能有一个public类。

       编译.java文件的时候，里面的每个类都会产生输出，文件名是类名，扩展名是.class。

       创建独一无二的package名字

       package语句必须是文件里的第一个非注释行。

       如果使用JAR文件打包package，必须把文件名放到CLASSPATH里面。

     

       冲突

       如果两个import语句所引入的类库都包含一个同名的类，只要不写会引起冲突的代码（不使用这个同名的类），就一切OK，否则编译器会报错。

       不论哪种对象，只要放进了String的表达式，就会被强制转化成该对象的String表示形式。如：

       System.out.print(""+100);//Force it to be a String

     

       2.Java的访问控制符

       Java的一个访问控制符只管它所定义的这一项，而C++的访问控制符会一直管下去，直到出现另一个。

       private:除非是用成员所在类的方法，否则一律不得访问。

       package访问权限（package access，有时也称为“friendly”），是默认的访问权限，没有关键词。同属一个package的类都能访问这个成员，但是对于不属于这个 package的类来说，这个成员就是private的。

       protected:继承的访问权限。protected也赋予成员package权限－－同一个package里的其它类也可以访问protected 元素。除此之外，继承类(不管是否在同一个package)也可以访问protected成员。

       public:访问接口的权限，任何类都能访问。

     

       3.类的访问权限

       类只有两种访问控制权，public和package。（inner class 可以是private或protected）

       每个编译单元（文件）只能有一个public类，也可以没有public类（不常见）。public类的名字必须和编译单元文件名大小写完全相同。如果没有public类，就可以随意给编译单元文件起名。

       对于package权限的类，通常应该将方法也设成package权限。

       如果不写类的访问控制符，默认是package权限的。package中的任何一个类都能创建这个类的对象，但是package以外的类就不行了。但是，如果这个类有一个public 的static成员，那么即使客户程序员不能创建这个类的对象，他们也还可以访问这个static成员。

     

     

     

＝＝＝＝＝＝＝＝＝＝＝＝＝＝     

Chap6 复用类

       1.合成所使用的语法

       对象的reference作为类的成员时，会被自动初始化为null。此外可以在三个时间对类的reference成员进行初始化：

       (1)在定义对象reference的时候。这就意味着，在类的构造函数调用前，已经初始化完毕了。

       private String a=new String("hello"), b="world";

       (2)在类的构造函数。

       (3)在即将使用对象reference之前。这被称为lazy或delayed initialization，如果创建对象的代价很大，或不是每次都需要创建对象，这种做法就能降低程序开销。

     

       2.基类的初始化

       当你创建一个派生类对象的时候，这个对象里面还有一个基类的子对象（subobject）。

       对于默认构造函数，即无参构造函数，Java会让派生类的构造函数自动地调用基类的构造函数。基类会在派生类的构造函数调用它之前进行初始化。

       对于带参数的构造函数，必须用super关键字以及合适的参数明确地调用基类构造函数，super()语句必须是派生类构造函数的第一条语句。

     

       3.确保进行妥善的清理

       不要依赖垃圾回收器去做任何与内存回收无关的事情。如果要进行清理，一定要自己写清理方法，别去用finalize()。

       清理的顺序：先按照创建对象的相反顺序进行类的清理，然后调用基类的清理方法。

     

       4.名字的遮盖（重载方法的覆盖）

       如果Java的基类里有一个被重载了好几次的方法，那么在派生类里重新定义那个方法，是不会把基类里定义的任何一个给覆盖掉的。（在C++里，就会把基类方法全都隐藏起来）

     

       5.用合成还是继承

       合成用于新类要使用旧类的功能，而不是其接口的场合。继承则是要对已有的类做一番改造，以获得一个特殊版本，即将一个较为抽象的类改造成能适用于某些特定需求的类。

       合成要表达的是“有（has-a）”关系，继承要表达的是一种“是（is-a）”关系。

       判断该用合成还是继承时，可以问一下是不是会把新类上传给基类。如果必须上传，那么继承就是必须的。

     

       6.final关键词

       6.1 final的数据

       常量能用于两种情况：（1）编译时的常量（compile-time constant），这样就再也不能改了；（2）运行时初始化的值，这个值你以后不想改了。

       如果是编译时常量，编译器会把常量放到表达式中，可以降低运行时的开销。Java中这种常量必须是primitive的，要用final表示，这种常量的赋值必须在定义的时候进行。

       当final修饰对象的reference时，表示reference是常量，初始化的时候，一旦将reference指向了某个对象，那么它就再也不能指向别的对象了。但是这个对象本身是可以修改的。

       final int v1 = 10;//compile-time constants

       final int v2 = rand.nextInt(100);//

       final Value v3 = new Value();//v3的数据成员是可变的

       final int[] arr={1,2,3};//arr的元素是可变的，如a[i]++;

       空白的final数据（Blank finals），是指声明了final成员，却没有在声明时赋值。编译器会强制在构造函数中初始化final数据。通过使用带参数的构造函数，根据参数对空白的final数据进行初始化，可以在保持final数据不变性的同时，提供一定的灵活性。

       可以把方法的参数声明为final的。

       6.2 final方法

       使用final方法有两个目的。第一，可以禁止派生类修改方法。第二，效率。对于final方法，编译器会把调用转换成“内联(inline)”，即用方法本身的拷贝来代替方法的调用。但是，如果方法很大，程序会很快膨胀，于是内联也不会带来什么性能的改善。

       只有是基类接口里的东西才能被覆写。如果基类的方法是private的，那它就不属于基类的接口。即使在派生类里创建了一个同名的方法，它同基类中可能同名的private方法没有任何联系。

       6.3 final类

       把类定义成final的，可以禁止继承这个类。final类的数据可以是final的，也可以不是。final类的方法都隐含地变成final了。

     

       7.初始化与类的装载

       在传统的编程语言中，程序启动的时候都是一次装载所有的东西，然后进行初始化，接下来再开始执行。这些语言必须仔细控制初始化的顺序。

       Java采用了一种新的装载模式。编译之后每个类都保存在它自己的文件里。不到需要的时候，这个文件是不会装载的。即“类的代码会在它们第一次使用的时候装载”，第一次访问static成员或创建对象的时候。

       继承情况下的初始化＝＝＝＝＝

       首次使用类的时候，装载器(loader)就会寻找类的.class文件，转载过程中，会依次追溯装载基类（不管是否创建基类对象，这个过程都会发生）。下一步，会执行“根基类(root base class)”的static初始化，然后是下一个派生类的static初始化，以此类推。

       所有类都装载结束，就可以创建对象了。首先对象里所有成员数据会被初始化为缺省值，这个过程是一瞬间完成的，对象的内存会被设置成二进制0。然后开始构造基类，基类的构造过程及顺序与派生类相同，先对基类的变量按字面顺序进行初始化，再调用基类的构造函数（调用是自动发生的，但你可以用super关键字指定要调用基类的哪个构造函数）。之后会对派生类的变量按定义的顺序进行初始化，最后执行派生类构造函数其余代码。

     

     

＝＝＝＝＝＝＝＝＝＝＝＝＝

Chap7 多态性

       1.方法调用的绑定

       将方法的调用连到方法本身被称为“绑定（binding）”。当绑定发生在程序运行之前时（由编译器或连接器负责），被称作“前绑定（early binding）”。

       “后绑定（late binding）”指在程序运行时，根据对象类型决定该绑定哪个方法。后绑定也被称为“动态绑定(dynamic binding)”或“运行时绑定（run-time binding）”。

       除了static和final方法（private方法隐含有final的意思），Java的所有方法都采用后绑定。

     

       2.错误：“覆写”private的方法

       public class Parent{

              private void f(){

              //...

              }

              public static void main(String[] args){

                     Parent pa = new Child();

                     pa.f();//执行的是Parent.f()

              }

       }

       class Child extends Parent{

              public void f(){

              //...

              }

       }

       应该避免用基类的private的方法名去命名派生类中方法。

       只有非private的方法才能被覆写。

     

       3.继承与清理

       清理的顺序应该与初始化的顺序相反。对数据成员而言，清理顺序就应该与声明的顺序相反。

       在派生类的清理方法（比如dispose()）的最后，应该调用基类的清理方法。

     

       4.多态方法在构造函数中的行为

       如果在构造函数里调用了动态绑定的方法，那么它会调用那个覆写后的版本。

       abstract class Glyph{

              abstract void draw();

              Glyph(){

                     System.out.println("Glyph() before draw()");

                     draw();

                     System.out.println("Glyph() after draw()");

              }

       }

       class RoundGlyph extends Glyph{

              private int radius = 1;

              RoundGlyph(int r){

                     radius = r;

                     System.out.println("RoundGlyph.RoundGlyph(),radius = " + radius);

              }

              void draw(){

                     System.out.println("RoundGlyph.draw(),radius = " + radius);

              }

       }

       public class PolyConstructors{

              public static void main(String[] args){

                     new RoundGlyph(5);

              }

       }

       //输出＝＝＝＝＝＝＝＝

       //Glyph() before draw()

       //RoundGlyph.draw(), radius = 0

       //Glyph() after draw()

       //RoundGlyph.RoundGlyph(), radius = 5

       上面程序中，Glyph的构造函数调用了draw()，而这个调用最后落到了RoundGlyph.draw()。而此时radius的值还没有被初始化为1，还是0。

     

       真正的对象初始化过程：

       (1)类加载结束，并且static初始化结束后，在进行其它工作之前，分配给这个对象的内存会被初始化为二进制的0。

       (2)构造基类，调用基类的构造函数。这时会调用被覆写的draw()方法（在调用RoundGlyph的构造函数之前），受第一步的影响，radius 的值还是0。

       (3)数据成员按照声明的顺序进行初始化。

       (4)调用派生类的构造函数的正文。

     

       5.用继承来进行设计

       一般准则：使用继承来表示不同的行为，使用成员数据（合成）来表示不同的状态。

     

       6.总结

       人们通常会把多态性同Java的那些非面向对象的特性相混淆，比如方法的重载，它常常会被当作面向对象的特性介绍给大家。千万别上当：不是后绑定的，就不是多态性。

     

     

     

＝＝＝＝＝＝＝＝＝＝＝

Chap8 接口与内部类

       1.接口（interface）

       interface也可以包含数据成员，但是它天生就是public，static和final的。

       interface默认是package权限的，只能用于同一个package。也可以加上public（只有保存在同名文件里的interface才可以加）。

       可以把interface里的方法声明成public的，但是即便不写public关键词，这些方法也自动是public的。当implements一个 interface的时候，必须把这个interface的方法定义成public的。

     

       2.Java的“多重继承”

       由于interface不带任何“实现”－－也就是说interface和内存无关－－因此不会有谁去阻挠interface之间的结合。

       到底是用interface，还是用abstract类？只要基类的设计里面可以不包括方法和成员变量的定义，就应该优先使用interface。只有在不得不定义方法或成员变量的情况下，才把它改成abstract类。

     

       3.合并接口时的名字冲突

       在要合并的接口里面放上同名的方法，通常会破坏程序的可读性，应该避免。

     

       4.用继承扩展interface

       可以用继承往interface里添加新的方法，也可以把多个interface合并成一个新的interface。使用extends关键词，多个“基接口(base interface)”之间用逗号分割。

       interface Vampire extends IMonster, IUndead{}

     

       5.常量的分组

       由于interface的数据成员自动就是public，static和final的，因此interface是一种非常方便的创建一组常量值的工具。这点同C和C++的enum很相似，但没有enum那样的类型安全。

     

       6.接口的嵌套

       接口既可以嵌套在类里，也可以嵌套在接口里面。

       实现接口的时候，不一定要实现嵌套在里面的接口。同样，private接口只能在定义它的类里实现。

     

       7.内部类(inner class)

       内部类与合成是截然不同的。

       除非是在“宿主类(outer class)”的非static方法里面，否则无论在哪里创建内部类的对象，都必须用OuterClassname.InnerClassName的形式来表示这个对象的类型。

     

       8.内部类与上传

       内部类可以被定义成private或protected，非内部类只可能是public或package权限的。

     

       9.在方法和作用域里的内部类

       在方法的某个作用域里定义的内部类，比如if语句里，并不意味着这个类的创建是有条件的－－它会同别的东西一起编译。但是，这个类的访问范围仅限于定义它的那个作用域。除此之外，它同普通的类没有区别。

     

       10.匿名内部类

       public class Parcel6{

              public Contents cont(){

                     return new Contents(){

                            private int i = 11;

                            public value(){return i;}

                     };//Semicolon required

              }

       }

       上例中return new Contents(){...}语句表达的是：创建一个继承Contents的匿名类的对象。new语句所返回的reference对自动上传到 Contents。这个return语句是如下代码的简化形式：

       class MyContents implements Contents{

              private int i = 11;

              public int value(){return i;}

       }

       return new MyContents();

       这个匿名内部类是通过默认构造函数来创建Contents的，如果基类需要的是一个带参数的构造函数，可以直接将参数传给基类的构造函数，return new Contents(x){...}。

       如果在定义匿名内部类的时候，要用到外面的对象，编译器会要求把这个参数的reference声明成final的。

       public class Parcel8{

              //Argument must be final to use inside anonymous inner class

              public Destination dest(final String ds){

                     return new Destination(){

                            private String lbl = ds;

                            public String readLabel(){return lbl;}

                     };

              }

       }

       不能在匿名内部类里创建构造函数（因为它根本就没有名字），但是可以通过“实例初始化(instance initialization)”（与static初始化对应），进行一些类似构造函数的操作。实际上实例初始化过程就是匿名内部类的构造函数。但它的功能是有限的，由于不能重载实例初始化，因此只能有一个构造函数。

       public Base getBase(int i){

              return new Base(i){

                     {

                            System.out.println("Inside instance initializer.");

                     }

                     public void f(){

                            System.out.println("In anonymous f().");   

                     }

              };

       }

     

       11.与宿主类的关系

       内部类能访问宿主类的所有成员。内部类对象里存在一个隐蔽的指向宿主类对象的reference，由编译器处理。

     

       12.嵌套类(静态内部类)

       如果不需要这种“内部类对象和宿主类对象之间的”联系，可以把内部类定义成static的，通常被称作“嵌套类(nested class)”。嵌套类的意思是：

       (1)无需宿主类的对象就能创建嵌套类的对象。

       (2)不能在嵌套类的对象里面访问非static的宿主类对象。

       此外，嵌套类同普通的内部类还有一点不同。普通的内部类的成员数据和方法只能到类的外围这一层，因此普通的内部类里不能有static数据，static 数据成员或嵌套类。但是，这些东西在嵌套类里都可以有。

       嵌套类可以是interface的一部分。

       每个类可以带一个供测试的main()方法，但编译后，会产生额外的代码。可以考虑在嵌套类里创建供测试的main()。编译后会产生单独的名称如 Test$NestedTester.class的文件，发布的时候可以删除这个文件。

     

       13.引用宿主类的对象

       在内部类里通过宿主类名字后面加句点再加this来表示宿主类对象的reference。比如类Sequence.Selctor里，可以用 Sequence.this来获取它所保存的宿主类Sequence对象的reference。

       要在其他地方创建内部类的对象，就必须在new表达式里面给出宿主类对象的reference。如：

       Parcel11 p = new Parcel11();

       //Must use instance of outer class to create an instance of the inner class.

       Parcel11.Contents c = p.new Contents();

     

       14.在多层嵌套的类里向外访问

       内部类的嵌套层次不是问题－－它可以透明地访问它的各级宿主类的成员。

       class MNA{

              private void f(){}

              class A{

                     private void g(){}

                     public class B{

                            void h(){

                                   g();

                                   f();

                            }

                     }

              }

       }

     

       public class MultiNestingAccess{

              public static void main(String[] args){

                     MNA mna = new MNA();

                     MNA.A mnaa = mna.new A();

                     MNA.A.B mnaab = mnaa.new B();

                     mnaab.h();

              }

       }

       ".new"语句指明了正确的作用域，因此无需在调用构造函数的语句里再限定类的名字了。

     

       15.继承内部类

       class WithInner(){

              class inner{}

       }

       public class InheritInner extends WithInner.Inner{

              //!InheritIner(){}//Won't compile

              InheritIner(WithInner wi){

                     wi.super();

              }

              public static void main(String[] args){

                     WithInner wi = new WithInner();

                     InheritInner ii = new InheritInner(wi);

              }   

       }

       InheritInner继承的只是内部类，默认的构造函数不能通过编译。必须传递宿主类对象的reference。此外，必须在构造函数里面使用这种语法：enclosingClassReference.super();这样才能提供那个必须的reference，才能编译通过。

     

       16.内部类可以被覆写吗

       像覆写宿主类的方法那样去“覆写”内部类，是不会有实际效果的。但是，可以在继承类的内部类明确继承基类的内部类。

       public class BigEgg2 extends Egg2{

              public class Yolk extends Egg2.Yolk{

              }

       }

     

       17.本地内部类(Local inner classes)

       本地内部类是在代码段，通常是方法的正文部分创建的。本地内部类不能有访问控制符，因为它并不属于宿主类，但它可访问当前代码段的final变量，以及宿主类的所有成员。

       由于本地内部类的名字在代码段（通常是一个方法）外面是没法访问的，因此选择本地内部类来代替匿名内部类的一个理由就是，需要一个有名字的构造函数，并要重载这个构造函数，因为匿名内部类只能进行实例初始化。另一个理由是，需要创建多个那种类的对象。

     

       18.内部类的标识符

       宿主类名字，加上"$"，再加上内部类的名字。如果是匿名内部类，编译器会直接用数字来表示。

       如：OuterClass$InnerClass.class，OuterClass$2.class。

     

       19.为什么要有内部类？

       每个内部类都可以独立的继承某个“实现(implementation)”。内部类能在事实上继承多个实体类或abstract类。可以把它当作彻底解决多重继承问题的办法，接口部分地解决了这个问题。

     

     

     

     

＝＝＝＝＝＝＝＝

Chap9     用异常来处理错误

       1.重抛异常

       如果直接重抛当前的异常，则printStackTrace()所打印出来的那些保存在异常对象里的信息，还会指向异常发生的地方，不会被指到重抛异常的地点。如果要装载新的栈轨迹信息，你可以调用fillInStackTrace()。

       try{

              f();

       } catch(Exception e){

              e.printStackTrace();

              //throw e;//17

              throw e.fillInStackTrace();//18

       }

     

       也可以抛出一个与捕捉到的异常不同的异常。这么做的效果同使用fillInstackTrace()的差不多－－异常最初在哪里发生的信息被扔了，现在里面保存的时抛出新异常的地点。

     

       2.异常链

       异常链可以在捕捉到一个异常并且抛出另一个异常的时候，仍然保存前一个异常的信息。