Tag/
共15个网摘 [
1 ] |
icecityman收录，使用标签：Think, in, java学习笔记，时间：2008-9-12 22:23:38 | 相关网摘，我也收藏
第3章控制程序流程
“就象任何有感知的生物一样，程序必须能操纵自己的世界，在执行过程中作出判断与选择。”
第一部分：Java运算符
“=”、“＝＝”和“!=” 能操作所有对象。
String类支持“+”和“+=”。
>，<，>=，<=，比较不适用于boolean类型。
其余运算符都只能操作“基本数据类型”（Primitives）。
一、 赋值运算符：＝
1. 赋值运算符（=），它的意思是“取得右边的值，把它复制到左边”。右边的值可以是任何常数、变量或者表达式，只要能产生一个值就行。但左边的值必须是一个明确的、已命名的变量。也就是说，它必须有一个物理性的空间来保存右边的值。
2. 对主（Primitives）数据类型的赋值。主类型容纳了实际的值，可将一个地方的内容复制到另一个地方。例如，假设为主类型使用“A=B”，那么B处的内容就复制到A。若接着又修改了A，那么B根本不会受这种修改的影响。
3. 对一个对象赋值，我们真正操作的是它的句柄。所以倘若“从一个对象到另一个对象”赋值，实际就是将句柄从一个地方复制到另一个地方。这意味着假若为对象使用“C=D”，那么C和D最终都会指向最初只有D才指向的那个对象。Assignment.java
4. 扩展赋值运算符:
a = a>>>b
a >>>= b
>>>=
a = a>>b
a >>= b
>>=
a = a<
a <<= b
<<=
a = a^b
a ^= b
^=
a |= b
a &= b
a %= b
a /= b
a *= b
a -= b
a += b
用法举例
a = a|b
|=
a = a&b
&=
a = a%b
%=
/=
*=
-=
+=
运算符
a = a/b
a = a*b
a = a-b
a = a+b
等效的表达式
二、 算术运算符：+，―，*，/，%，++，――
1. 整数除法会直接砍掉小数，而不是进位。
2. 前递增和前递减（如++A或--A），会先执行运算，再生成值。后递增和后递减（如A++或A--），会先生成值，再执行运算。
例：AutoInc.java
三、 关系运算符：>，<，>=，<=，＝＝，!=
1. 关系运算符生成的是一个“布尔”（Boolean）结果。它们评价的是运算对象值之间的关系。若关系是真实的，关系表达式会生成true（真）；若关系不真实，则生成false（假）。
2. 检查对象是否相等
1) ＝＝和!=比较的是对象句柄。例：Equivalence.java
2) equals()方法。 [Usage：n1.equals(n2)]例：EqualsMethod.java
ü 不适用于“主类型”。
注意：可以比较封装器类型和主类型和常数。
ü 当用equals()方法进行比较时，对类File、String、Date及封装类（Wrapper Class）来说，是比较类型及内容而不考虑引用的是否是同一个实例；
ü equals()的默认行为是比较句柄。要想比较对象必须重新实现它例：EqualsMethod2.java
ü 大多数Java类库都实现了equals()，所以它实际比较的是对象的内容，而非它们的句柄。
四、 逻辑运算符：&,|,!,^,&&,||
1. 只能应用于布尔值。不可将一个非布尔值当作布尔值在逻辑表达式中使用。
2. 逻辑运算符功能
！-- 逻辑非 & -- 逻辑与 | -- 逻辑或
^ -- 逻辑异或 &&-- 短路与 || -- 短路或
3. 短路：如果一个逻辑表达式的所有部分都不必执行下去，那么潜在的性能提升将是相当可观的。
&& -- 第一个操作数为假则不判断第二个操作数
|| -- 第一个操作数为真则不判断第二个操作数
例：ShortCircuit.java五、按位运算符：&，|，^，~
1. 按位运算符允许我们操作一个整数主数据类型中的单个“比特”，即二进制位。按位运算符会对两个自变量中对应的位执行布尔代数，并最终生成一个结果.
2. Java整数进制转换
ü Java语言二进制数采用补码形式，数正负区分标志：符号位
ü 正数进制转换
Ø 十进制----二进制：除2取余、除尽为止
Ø 二进制----十进制：累加求和
ü 负数进制转换
Ø 十进制----二进制：
•取绝对值
•转换为二进制
•逐位取反
•加1
Ø 二进制----十进制
•减1
•逐位取反
•转换为十进制正数
•乘-1
六、 移位运算符：<<，>>，>>>
1. 移位运算符面向的运算对象也是二进制的“位”。可单独用它们处理整数类型（主类型的一种）
2. 左移<<
ü 将运算符左边的运算对象向左移动运算符右侧指定的位数（在低位补0）
ü "a<>
ü 将运算符左边的运算对象向右移动运算符右侧指定的位数。
ü "a>>b; "将二进制形式的a逐位右移b位，最高位空出的b位补原来的符号位；
ü “有符号”右移位运算符使用了“符号扩展”：若值为正，则在高位插入0；若值为负，则在高位插入1。
4. 无符号右移>>>
ü 它使用了“零扩展”：无论正负，都在高位插入0。这一运算符是C或C++没有的。
ü "a>>>b;"将二进制形式的a逐位右移b位，最高位空出的b位补0。
5. 移位运算符性质
ü 适用数据类型:byte、short、char、int、long，对低于int型的操作数将先自动转换为int型再移位
ü 对于int型整数移位a>>b，系统先将b对32取模，得到的结果才是真正移位的位数
ü 对于long型整数移位时a>>b ，则是先将移位位数b对64取模
ü 在进行“无符号”右移位时，也可能遇到一个问题。若对byte或short值进行右移位运算，得到的可能不是正确的结果（Java 1.0和Java 1.1特别突出）。它们会自动转换成int类型，并进行右移位。但“零扩展”不会发生，所以在那些情况下会得到-1的结果。
七、三元if-else运算符：布尔表达式 ? 值0:值1
1. 若“布尔表达式”的结果为true，就计算“值0”，而且它的结果成为最终由运算符产生的值。但若“布尔表达式”的结果为false，计算的就是“值1”，而且它的结果成为最终由运算符产生的值。
八、 逗号运算符
在Java里需要用到逗号的唯一场所就是for循环
九、字串运算符+
1. "+"运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接
2. 注意：对于Java的早期版本，如果想通过“加号”连接字串，请务必保证第一个元素是字串。
十、 造型运算符
十一、
十二、
http://blog.csdn.net/wangr1978/archive/2006/07/03/869847.aspx
icecityman收录，使用标签：Think, in, java学习笔记，时间：2008-9-12 22:23:11 | 相关网摘，我也收藏
初始化和清除
“随着计算机的进步，‘不安全’的程序设计已成为造成编程代价高昂的罪魁祸首之一，初始化和清除是这些安全问题的其中两个。”
一、构造方法(constructor)
如果类有构造函数，那么JAVA会在对象刚刚创建，用户还来不及使用的时候，自动调用那个类的构造函数初始化这个将要被使用的对象。
1、 构造方法的名字必须与类名完全相同！首字母不小写。
原因：
ü 使用其他名字可能与类中的成员方法的名字冲突。
ü 告诉编译器那个是构造方法，保证在对象初始化期间自动调用构造方法。
例：SimpleConstructor.java
2、 构造方法可以使用自变量，一个类可以有多个不同的构造方法。这样我们就可以选择我们创建对象的方式。
例：SimpleConstructor.java
3、 对象的创建和初始化是同一个概念，不能要这个不要那个。
4、 没有自变量的构造方法称作“默认构造方法”。 一旦显式定义了构造方法，则系统不再提供默认构造方法。
例：DefaultConstructor.java5、 子类继承父类所有的成员方法，但不继承父类的构造方法
6、 构造方法没有返回值。这与void返回值存在着明显的区别。New表达式会返回新建这个对象的句柄（reference）。
二、方法重载
1、 方法名相同，自变量列表不同
2、 方法重载可应用于构造方法，亦可应用于其他任何方法。
例：Overloading.java
3、 区分重载方法：必须采取独一无二的自变量类型列表；不用自变量的顺序来区分两个方法；不能根据返回值类型来区分过载的方法。
例：OverloadingOrder.java4、 基本类型的过载：
实参类型“小于”形参类型：实参类型就会自动转换为形参类型处理。常数和char转换为int,
实参类型“大于”形参类型：必须把实参类型强制转化为形参类型，否则会报错。
例：PrimitiveOverloading.java，Demotion.java三、this关键字
1、 引入
类A和类B有相同的方法f（）。内部的调用过程：
class Banana { void f(int i) { /* ... */ } }
Banana a = new Banana(), b = new Banana();
a.f(1);
b.f(2);
实际上是：
Banana.f(a,1);
Banana.f(b,2);
2、 this关键字代表当前对象的一个引用。
3、 在构造方法里调用其他构造方法时必须用this(自变量列表或空)。且只能调用一个，必须放在方法开始一行。例：Flower.java
4、 return this;返回当前对象的引用。例：Leaf.java
5、 方法自变量的名字与类成员变量的名字相同时，用this. 变量名来表示成员变量。
四、static的含义
1、 什么时候用static（静态）关键字
1) 一种情形是只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创建对象。
2) 另一种情形是我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能调用的方法。
2、 static的含义
1) 它意味着一个特定的方法没有this。
2) 我们不可从一个static方法内部发出对非static方法的调用
3) 而且在没有任何对象的前提下，我们可针对类本身发出对一个static方法的调用。
4) 一旦将什么东西设为static，数据或方法就不会同那个类的任何对象实例联系到一起。
5) 为了将数据成员或方法设为static，只需在定义前置和这个关键字即可。例如，下述代码能生成一个static数据成员，并对其初始化：
class Static Test {
Static int i = 47;
}
现在，尽管我们制作了两个StaticTest对象，但它们仍然只占据StaticTest.i的一个存储空间。这两个对象都共享同样的i。
6) 有两个办法可引用一个static变量。正如上面展示的那样，可通过一个对象命名它，如st2.i。亦可直接用它的类名引用，（最好用这个办法引用static变量，因为它强调了那个变量的“静态”本质）
五、清除：收尾和垃圾收集
1、 垃圾收集的原理
1) 垃圾收集器只知道释放那些由new分配的内存
2) 在理想情况下，它的工作原理应该是这样的：一旦垃圾收集器准备好释放对象占用的存储空间，它首先调用finalize()，而且只有在下一次垃圾收集过程中，才会真正回收对象的内存。
3) 垃圾收集并不等于“破坏”！ Java对象并非肯定能作为垃圾被“收集”去。垃圾收集不等于清除，当我们不需要一个对象之前，必须创建一个原始的方法，用它来进行这种清除。我们的对象可能不会当作垃圾被收掉！有时可能发现一个对象的存储空间永远都不会释放，因为自己的程序永远都接近于用光空间的临界点。若程序执行结束，而且垃圾收集器一直都没有释放我们创建的任何对象的存储空间，则随着程序的退出，那些资源会返回给操作系统。这是一件好事情，因为垃圾收集本身也要消耗一些开销。如永远都不用它，那么永远也不用支出这部分开销。
2、 为什么要用finalize（）？
1) 垃圾收集只跟内存有关！垃圾收集器存在的唯一原因是为了回收程序不再使用的内存。自己写的finalize()方法，也必须同内存以及内存释放有关。不论对象以什么方式创建，内存都是由垃圾回收器负责的。不必过多地使用finalize()，finalize()最有用处的地方之一是观察垃圾收集的过程。例：Garbage.java
3、 若希望执行除释放存储空间之外的其他某种形式的清除工作，仍然必须调用Java中的一个方法。它等价于C++的破坏器，只是没后者方便。
4、 为强制进行收尾工作，可先调用System.gc()，再调用System.runFinalization()。这样可清除到目前为止没有使用的所有对象。
六、类成员变量的初始化
1、 默认初始化：一个类的数据成员都会保证获得一个初始值。
例：InitialValues.java
2、 规定初始化
1) 定义变量的同时也为其赋值
2) 可通过调用一个方法来提供初始值：这个方法亦可使用自变量，但那些自变量不可是尚未初始化的其他类成员。
3、 在构造方法内部初始化：先执行默认初始化。
4、 成员变量的初始化顺序
1) 在一个类里，初始化的顺序是由变量在类内的定义顺序决定的。
例：OrderOfInitialization.java
2) 成员变量在调用任何方法（包括构造方法）之前得到初始化。
5、 静态数据的初始化
1) static初始化只有在必要的时候才会进行。只被初始化一次。
2) 初始化的顺序是首先static（如果它们尚未由前一次对象创建过程初始化），接着是非static对象。
例：StaticInitialization.java
3) 对象的创建过程。请考虑一个名为Dog的类：
ü Java解释器找到Dog.class（在事先设好的类路径里搜索）。
ü 找到Dog.class后（它会创建一个Class对象），它的所有static初始化模块都会运行。因此，static初始化仅发生一次——在Class对象首次载入的时候。
ü 创建一个new Dog()时，Dog对象的构建进程首先会在内存堆（Heap）里为一个Dog对象分配足够多的存储空间。
ü 这种存储空间会清为零，将Dog中的所有基本类型设为它们的默认值
ü 进行字段定义时发生的所有初始化都会执行。
ü 执行构建器。
6、 静态块
例：ExplicitStatic.java
7、 非静态块
例：Mugs.java
七、数组初始化
1、 数组的定义：type[] name;或type name[]
2、 编译器不允许我们告诉它一个数组有多大。我们拥有的一切就是指向数组的一个句柄，而且尚未给数组分配任何空间。为了给数组创建相应的存储空间，必须编写一个初始化表达式。
3、 对于数组，初始化工作可在代码的任何地方出现，但也可以使用一种特殊的初始化表达式，它必须在数组创建的地方出现。这种特殊的初始化是一系列由花括号封闭起来的值。存储空间的分配（等价于使用new）将由编译器在这种情况下进行。例如：
int[] a1 = { 1, 2, 3, 4, 5 };
那么为什么还要定义一个没有数组的数组句柄呢？
int[] a2;
事实上在Java中，可将一个数组分配给另一个，所以能使用下述语句：
a2 = a1;
4、 这里也出现了一些新东西：所有数组都有一个本质成员（无论它们是对象数组还是基本类型数组），可对其进行查询——但不是改变，从而获知数组内包含了多少个元素。这个成员就是length。由于Java数组从元素0开始计数，所以能索引的最大元素编号是“length-1”。一旦超过边界，就生成一个运行期错误（即一个“违例”，这是第9章的主题）。
5、 程序编写期间，如果不知道在自己的数组里需要多少元素，那么又该怎么办呢？此时，只需简单地用new在数组里创建元素。在这里，即使准备创建的是一个基本数据类型的数组，new也能正常地工作（new不会创建非数组的基本类型）：
例：ArrayNew.java
6、 若操作的是一个非基本类型对象的数组，那么无论如何都要使用new。
例：ArrayClassObj.java
7、 多维数组
例：MultiDimArray.java
http://blog.csdn.net/wangr1978/archive/2006/07/03/869829.aspx
icecityman收录，使用标签：Think, in, java学习笔记，时间：2008-9-12 22:22:22 | 相关网摘，我也收藏
“进行面向对象的设计时，一项基本的考虑是：如何将发生变化的东西与保持不变的东西分隔开。”
为什么?
库的用户（client programmer）：必须应该知道他可以使用那些类的成员和方法。
库的创建者：为了以后能对库自由地进行修改与改进，同时保证客户程序员代码不会受到那些变动的影响；因此他需要声明哪些东西是客户程序员可以使用的，哪些是不可使用的。把所有不想被用户使用的都声明为private.
5.1包（package）：库单元
一、 import关键字：引入java源程序中用到的包或包里的成员，放在java源程序的开头
1、 引入包中所有的类
例：import java.util.*;－引入java\util包中所有的类。
2、 引入包里的一个类
例：import java.util.Vector;－引入java\util包中Vector类。
3、 目的：提供一种特殊的机制，以便管理一个对因特网友好的“命名空间”（Name Space）。即，类名全球唯一。
二、 编译单元：Java创建的一个源码文件。
1、 每个编译单元都必须有一个以.java结尾的名字。在编译单元的内部，可以有且只能有一个公共（public）类，它必须拥有与文件相同的名字（包括大小写形式，但排除.java文件扩展名）；这个编译单元中剩下的类（如果有的话），对于这个编译单元包外面的世界是隐藏的，不可以访问的。
2、 编译一个.java文件时，对于.java文件中的每个类，都会得到一个.class文件。一个有效的程序就是一系列.class文件，它们可以封装和压缩到一个JAR文件里（使用Java 1.1提供的jar工具）。Java解释器负责对这些文件的寻找、装载和解释。
三、 包的定义：一个库中一堆.class文件。
1、 package关键字：指明编译单元所属的包
例：package mypackage;
package语句必须作为文件的第一个非注释语句出现。该语句的作用是指出这个编译单元属于名为mypackage的一个库的一部分。或者换句话说，它表明这个编译单元内的public类名位于mypackage这个名字的下面。如果其他人想使用这个类，要么指出完整的名字-包.类名，要么与使用import关键字。注意根据Java包（封装）的约定，包名字内的所有字母都应小写。
2、 库设计者，一定要记住package和import关键字允许我们做的事情就是分割单个全局命名空间，保证我们不会遇到名字的冲突
3、 java中的包没有管理机制，只要我们声明我们的类属于一个包，就可使用包中除private的类。
四、 CLASSPATH的陷阱
1、 Java解释器的工作程序如下：首先，它找到环境变量CLASSPATH。CLASSPATH包含了一个或多个目录，它们作为一种特殊的“根”使用，从这里展开对.class文件的搜索。从那个根开始，解释器会寻找包名，并将每个点号（句点）替换成一个斜杠，从而生成从CLASSPATH根开始的一个路径名。随后将它们连接到一起，成为CLASSPATH内的各个条目（入口）。以后搜索.class文件时，就可从这些地方开始查找与准备创建的类名对应的名字。此外，它也会搜索一些标准目录——这些目录与Java解释器驻留的地方有关。
2、 务必保证对于类路径的每个地方，每个名字都仅存在一个类。
3、 CLASSPATH就是类库所在的目录。
4、 当用多个.*引入多个包时，如果存在相同的类名，必须带上包名使用。
五、 包的两个额外的作用
1、 自定义工具库
不论什么对象，只要放入String表达式，他就会被强制转化为这个对象的String表达形式。
2、 利用导入改变行为
5.2 Java访问指示符：“友好的”，public，private，protected
Java访问指示符都置于数据成员和方法的最前面。
一、“友好的”：包中有效。
1、 不指定访问指示符，默认就是friendly.
2、 当前包内的其他所有类都能访问“友好的”成员和方法，但对包外的所有类来说，这些成员却是“私有”（Private）的，外界不得访问。
二、public：接口访问。
1、 在public后面的成员声明适用于所有人，
2、 默认包：处于同一个目录下的.class，没有定义package，这个目录就是这些.class的一个默认包。
三、private：不能接触！
1、 private关键字意味着除非那个特定的类，而且从那个类的方法里，否则没有人能访问那个成员。
四、protected：友好的＋子类可以访问
5.3类访问
1、 每个编译单元（文件）都只能有一个public类。每个编译单元有一个公共接口的概念是由那个公共类表达出来的。根据自己的需要，它可拥有任意多个提供支撑的“友好”类。但若在一个编译单元里使用了多个public类，编译器就会向我们提示一条出错消息。
2、 public类的名字必须与包含了编译单元的那个文件的名字完全相符，甚至包括它的大小写形式。
3、 可能（但并常见）有一个编译单元根本没有任何公共类。此时，可按自己的意愿任意指定文件名。
4、 对于类的访问只有两个选择：“友好的”或者public。若不愿其他任何人访问那个类，可将所有构建器设为private。这样一来，在类的一个static成员内部，除自己之外的其他所有人都无法创建属于那个类的一个对象
http://blog.csdn.net/wangr1978/archive/2006/07/03/869760.aspx
icecityman收录，使用标签：Think, in, java学习笔记，时间：2008-9-12 22:21:53 | 相关网摘，我也收藏
第6章 合成
一、合成的语法
对象引用初始化，可在下面这些地方进行：
(1) 在对象定义的时候。这意味着它们在构建器调用之前肯定能得到初始化。
(2) 在那个类的构建器中。
(3) 紧靠在要求实际使用那个对象之前。这样做可减少不必要的开销——假如对象并不需要创建的话。
Bath.java
在类内作为字段使用的基本数据会初始化成零；对象句柄会初始化成null，而且假若试图为它们中的任何一个调用方法，就会产生一次“违例”。
例：SprinklerSystem.java
二、什么时候使用合成
如果想利用新类内部一个现有类的特性，而不想使用它的接口，通常应选择合成。也就是说，我们可嵌入一个对象，使自己能用它实现新类的特性。但新类的用户会看到我们已定义的接口，而不是来自嵌入对象的接口。考虑到这种效果，我们需在新类里嵌入现有类的private对象。
例：Car.java
http://blog.csdn.net/wangr1978/archive/2006/07/03/869775.aspx
icecityman收录，使用标签：Think, in, java学习笔记，时间：2008-9-12 22:21:25 | 相关网摘，我也收藏
第6章 继承
一、 继承的语法：
class Thisclass extends Superclass{
//classBody
}
1、 java的所以类都是从Object类继承来得。java的继承是单继承。
2、 子类拥有父类的所有成员和方法，除了private的，除了构造方法。
3、 子类可以覆盖拥有的父类的成员和方法。也可以添加自己的成员和方法。
4、 子类中使用父类被覆盖的成员和方法用super关键字
例：Detergent.java
二、 初始化父类子对象
1. 创建子类的对象时，同时也会创建父类的一个子对象，父类的子对象包含在子类的对象中。
2. 为了保证父类子对象的正确初始化，在子类的构造方法中，Java会首先自动插入对父类默认构建器的调用。
例：Cartoon.Java
3. 如果父类的构造方法含有自变量，则在子类的构造方法必须显式的调用。用super关键字。
例：Chess.java
4. 子类的构造方法必须捕获父类构造方法的所有违例
5. 尽管编译器会强迫我们对基础类进行初始化，并要求我们在构建器最开头做这一工作，但它并不会监视我们是否正确初始化了成员对象。所以对此必须特别加以留意。
三、 确保正确的清除顺序
1. 在确实需要自己去清除一个对象时，必须写一个特别的方法，明确、专门地来做这件事情。
2. 让客户程序员知道他们必须调用这个方法
3. 不管发生什么清除方法必须被执行，必须将这样的清除代码置于一个finally从句中防范任何可能出现的违例事件。
4. 注意清楚顺序与创建顺序相反
例：CADSystem.java
四、 选择合成还是继承
“属于”关系是用继承来表达的，而“包含”关系是用合成来表达的。
五、 上溯造型
1. 子类属于父类的一种类型，可以使用父类对象的地方都可以使用子类的对象，这时子类对象被当作父类对象对待。
2. 继承是对一种特殊关系的表达，意味着“这个新类属于那个旧类的一种类型”。
六、 final关键字
“这个东西不能改变”。之所以要禁止改变，可能是考虑到两方面的因素：设计或效率。
1. final数据：常数
1) 常数的用途：
l 编译期常数，它永远不会改变，必须属于基本数据类型，必须给出一个值。
l 在运行期初始化的一个值，我们不希望它发生变化。对于对象句柄，final句柄一旦初始化，永远不能指向另一个对象。对于基本数据类型的值也同。
例：FinalData.java
2) 空白final
Java 1.1允许我们创建“空白final”。尽管被声明成final，但却未得到一个初始值。空白final都必须在实际使用前得到正确的初始化。
例：BlankFinal.java
3) final自变量
Java 1.1允许我们将自变量设成final属性，方法是在自变量列表中对它们进行适当的声明。这意味着在一个方法的内部，我们不能改变自变量句柄指向的东西。
例：FinalArguments.java
2. final方法
使用final方法的两方面理由：
第一个是为方法“上锁”，防止任何继承类改变它的本来含义。不可被覆盖。
第二个理由是程序执行的效率。关闭动态绑定。
类内所有private方法都自动成为final。
3. final类
不希望从这个类继承。例：Jurassic.java
六、 初始化总结
例：Beetle.java
1、 运行Beetle时（java Beetle），首先装载程序根据Beetle.main到外面找到Beetle.class类。
2、 在装载过程中，装载程序注意它有一个父类Insect，无论是否准备生成Insect的一个对象，都会将Insect.class载入。若Insect也含有父类，则Insect的父类随即也会载入，以此类推。
3、 在根父类（此时是Insect）执行static成员变量初始化，再在下一个子类执行，以此类推。
4、 创建对象。
l 首先，子类中的所有基本数据类型都会设成它们的默认值，而将对象句柄设为null。
l 调用父类构建器：构建器采用与子类构建器完全相同的处理过程；父类的非static成员变量执行规定初始化。创建父类对象。
l 子类的非static成员变量执行规定初始化。
l 最后，执行构建器剩余的主体部分，创建子类对象。
http://blog.csdn.net/wangr1978/archive/2006/07/03/869788.aspx
icecityman收录，使用标签：Think, in, java学习笔记，时间：2008-9-12 22:20:58 | 相关网摘，我也收藏
多态性
“面向对象的程序设计语言的第三种最基本的特征－多态性。”
抽象：创建出新的数据类型class（成员变量和成员方法）。
封装：将接口与实施细节分离。
继承：代码复用。
多态：实现了“是什么”与“怎样做”两个模块的分离。
可扩展：在需要时易于添加新功能。
一、upcasting
1.将子类的对象作为父类的对象使用。这就叫upcasting。
2.子类的接口被窄化
3.为什么要upcasting
4.比较Music.java 和Music2.java
二、多态性
1. 多态性也叫动态绑定、推迟绑定、运行期绑定、晚绑定
2. 绑定（Binding）：将一个方法调用同一个方法主体连接到一起。
3. 早期绑定：由编译器和链接程序，在程序运行以前执行绑定。主观上可以判断调用的是那个方法。
4. 动态绑定：绑定在运行期间进行。
l 必须能在运行期间判断对象的类型，并分别调用相应的方法。
5. 在Java中，除非一个方法已被声明成final或static，否则方法的绑定就是动态绑定。
6. 声明成final的方法的好处：防止其他人覆盖那个方法；“关闭”动态绑定，提高效率。
Shapes.java
三、可扩展
Music3.java
四、覆盖与过载(注意private方法)
1. 过载”是指同一样东西在不同的地方具有多种含义；
2. “覆盖”是指它随时随地都只有一种含义，只是原先的含义完全被后来的含义取代了。
五、抽象类和抽象方法
1. 用abstract关键字来修饰一个类时，这个类叫做抽象类；它包含有0个或多个抽象方法。不能创建属于它的对象，只能被继承。
2. 用abstract来修饰一个方法时，该方法叫做抽象方法。只含有一个声明，没有方法主体。
3. 含有抽象方法的类必须被声明为抽象类。
4. 如从一个抽象类继承，而且想生成新类型的一个对象，就必须实现父类中的所有抽象方法。如果不这样做，子类也会是抽象的。
5. 一个类抽象以后，并不会强迫我们将它的所有方法都同时变成抽象。
六、构建器和多形性
1. 构建器的调用顺序：Sandwich.java
初始化总结
例：Beetle.java
1、 运行Beetle时（java Beetle），首先装载程序根据Beetle.main到外面找到Beetle.class类。
2、 在装载过程中，装载程序注意它有一个父类Insect，无论是否准备生成Insect的一个对象，都会将Insect.class载入。若Insect也含有父类，则Insect的父类随即也会载入，以此类推。
3、 在根父类（此时是Insect）执行static成员变量初始化，再在下一个子类执行，以此类推。
4、 创建对象。
l 首先，子类中的所有基本数据类型都会设成它们的默认值，而将对象句柄设为null。
l 调用父类构建器：构建器采用与子类构建器完全相同的处理过程；父类的非static成员变量执行规定初始化。创建父类对象。
l 子类的非static成员变量执行规定初始化。
l 最后，执行构建器剩余的主体部分，创建子类对象。
2. 继承与清理：Frog.java
在自己定义清除方法时，子类覆盖了父类的清除方法，一定要记住记住在子类的清除方法中调用父类的。
3. 构建器内部的多形性方法的行为：PolyConstructors.java
设计构建器时一个特别有效的规则是：用尽可能简单的方法使对象进入就绪状态；如果可能，避免调用任何方法。在构建器内唯一能够安全调用的是在基础类中具有final属性的那些方法
七、通过继承进行设计
1. 用继承表达行为间的差异，并用成员变量表达状态的变化。
2. 纯继承与扩展
3. 下溯造型与运行期类型标识
http://blog.csdn.net/wangr1978/archive/2006/07/03/869795.aspx
icecityman收录，使用标签：Think, in, java学习笔记，时间：2008-9-12 22:20:05 | 相关网摘，我也收藏
内部类
“为了访问一个类的所有成员和方法”
一、 什么是内部类
1、 在Java 1.1中，可将一个类的定义置入另一个类的定义中，这种处于内部的类就叫作“内部类”。
2、 内部类创建方法
例：Parcel1.java
3、 和外部类不同，Inner class可以声明为private或protected；
二、 方法内部类和作用域内部类
1、 方法内部类：对象在方法外仍然可以使用。方法内部类可以自由使用方法的自变量。
例：Parcel4.java
2、 作用域内部类：在定义它的那个作用域之外，它是不可使用的
例：Parcel4.java
三、 匿名内部类（常用）
1、 什么是匿名内部类？没有名字的内部类。
例：Parcel6.java
2、 匿名类不能拥有一个构造方法
例：Parcel7.java
3、 若试图定义一个匿名内部类，并想使用在匿名内部类外部定义的一个对象，则编译器要求外部对象为final属性。
例：Parcel8.java
4、 一个实例初始化模块就是一个匿名内部类的构造方法
例：Parcel9.java
四、 非static内部类（相当与非static的成员）
1、 非static内部类的对象持有创建它的外部类的一个对象的引用。（本质）
2、 想在除外部类非static方法内部之外的任何地方生成非static内部类的一个对象，必须将那个对象的类型设为“外部类名.内部类名”。
例：Parcel2.java ，
3、 创建非static内部类的对象时，需要外部类的对象。即：除非已拥有外部类的一个对象，否则不可能创建非static内部类的一个对象
例：Parcel11.java
4、 非static成员内部类可以自由使用外部类的任何成员变量和成员方法。（常用）
例：Sequence.java
5、 非static内部类不可拥有static数据或static内部类。
五、 static内部类（相当与static的成员）
1、 static内部类的对象没有创建它的外部类的一个对象的引用。（本质）
2、 创建static内部类的对象时，不再需要外部类的对象。
例：比较Parcel3.java和Parcel10.java
3、 static成员内部类只能使用外部类的static成员变量和成员方法。
4、 static内部类可以成为接口的一部分。
例：IInterface.java
5、 static内部类的一个用途
例：TestBed.java
6、
六、 内部类和继承
Inner class可以声明为抽象类 ，因此可以被其它的内部类继承。也可以声明为final的。
1、 继承内部类
例：InheritInner.java
结论：
1) 注意子类构造方法的定义
2) 子类没有默认的构造方法。
3) 子类的构造方法的自变量必须有父类的外部类。
4) 子类的构造方法中必须明确的调用父类的构造方法: 父类外部类名.super（）；
2、 继承外部类时内部类不可以被覆盖
例：BigEgg.java
结论：
一个内部类不能被覆盖――继承一个外部类时，它的内部类不会继续，即内部类不属于子类。
例：BigEgg2.java
结论：子类的内部类可以继承父类的内部类。
七、 内部类标识符
1、 成员内部类的标识符：外部类的名字＋$＋内部类的名字.class
2、 方法和作用域中的内部类的标识符：外部类的名字＋$＋数字序号＋内部类的名字.class
3、 匿名内部类的标识符：外部类的名字＋$＋数字序号.class
4、 内部类嵌套于其他内部类: 外部类的名字＋$＋内部类1的名字+$+内部类2的名字.class
由于它是Java的标准命名机制，所以产生的文件会自动具备“与平台无关”的能力。
http://blog.csdn.net/wangr1978/archive/2006/07/03/869851.aspx
icecityman收录，使用标签：Think, in, java学习笔记，时间：2008-9-12 22:19:15 | 相关网摘，我也收藏
接口
1. 接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的声明，而没有变量和方法的实现。
2. 接口中的常量默认为public static final的；也只能是public static final的，它们不能是“空白final”，但可初始化成非常数表达式。
3. 接口中只能定义抽象方法，而且这些方法默认为public的、也只能是public的；
4. 接口这样描述自己：“对于实现我的所有类，看起来都应该象我现在这个样子”。多个无关的类可以实现同一个接口，所以我们常把接口用于建立类和类之间的一个“协议”。
5. 使用interface关键字创建一个接口，接口可以是“友好的”或“public”的。
6. 类使用接口，要使用implements（实现）关键字。我们要表达的意思是“接口看起来就象那个样子，这儿是它具体的工作细节”。 一个类可以实现多个无关的接口，所有接口名置于implements关键字的后面，并用逗号分隔它们。
7. 与继承关系类似，接口与实现类之间存在多态性
8. 接口可以多继承其它的接口，并添加新的属性和抽象方法。
9. 通过接口可以实现不相关类的相同行为，而不需要考虑这些类之间的层次关系。
10. 通过接口可以指明多个类需要实现的方法。
11. 通过接口可以了解对象的交互界面，而不需了解对象所对应的类。
http://blog.csdn.net/wangr1978/archive/2006/07/03/869854.aspx
icecityman收录，使用标签：Think, in, java学习笔记，时间：2008-9-12 22:18:17 | 相关网摘，我也收藏
第9章 违例差错控制
Java违例差错控制的基本原理就是“形式错误的代码不会运行”。
违例差错控制总则：不要去隐藏程序运行中的错误，而是要告诉用户在遇到错误时该怎么办。
一、Throwable类和Exception类
1、 java.lang.Throwable类：对可以作为违例“掷”出的所有东西进行了描述。
1) public class Throwable extends Object implements Serializable
2) 构造方法
ü Throwable()
ü Throwable(String message)
3) 成员方法
ü Throwable fillInStackTrace()：Fills in the execution stack trace.
ü String getLocalizedMessage()：Creates a localized description of this Throwable.
ü String getMessage()：Returns the error message string of this throwable object.
ü String toString()：Returns a short description of this throwable object.
ü void printStackTrace()：Prints this Throwable and its backtrace to the standard error stream.
ü void printStackTrace(PrintStream s)： Prints this Throwable and its backtrace to the specified print stream.
ü void printStackTrace(PrintWriter s)： Prints this Throwable and its backtrace to the specified print writer.
2、 java.lang.Exception类
1) public class Exception extends Throwable
2) 构造方法
ü Exception()
ü Exception(String message)
二、 抛出违例
1、 在异常发生时，应中止方法或作用域的继续，你没有办法解决这个异常，必须抛出一个异常。
2、 基本违例的构造方法：
1) 默认构建器，
2) 使用一个字串自变量
3、 抛出一个基本违例
1) 方法1：throw new NullPointerException();
2) 方法2：throw new NullPointerException("t = null");
4、 抛出一个违例时：
1) 在内存“堆”里来创建一个违例对象。
2) 停止当前执行路径，然后从当前的环境中释放出违例对象的句柄。
3) 违例控制机制接管一切，并开始查找一个恰当的地方，用于继续程序的执行。
三、 违例的捕获
1、 违例控制器
try { // Code that might generate exceptions} catch(Type1 id1) { // Handle exceptions of Type1} catch(Type2 id2) { // Handle exceptions of Type22、 违例的声明
1) 如果方法产生违例必须声明
2) 方法名 throws异常名1，异常名2{}
3) 可以声明一个并没有真正抛出的违例
3、 捕获所有违例
try{
}catch(Exception e) { }
例：ExceptionMethods.java
4、 重新“掷”出违例
try{
}catch(Type1 id1) {
//
throw id1;
重新“掷”出一个不同的违例；
}
例：Rethrowing.java，RethrowNew.java四、 标准Java违例
1、 hrowable对象有两种常规子类（Error类代表编译期和系统错误，Exception类是可以从任何标准Java库的类方法中“掷”出的基本类型）我们一般不必特意捕获它们（除在特殊情况以外）。
2、 方法抛出RuntimeException违例，不需要声明。假若一个RuntimeException获得到达main()的所有途径，同时不被捕获，那么当程序退出时，会为那个违例调用printStackTrace()。
五、 创建自己的违例
1、 建自己的违例类，必须从一个现有的违例类型继承——最好在含义上与新违例近似。
例：Inheriting.java，Inheriting2.java六、 违例的限制
1、子类覆盖父类的一个方法时，只能产生比父类中该方法定义的违例少的违例。对违例的限制并不适用于构建器。
2、衍生类构建器必须在自己的违例规范中声明所有基础类构建器违例。
例：StormyInning.java七、用finally清除
1、 无论是否“掷”出一个违例，finally从句都会执行。
try {
// 要保卫的区域：
// 可能“掷”出A,B,或C的危险情况
} catch (A a1) {
// 控制器 A
} catch (B b1) {
// 控制器 B
} catch (C c1) {
// 控制器 C
} finally {
// 每次都会发生的情况
}
2、 用finally做什么
例：OnOffSwitch.java，WithFinally.java，AlwaysFinally.java3、 缺点：丢失的违例
例：LostMessage.java八、 构造方法
构造方法一旦产生违例，会正确地进行清除吗？例：Cleanup.java九、 违例匹配
1. “掷”出一个违例后，违例控制系统会按当初编写的顺序搜索“最接近”的控制器。一旦找到相符的控制器，就认为违例已得到控制，不再进行更多的搜索工作。2. 在违例和它的控制器之间，并不需要非常精确的匹配。一个衍生类对象可与基础类的一个控制器相配。例：Human.java十、 违例准则
用违例做下面这些事情：
(1) 解决问题并再次调用造成违例的方法。
(2) 平息事态的发展，并在不重新尝试方法的前提下继续。
(3) 计算另一些结果，而不是希望方法产生的结果。
(4) 在当前环境中尽可能解决问题，以及将相同的违例重新“掷”出一个更高级的环境。
(5) 在当前环境中尽可能解决问题，以及将不同的违例重新“掷”出一个更高级的环境。
(6) 中止程序执行。
(7) 简化编码。若违例方案使事情变得更加复杂，那就会令人非常烦恼，不如不用。
(8) 使自己的库和程序变得更加安全。这既是一种“短期投资”（便于调试），也是一种“长期投资”（改善应用程序的健壮性）
http://blog.csdn.net/wangr1978/archive/2006/07/03/869860.aspx
共15个网摘 [
1 ]