第一章对象导论

>>>>封装<<<<

被隐藏（也即封装）的部分通常代表对象内部脆弱的部分，它们很容易被程序员所毁坏，因此将实现隐藏起来可以减少程序的bug。

隐藏是通过访问控制修饰符（public、protected、包访问、private）来实现的。

访问控制的第一个存在原因就是让调用者无法直接触及他们不应该触及的部分，但从另一方面来看，其实这不失为一项服务，因为他们可以很容易地看出哪些东西对他们来说很重要，而哪些东西可能不关心；访问控制的第二个存在原因就是允许库设计者可以改变类的内部的工作方式而不用担心会影响到调用者。

>>>>继承<<<<

代码复用：复用是面向对象程序设计所提供最了不起的优点之一。

最简单的代码复用就是直接调用类的方法，此外，我们还可以将该类置于某个新类中，使它成为新类的属性成员。新的类也可由任意数量、任意类型的其他对象以任意可以实现新的类中想要功能的方式所组成，这种使用现有的类合成新的类方式称为组合复用。

组合复用带来了极大的灵活性，使得它能在运行时动态的修改其实现行为，但继承并不具备这样的灵活性，因为继承是在编译时期就已经确定其行为，在运行时期是不能修改的。

继承两种实现方式，第一种方式非常直接：直接在子类中添加新的方法，即扩展父类接口。第二种方式就是子类覆写父类方法，但不新增父类没有接口。

“is-a是一个”与“is-like-a像是一个”。继承时，我们使用第一种还是第二种方式呢？这可能引起争论：继承应该只覆盖基类的方法，而并不添加在基类中没有的新方法吗？如果这样做，就意味着子类与基类是完全相同的类型，因为它们具有完全相同的接口，结果可以用一个子类对象来完全替代一个基类对象，这可被认为是纯粹替代，通常称之为替代原则，这也是一种理想的方式，我们经常称这种情况下的子类与基类的关系是“is-a是一个”；有时必须在子类型中添加新的接口，这样也就扩展了接口，这个新的类型仍可以替代基类，但是这种替代并不完美，因为基类无法访问新添加的方法，这种情况下我们可以描述为“is-like-a像是一个”关系。

>>>>多态<<<<

一个非面向对象编程的编译器产生的函数调用会引起所谓的前期绑定，而向对象程序设计语言使用了后期绑定的概念。

方法的调用就是编译器将产生对一个具体函数名字的调用，前期绑定是在运行时将这个调用解析到将要被执行的代码的绝对地址。然而在OOP中，程序直到运行时才能够确定代码的地址，为了执行后期绑定，Java编译器使用了一小段特殊代码来替代绝对地址调用，这段代码使用对象中存储的信息来计算方法体的地址，根据这段特殊代码，每个对象都可以具有不同的行为表现。

在某些语言中，必须明确地声明某个方法具备后期绑定属性所带来的灵活性，如C++使用virtual关键字来实现，在默认情况下，C++不是动态绑定的，而在Java中，动态绑定是默认行为，不需要添加额外的关键字来实现多态。

>>> Java语言支持四种类型<<<

接口（interface）、类（class）、数组（array）和基本类型（primitive）。前三种类型通常被称为引用类型（reference type），类实例和数组是对象（object），而基本类型的值则不是对象。类的成员（member）由它的域（field）、方法（method）、成员类（member class）和成员接口（member interface）组成。方法签名（signature）由它的名称和所有参数类型组成；签名不包括它的返回类型。

>>>>运行Java<<<<

用javac命令编译一个打包的类时，如果没有加参数"-d"时，则编译出的类不会放在包中（即相应的文件夹中），是没有包路径的，除非用参数"-d"指定类存放的位置，–d 指示的是编译后的class文件放在哪个目录下，并且会自动创建包名文件夹。

比如现有如下类：
package a.b;

class A{}

       javac A.java 时会在当前工作目录下产生一个A.class文件，不会创建包目录结构。

       javac –d . A.java ，则会在当前工作目录产生 a/b/A.class 目录与文件。

所以使用javac编译时要想产生相应的类包名上当结构，则需要带上“–d .”这样的参数。

用java命令运行一个类时，如果该类是存放在包中的，则运行时一定要带上包名，并且在环境变量要有该包存放的路径。

　    java -classpath . a.Ａ

　    注，如果用java命令运行时，没有配置classpath环境变量，则这里的classpath不能缺少。

>>>类与类之间的关系<<<

类和类、类和接口、接口和接口之间有如下几种关系：泛化关系、实现关系、关联关系（聚合、合成）、依赖关系。

l  泛化：表示类与类之间的继承关系，使用extends关键字来表示。在图形上使用虚线三角形箭头表示。

l  实现：表示类与接口之间的实现关系，使用implements关键字来表示。在图形上使用实线三角形箭头表示。

l  关联：类与类之间的联接。关联可以是双向的，也可以是单向的，双向的关联可以有两个箭头或都没有箭头。单向的关联有一个箭头，表示关联的方向。在Java里，关联关系是使用实例变量实现的。在每一个关联的端点，还可以有一个基数，表时这一端的类可以有几个实例。常见的基数有：0..1（零个或者一个实例）、0..*或者*（没限制，可以是零）、1（只有一个实例）、1..*（至少有一个实例）。一个关联关系可以进一步确定为聚合与合成关系。在图形上使用实线的箭头表示。

l  聚合：是关联关系的一种，是强的关联关系，聚合是整体和个体之间的关系。关联与聚合仅仅从Java语法是上是分辨不出的，需要考察所涉及的类之间的逻辑关系。如果不确定是聚合关系，可以将之设置为关联关系。图形是在实线的箭头的尾部多一个空心菱形。

l  合成：是关联关系的一种，是比聚合关系强的关系。它要求普通的聚合关系中代表整体的对象负责代表部分的对象的生命周期。整体消亡，则部分与消亡。图形是在实线的箭头的尾部多一个黑心菱形。

l  依赖：类与类之间的连接，依赖总是单向的。表示一个类依赖于另一个类的定义。一般而言，依赖关系在Java里体现为局部变量、方法的参数、以及对静态方法的调用。但如果对方出现在实例变量中，那关系就超过了依赖关系，而成了关联关系了。在图形上使用虚线的箭头表示。

第二章一切都是对象

>>>>对象存放位置与生命周期<<<<

C++创建的对象可以存放在栈、静态存储区与堆（heap）中，放在栈中的对象用完后不需手动释放，会自动销毁，但放在堆中的对象需手动释放，栈中的对象所需空间与生命周期都是确定的，堆中的对象内存分配是动态的，在运行时才知道需要多少内存以及生命周期，如果说在堆上创建对象，编译器就会对它的生命周期一无所知，C++就需要以编程的方式来确定何时销毁对象，这可能因不正确处理而导致内存泄漏，而Java则提供了自动垃圾回收机制。

Java对象的创建采用了动态内存分配策略，即创建的堆都是放在堆中的。

>>>>数据内存分配<<<<

寄存器——位于处理器内部，这是最快的存储区，大小极其有限，一般不能直接控制，但C和C++允许你向编译器建议寄存器分配方式。

堆栈——位于通用RAM（随机访问存储器）中，堆栈指针向下移动，则分配新的内存；若向上移动，则释放内存。这是一种快速有效的分配方法，速度仅次于寄存器。创建程序时，Java系统必须知道存储在堆栈内所有项的确切生命周期，以便上下移动堆栈指针。这一约束限制了程序的灵活性，所以虽然某些Java数据存储于堆栈中（如对象引用），但是Java对象并不存储于其中。

堆——一种通用的内存池（也位于RAM区），用于存放所有的Java对象，堆不同于堆栈的好处是，编译器不需要知道存储的数据在堆里存活多长时间。因此，在堆栈分配存储有很大的灵活性。当然，这种灵活性导致了分配需要更多的时间，时间效率上不如堆栈。

常量存储：常量值通常直接存放到程序代码内部，这样做是安全的，因为它们永远不会被改变。

非RAM存储：数据可完全存活于程序之外，在没有运行机制时也可以存在，如持久化对象的存放。

JVM有两类存储区：常量缓冲池和方法区。常量缓冲池用于存储类名称、方法和字段名称以及串常量。方法区则用于存储Java方法的字节码。

Java字节码的执行有两种方式：

　　1.即时编译方式：解释器先将字节码编译成机器码，然后再执行该机器码。

　　2.解释执行方式：解释器通过每次解释并执行一小段代码来完成Java字节码程 序的所有操作。

通常采用的是第二种方法。由于JVM规格描述具有足够的灵活性，这使得将字节码翻译为机器代码的工作具有较高的效率。对于那些对运行速度要求较高的应用程序，解释器可将Java字节码即时编译为机器码，从而很好地保证了Java代码的可移植性和高性能。

转载C/C++内存分配：

堆和栈的区别

一、预备知识—程序的内存分配

一个由C/C++编译的程序占用的内存分为以下几个部分

1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。

3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放

4、文字常量区—常量字符串就是放在这里的。 程序结束后由系统释放

5、程序代码区—存放函数体的二进制代码。

二、例子程序

这是一个前辈写的，非常详细

//main.cpp

int a = 0; 全局初始化区

char *p1; 全局未初始化区

main()

{

int b; 栈

char s[] = "abc"; 栈

char *p2; 栈

char *p3 = "123456"; "123456"在常量区，p3在栈上。

static int c =0； 全局（静态）初始化区

p1 = (char *)malloc(10);

p2 = (char *)malloc(20);

上面分配得来得10和20字节的区域就在堆区。

strcpy(p1, "123456"); "123456"放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方，即指向同一个字符串。

}

二、堆和栈的理论知识

2.1申请方式

stack:

由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间

heap:

需要程序员自己申请，并指明大小，在c中malloc函数

如p1 = (char *)malloc(10);

在C++中用new运算符

如p2 = (char *)malloc(10);

但是注意p1、p2本身是在栈中的。

2.2

申请后系统的响应

栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。

堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，

会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3申请大小的限制

栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。

堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

2.4申请效率的比较：

栈由系统自动分配，速度较快。但程序员是无法控制的。

堆是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便.

另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

2.5堆和栈中的存储内容

栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。

当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。

堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

2.6存取效率的比较

char s1[] = "aaaaaaaaaaaaaaa";

char *s2 = "bbbbbbbbbbbbbbbbb";

aaaaaaaaaaa是在运行时刻赋值的；

而bbbbbbbbbbb是在编译时就确定的；

但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。比如：

#include

void main()

{

char a = 1;

char c[] = "1234567890";

char *p ="1234567890";

a = c[1];

a = p[1];

return;

}

对应的汇编代码

10: a = c[1];

00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]

0040106A 88 4D FC mov byte ptr [ebp-4],cl

11: a = p[1];

0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]

00401070 8A 42 01 mov al,byte ptr [edx+1]

00401073 88 45 FC mov byte ptr [ebp-4],al

第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。

>>>>基本类型<<<<

void属于基本类型，但只能用来修饰方法，不能用来修饰变量。

只要两个操作数中有一个是double类型的，另一个将会被转换成double类型，并且结果也是double类型；

否则，只要两个操作数中有一个是float类型的，另一个将会被转换成float类型，并且结果也是float类型；

否则，只要两个操作数中有一个是long类型的，另一个将会被转换成long类型，并且结果也是long类型；

否则，两个操作数（包括byte、short、int、char）都将会被转换成int类型，并且结果也是int类型。

Java提供了两个用于高精度计算类：BigInteger和BigDecimal，大体属于“包装器类”范畴，但都没有对应的基本类型。

BigInteger支持任意精度的整数，可表示任何大小的整数值。

BigDecimal支持任意精度的定点数，例如，可以用它进行精确的货币计算。

>>>>引用与对象生存周期<<<<

{

       String s = new String("a string");

}

引用s在作用域终点就消失了，然而，s指向的String对象继续占据内存，最后由垃圾回收器回收。

>>>>方法签名<<<<

方法名和参数列表（合起来被称为“方法签名”）唯一地标识出某个方法。

>>>>static修饰字段与方法的区别<<<<

一个static字段对每个对象来说都只有一份空间，而非static字段则是对每个对象都有一个存储空间，但是如果static作用于某个方法时，差别却没有那么大，static方法的一个重要的用法就是在不创建任何对象的前提下就可以调用它，这一点对定义main()方法很重要，该方法是运行时程序的一个入口。

第三章操作符

char c = 0xffff;//最大字符串

byte b = -0x80;//最小字节型 或byte b = (byte)0x80; 因为0x80形式为正，即第一位不是符号位而是数字位，所以超过byte范围，但-0x80却明确说明第一位是符号位，即为负，没有超过byte范围类型

byte b = 0x7f;//最大字节型

如果将比较小的类型传递给Integer.toBinaryString()方法，则该类型将自动被提升为int再执行。

如果对char、byte或short类型的数值进行移位处理，那么在移位进行之前，它们会被转换为int类型，并且得到的结果也是一个int类型的值；如果为int与long，则结果类型不变。

“移位”可与“等号”（<<=、>>=、>>>=）组合使用，此时，操作符左边的值会移动由右边的值指定的位数，再将得到的结果赋给左边的变量，但在进行“无符号”右移结合赋值操作时，可能会遇到一个问题：如果对byte或short值进行这样的位移运算时，得到的可能不是正确的结果，它们会先转换成int类型，再进行右移操作，然后被截断，赋值给原来的类型，在这种情况下可能得到-1的结果。

long l = -1;

System.out.println(Long.toBinaryString(l));// 64个1

l >>>= 10;

System.out.println(Long.toBinaryString(l));// 54个1

int i = -1;

System.out.println(Integer.toBinaryString(i));// 32个1

i >>>= 10;

System.out.println(Integer.toBinaryString(i));// 22个1

byte b = -1;

// 字节型-1提升到整型-1，所以结果为32个1

System.out.println(Integer.toBinaryString(b));// 32个1

// b先提升到int 即在原来8个1前再补24个1，然后无符号右移，再截最后8位并赋值给b

b >>>= 10;

// b会先提升为int，再运算

System.out.println(Integer.toBinaryString(b));// 32个1

b = -1;

// 不使用 >>>= 时，结果为正确，虽然在执行前b提升为int，但计算后没有截断，直接输出整型结果

System.out.println(Integer.toBinaryString(b >>> 10));// 22个1

将float或double转型为整型值时，总是对该数字执行截尾（(int) 0.7结果为0），如果想要得到舍入的结果，就需要使用java.lang.Math中的round()方法（Math.round(0.7)结果为1）。

一般来说，如果在程序里使用了“直接常量”，编译器可以准确地知道要生成什么样的类型，但有时候却是不明确的，此时可以在常量后附加上一些特定类型字符来明确。

/*

* 计算表达式中如果都整型数常量，则计算过程中还是整型，这有可能引起计算

* 溢出问题，但编译与运行都不会报错，对于此种情况，在表达式中的某个常量

* 后加上L即可使表达式计算过程中以long型来计算

*/

long l = 2147483647 * 2;// -2

l = 2147483647L * 2;// 4294967294

// 编译运行都不会错

int i = 2147483647 * 2;// -2

// !! 以下编译时就出错

// short s1 = 32767 * 2;

// byte b1 = 127 * 2;

// short s2 = 16384 * 2;

// byte b2 = 64 * 2;

// short s3 = 2147483647 * 3;//乘以奇数就不行，偶数就可以？

// byte b3 = 2147483647 * 3;

// 但下面可编译运行

short s = 2147483647 * 2;// -2

byte b = 2147483647 * 2;// -2

第四章流程控制

Foreach循环可用于数组，以及实现了java.util.Iterator接口的对象。

public interface Iterable<T> {

    Iterator<T> iterator();

}

如果在返回void的方法中没有return语句，那么在该方法的结尾处会有一个隐式的return，因此在方法中并非总是必须要有一个return语句。但是，如果一个方法声明它将返回void之外的其他东西，那么必须确保每一条代码路径都将返回一个值。

int i;

for (i = 0; i <= 5; i++) {

       if (i == 2) {

              break;//退出时i不会再递增，但continue会

       }

}

System.out.println("i=" + i);//2

for(;;)与while(ture)等效。

尽管goto仍是Java中的一个保留字，但在语言中并未使用它，Java没有goto。但可使用带标签的 continue或break来完成类似的跳转操作。

带标签与不带标签的continue、break用于迭代语句时规则：

一般的continue会退回到最内层循环的开头，并继续执行循环。

带标签的continue会到标签的位置，并重新进入紧接在那个标签后面的循环。

一般的break会中断并跳出当前循环。

带标签的break会中断并跳出标签所指的循环。

在Java里需要使用标签的唯一理由就是因为有循环嵌套存在，而且想从多层嵌套中break或continue到外层循环外。

标签只能紧跟在循环语句前（注：如果中间还有其他语句，则continue与break语句编译出错，但如果标签不应用到continue与break中，则不会有问题）

int i = 0, j = 0;

outer:

// !! 注，标签的下面不能写任何其他非迭代语句

for (; i < 5; i++) { // 死循环

       inner:

       // !! 注，标签的下面不能写任何其他非迭代语句

       for (; j < 10; j++) {

              System.out.println(("i=" + i + " j = " + j));

              if (j == 2) {

                     System.out.println("continue");

                     continue;// 回到内层循环起始处继续执行内层循环，j会自动递增

              }

              if (j == 3) {

                     System.out.println("break");

                     // 为了下次循环不再走该分支，则要使用i递增1，因为break后j不会自动递增

                     j++;

                     break;// 跳出内层循环，回到外层循环起始处继续执行外层循环

              }

              if (j == 7) {

                     System.out.println("continue outer");

                     // 由于带标签的continue跳到了外层循环起始处，所以j不会自动递增，但为了

                     // 下一次不再走该分支，所以要手动递增1

                     j++;

                     continue outer;

              }

              if (j == 8) {

                     System.out.println("break outer");

                     break outer;// 当j为8时，退出内外层循环，实质上执行最后打印语句

              }

              for (int k = 0; k < 5; k++) {

                     if (k == 3) {

                            System.out.println("continue inner");

                            // j为0、1、4、5、6时分别会执行一遍

                            continue inner;

                     }

              }

       }

}

// 由于 break outer 跳出，所以i不会递增，最后还是2

System.out.println(("i = " + i));

switch(integer-selector){

       case integer-value1: statement;break;

       case integer-value2: statement;break;

case integer-value3: statement;break;

//…

default: statement;break;

}

switch语句是可用的选择数据类型有 int、char、enum。

case均以一个break结尾，这样可使执行流程跳转至switch主体的末尾。这是构建switch语句的一种传统方式，但break是可选的。若省略break，会继续执行后面的case语句，直到遇到一个break为止。注意最后的default语句没有break，因为执行流程已到了break的跳转目的地。当然，如果考虑到编程风格方面的原因，完全可以在default语句的末尾放置一个break，尽管它并没有任何实际的用处。

第五章初始化与清理

重载：方法名相同，参数列表不同（参数类型、个数、顺序）。

以基本类型参数重载方法时，会优先调用该类型的参数的方式，如果没有找到相同类型时，则提升最近的参数类型。

this(type x)用来在构造函数中调用其他构造函数，也只能用于构造函数中，并且只能用在第一行。

如果你的对象（并非使用new）获得了一块“特殊”的内存区域中，由于垃圾回收器只知道释放那些经由new分配的内存，所以它不知道该如何释放该对象的这块“特殊”内存。

finalize()：该方法并不是用来释放由Java程序本身分配的空间，因为它有可能不被调用，由Java程序本身分配的空间会由JVM在适当的时机释放，有可能不调用，分配的空间直到程序运行完时一次性还给操作系统，那其作用是什么呢？由于在分配内存时可能采用了类似C语言中的做法，而非Java中的通常做法。这种情况主要发生在使用“本地方法”的情况下，在非Java代码中，也许会调用C的malloc()函数系列来分配存储空间，而且除非调用了free()函数，否则存储空间将得不到释放，从而造成内存泄露。当然free()是C与C++中的函数，所以需要在finalize()中用本地方法来调用它。

C++中在堆栈中创建的对象相当于局部对象（Java是不可以在栈上创建对象的），会在方法调用完毕时自动销毁对象。但如果是采用的new方式创建的对象（类似Java），那么程序员调用C++的delete操作符时（Java中没有该命令），就会调用相应的析构函数。如果没有调用delete，那么就不会调用析构函数，这样就会引起内存泄露。

>>>>可变参数<<<<

如果有多个参数，则可变参数只能放在最后，否则编译不能通过。

可变参数接收到所有参数时，实质上是一个数组，所以可变参数的所有参数都是同一类型的。

即然是可变的，当然我们也可不输出任何参数。

public static void main(String[] args) {

       print("you input:", 1, 2, 3);

       //与下面等效，即可变参数也可使用数组进行传递

       print("you input:", new int[] { 1, 2, 3 });

}

private static void print(String msg, int... is) {

       System.out.print(msg + " ");

       for (int i : is) {

              System.out.print(i + " ");

       }

}

可变参数重载时，有时有问题，如下：

static void f(float i, Character... args) {}

static void f(Character... args) {}

因为在只传一个参数时可能引起模糊，所以这样是不允许的，如果你给这两个方法都添加一个非可变参数，就可以解决问题：

static void f(float i, Character... args) {}

static void f(char c, Character... args) {}

第六章访问权限控制

要学会把变动的代码与保持不变的代码区分开来。

如果有必要，你尽可能将一切方法都定为private。

非public类在其它包中是访问不到的。

所有默认包的类都是属于同一个包，尽管它们在不同的文件夹下面。

private，只允许本类所有对象可访问，其他任何类都不能访问，哪怕是它的子类或同一包中的类都不行。

如果一类继承自不同包中的类，则该子类不能继承与访问父类中的“包访问权限或默认访问权限”的属性与方法，只能继承与访问protected或public的属性与方法。

设计一个类时一般按照public、protected、默认、private的顺序来定义属性与方法，这样让人最先注意到公开的，当然，我们一般把接口与实现分离更好，这样用户只关心他所需要的接口，而对实现不必理会。

控制对成员的访问权限有两个原因：第一是为了使用户不必关心那此不必关心的private部分，而只关心类提供了哪些服务接口，即public修饰的部分。第二就是让类库设计者可以更改类的内部工作方式，而不必担心这样会客户程序产生重大的影响。

>>>关于protected修饰符<<<

定义规则前，我这里约定有三个类，一个是Base类，一个是Base类的子类Sub类，一个是Sub类的子类SubSub类，另一个是Other类且与Base、Sub、SubSub没有继承关系，并假设Base中有protected方法与属性，都叫YYY吧。

先看看protected规则：首先要搞清楚什么叫访问？这里在讲到的访问是有二种的：

一、就是在类中通过“XXX x = new XXX(); x.YYY;”的形式来访问（不妨叫此种形式为“外部访问”吧，此种访问形式除了可以应用到自己与子类中外，还可以应用在其他类中访问，其中XXX表示定义的类型，这里可为Base与Sub、SubSub，YYY为方法或属性）；

二、就是this.YYY的形式来访问（不妨叫此种形式为“内部访问”吧，不过这种访问形式只能应用在在自己的类或是子类中）。

protected方法与属性可访问的地方有三个：

1.         在自己的类Base中：上面的“XXX x = new XXX(); x.YYY;”与“this.YYY”两种访问形式都可以访问的到自己定义的portected方法或属性；

2.         二是子类Sub、SubSub中，这要分三种访问方式：

a.         在Sub、SubSub 中的“this.YYY”内部访问形式：在此种方式形式下，不管是否重写或重新定义过父类Base中protected方法与属性，子类Sub、SubSub一定可以访问的。

b.         在Sub、SubSub 中“Base x = new XXX (); x.YYY;”外部访问形式：此种形式就不一定的能访问的到了，这要看父类Base与子类Sub、SubSub是否在同一包（注意，此时与是否重写或重新定义过这些protedted方法与属性没有关系）；

c.         在SubSub 中“Sub x = new XXX (); x.YYY;” 外部访问形式：此种访问形式能否访问关键看Sub是否重写或重新定义过Base的属性与方法：

                        i.              如果重写或重新定义过，则看Sub与SubSub是否在同包中

                      ii.              如果没有，则看Base与SubSub是否在同包中

3.         在其他类Other中：此时只支持外部访问形式，不过到底是要求Other与Base同包还是要求Other与Sub同包，则要依你访问方式而定了：

a.         如果是通过父类引用“Base x = new XXX (); x.YYY;”形式来访问的，则要求Other与Base同包；

b.         如果是通过子类引用“Sub x = new Sub (); x.YYY;”形式来访问的，情况又会比较复杂了，此时关键是看子类Sub是否重写或重新定义过父类Base中的protected方法与属性：

                        i.              如果重写或重新定义过了，则要求Other与Sub同包即可；

                      ii.              如果没有重写或重新定义过了，则要求Other与Base同包即可；

规则总结肯定有遗漏的地方，不过我只想到这些，希望大家一起看看。看文字比较绕，下面来应用上面的规则看看这些实例也许会好理解一些：

package pk1.a;

public class Base {

       protected int i = 1;

       protected void protect() {

              System.out.println("Base::protect");

       }

}

package pk1.a;

import pk1.b.Sub;

public class SubSub extends Sub {

       void g() {

              Sub s = new SubSub();

              //!! s.protect();//规则2.c.i

              System.out.println(s.i);//规则2.c.ii

       }

}

package pk1.b;

import pk1.a.Base;

public class Sub extends Base {

       private void prt() {}

       protected void protect() {

              System.out.println("Base::protect");

       }

       void f() {

              //规则2.a

              this.protect();

              this.i = 2;

              //规则2.b

              Base a2 = new Sub();

              //!! a2.protect();

              //!! System.out.println(a2.i);

              //规则1

              Sub b = new Sub();

              b.protect();

              b.i = 1;

              b.prt();

       }

}

package pk1.b;

public class SubSub extends Sub {

       void g() {

              Sub s = new SubSub();

              s.protect();//规则2.c.i

              //!! System.out.println(s.i);//规则2.c.ii

       }

}

package pk1.c;

import pk1.a.Base;

import pk1.b.Sub;

public class SubSub extends Sub {

       void g() {

              this.protect();//规则2.a

              //规则2.b

              Base b = new SubSub();

              //!! b.protect();

              //!! System.out.println(b.i);

              //规则2.b

              Sub s = new SubSub();

              //!! s.protect();

              //!! System.out.println(s.i);

       }

}

package pk2.a;

public class Base {

       protected int i = 1;

       protected void protect() {

              System.out.println("Base::protect");

       }

}

package pk2.a;

import pk2.b.Sub;

public class Other {

       void g() {

              //规则3.a

              Base b = new Sub();

              b.protect();

              System.out.println(b.i);

              //规则3.b.ii

              Sub s = new Sub();

              s.protect();

              System.out.println(s.i);

       }

}

package pk2.b;

import pk2.a.Base;

public class Other {

       void g() {

              //规则3.a

              Base b = new Sub();

              //!! b.protect();

              //!! System.out.println(b.i);

              //规则3.b.ii

              Sub s = new Sub();

              //!! s.protect();

              //!! System.out.println(s.i);

       }

}

package pk2.b;

import pk2.a.Base;

public class Sub extends Base {}

package pk3.a;

import pk3.b.Sub;

public class Base {

       protected int i = 1;

       protected void protect() {

              System.out.println("Base::protect");

       }

       static protected int i_s = 1;

       static protected void protect_s() {

              System.out.println("Static:Base::protect");

       }

       void f() {

              //!! Sub.i_s = 2; //规则3.b.i

              Sub.protect_s();//规则3.b.ii

       }

}

package pk3.a;

import pk3.b.Sub;

public class Other {

       void g() {

              Sub s = new Sub();

              //!! s.protect();//规则3.b.i

              System.out.println(s.i);//规则3.b.ii

       }

       void f() {

              //!! Sub.i_s = 2; //规则3.b.i

              Sub.protect_s();//规则3.b.ii

              Base.i_s = 2;//规则3.a

              Base.protect_s();//规则3.a

       }

}

package pk3.b;

import pk3.a.Base;

public class Other {

       void f() {

              Sub.i_s = 2;//规则3.b.i

              //!! Sub.protect1();//规则3.b.ii

              //!! Base.i1 = 2;//规则3.a

              //!! Base.protect1();//规则3.a

       }

}

package pk3.b;

import pk3.a.Base;

public class Sub extends Base {

       protected void protect() {

              System.out.println("Base::protect");

       }

       static protected int i_s = 2;

       void f() {

              /*

               * 在子类中可能通过子类类型或父类类型来来访问父类中protected静态

               * 成员，而不管子类与父类是否在同一包中，或是子类重新定义了这些成员

               *

               * 注，在父类或子类中访问时后面的规则不再适用

               */

              System.out.println(Sub.i_s);//2

              Sub.protect_s();

              System.out.println(Base.i_s);//1

              Base.protect_s();

       }

}

最后，通过上面的规我们可以很好的解释Object.clone()类似的问题：Object.clone()访问修饰符为protected，如果某个类没有重写此方法，则Object中的clone()方法除被自己与子类能调用方法外，其他不管与这个类在同一包还是不同包都是不可见的，因为未重写，还是属于Object中的方法，又Object在java.lang包中，与我们定义的包又不在java.lang包中，所以不能访问到（这也与你在在程序里定义了Object o = new Object();你还是不能在当前类中调用o.clone();一样）。所以如果要能被不同包中的非子类克隆，则需重写Object.clone()并设置访问权限为public（如果重写后还是protected，则还是只能被同一包访问）。

package a;

public class A {

       protected void f() {}

       void g() {}

       private void p(A a) {}

       private void m(A a) {

              p(a);

       }

       public static void main(String[] args) {

              A a = new A();

              a.m(a);

       }

}

package b;

import a.A;

public class B extends A {

       protected void f() {}

       private void p() {}

       public void call1(B b) {

              b.f();// 此种访问方式属于访问同类中方式，是没有问题的

              f();// 属于访问自已的方法        

              // !! g();// 父类中的包访问权限方法不能被子类继承访问

              b.p();//在同一类中是可以访问私有方法的，访问控制是针对整个类来说的，而不是某个对象

       }

       public void call12(A a) {

              /*

               * 即使是f()是父类中的protected方法，并且子类还重写过了 ，但

               * 是这种以父类类型实例访问父类中的protected方式属于不同包非

               * 子 类访问方式，所以不能访问，即使访问的代码在子类中!

               */

              // !! a.f();

              A a1 = new B();

              // 此种访问与上面是一样也不能编译

              // !! a1.f();

       }

       public static void main(String[] args) {

              B b = new B();

              b.f();

              A a = new B();

              // 与上面 call2方法中的调用一样，也是不能访问的

              // !! a.f();

       }

}

第七章复用

代码复用可分为组合复用与继承复用。

属性成员初始化的4个时机：定义时、构造器中、块中、使用时。

main方法所在的类不一定要是public的（但方法一定要定义成public，如果不是public方法，则启动时会报找不到main方法）为包访问也是可以的，照样可以用作程序入口。另外，main方法也可以由另一个main方法来调用，这也是允许的。

继承并不只是复制基类的接口，当创建了一个子类的对象时，该对象包含了一个基类的子对象，这个子对象与你用基类直接创建的对象是一样的，二者区别在于，后者来自于外部，而基类的子对象被包装在子类对象内部。

当我们亲自处理清理时，要加以小心，因为，一旦涉及垃圾回收，能够信赖的事就不会很多了，垃圾回收器可能永远也无法被调用，即使用被调用，它可能以任何它想要的顺序来回收对象。最好的办法是除了内存以外，不能依赖垃圾回收器去做任何事，如果需要进行清理，最好编写你自己的清理方法，但不要使用finalize()，最好是在finally块调用自己的清理方法。

组合和继承都允许在新的类中放置子对象，组合是显示地这样做，而继承则是隐藏地做。

组合技术通常用于想在新类中使用现有类的功能而非它的接口这种情形。即，在新类中嵌入某个对象，让其实现所需要的功能，但新类的用户看到的只是为新类所定义的接口，而非所嵌入对象的接口，一般需在新类中嵌入一个现有类的private对象。

向上转型是从一个较专用类型向较通用类型转换，所以总是很安全的。向上转型的过程中，类接口唯一可能发生的事情是丢失方法，而不能访问它们。

到底是该用组合还是用继承，一个最清晰的判断办法就是问一问自己是否需要从新类向基类进行向上转型。如果必须向上转换，则继承是必要的，但如果不需要，则应当好好考虑自己是否需要继承。

使用static与final域只占据一段不能改变的存储空间。

final数据在编译时可能还不能确定其值，比如值是通过某个方法计算才能得到的，需在运行时才能确定。

对于编译期常量这种情况，编译器可以将该常量值代入任何可能用到它的计算式中，也就是说，可以在编译时执行计算式，这可减轻一些运行时的负担。在Java中，这类常量必须是基本数据类型。

在Java早期实现中，如果将一个方法指明为final，就是同意编译器将针对该方法的所有调用都转为内嵌调用。当编译器发现一个final方法调用命令时，它会跳过插入程序代码这种正常方式而执行方法调用机制，并且以方法体中的实际代码的副本来替代方法调用，这将消除方法调用的开销。当然，如果方法本身很大，这种效率提升不是很明显，反而可能下降。在最近的Java版本中，虚拟机可以探测到这些情况，并优化去掉这些效率反而降低的额外的内嵌调用，因此不再需要使用final方法来进行优化了，事实上，这种做法正在逐渐受到劝阻，在使用JavaSE5/6时，应该让编译器和虚拟机去处理效率问题，只有在想要明确禁止覆盖时，才将方法设置为final。

类中所有的private方法都隐式地指定为final，可以对private方法添加final修饰词，但这并不能给该方法增加任何额外的意义。

final类中定义的属性成员可以是final的，也可以不是的。但是，所有final类的中方法默认都是final的，因此在final类中的方法前添加final修饰符没有什么意义。

有关final、finally、finalize区别请参考XXX

第八章多态

多态通过分离做什么和怎么做，从另一角度将接口和实现分离开来，多态不但能够改善代码的组织结构和可读性，还能够创建可扩展的程序。

前期绑定在编译时期（如C），后期绑定是在运行时期（即多态，C++与Java），多态得程序的后期扩展。

Java中除了static方法和final方法（private方法属于final方法），其他所有的方法都是后期绑定。这意味着通常情况下，我们不必判定是否应该进行后期绑定——它会自动发生。

final方法会关闭动态绑定。

类的构造方法隐式的为static，它们实际上是static方法。

如果父类构造函数抛出异常，子类构造函数一定要抛出，不能被捕获。

覆写/重写父类方法时，子类方法异常处理有以下几种：

import java.io.IOException;

public class Parent {

       public void overwrite(int i) throws IOException {}

       public void overwrite() throws NullPointerException {}

}

import java.io.ObjectStreamException;

class SubSub extends Parent {

       /*

        * 父类抛出捕获型异常，子类却抛出运行时异常，这是可以，因为

        * 抛出运行时就相当于没有抛出任何异常

        */

       public void overwrite(int i) throws RuntimeException {}

       /*

        * 如果父类抛出的是非捕获型异常，则子类可以抛出任意非捕获型异

        * 常，没有扩大异常范围这一问题

        */

       public void overwrite() throws RuntimeException {}

}

class Sub2 extends Parent {

       //也可以不抛出任何异常

       public void overwrite(int i) {}   

       /*

        * 如果父类抛出的是非捕获异常，子类也可以不用抛出，这与父类为捕

        * 获型异常是一样的

        */  

       public void overwrite() {}

}

class Sub3 extends Parent {

       //如果抛出的是捕获型异常，则只能是IOException的子类

       //!!public void overwrite(int i) throws ObjectStreamException{}   

       /*

        * 如果父类抛出的是非捕获异常，子类就不能抛出任何捕获型异常，因

        * 为这样会扩大异常的范围

        */

       //!! public void overwrite() throws IOException {}

}

组合更加灵活，因为它可以动态选择类型，运行时可以动态的修改具体的行为，而继承在编译时就知道确切类型。“用继承表达行为间的差异，并用字段（组合）表达状态上的变化。”下面实例中，两者都用到了：通过继承得到了两个不同的类，用于表达act()方法的差异；而Stage通过运用组合使用自己的状态发生变化。

//演员

class Actor {

  public void act() {}

}

//继承（is-a关系）：HappyActor（喜剧演员）确实是一种Actor（演员）

class HappyActor extends Actor {

  public void act() { System.out.println("HappyActor"); }

}

//继承（is-a关系）：HappyActor（悲剧演员）确实是一种Actor（演员）

class SadActor extends Actor {

  public void act() { System.out.println("SadActor"); }

}

//舞台

class Stage {

  private Actor actor = new HappyActor();//组合（has-a关系）：舞台上有演员

  public void change() { actor = new SadActor(); }

  public void performPlay() { actor.act(); }

}

public class Transmogrify {

  public static void main(String[] args) {

    Stage stage = new Stage();

    stage.performPlay();

    stage.change();//运行过程中改变具体性为

    stage.performPlay();

  }

} /* Output:

HappyActor

SadActor

*///:~

private方法不能被覆写，即使子类覆写也不会起作用，根据调用它的引用类型来调用相应的方法，实质上private方法就是final方法，所以在编译期就已确定调用哪个方法。

public class PrivateOverride {

  private void f() { System.out.println("private f()"); }

  public static void main(String[] args) {

    PrivateOverride po = new Derived();

    po.f();

  }

}

class Derived extends PrivateOverride {

  public void f() { System.out.println("public f()"); }

} /* Output:

private f()

*///:~

只有非静态的方法才有可能构造多态，属性成员（即使是public）与静态方法不会造成多态，即使用子类重写了这些属性成员与静态方法，因为这此是在编译期进行解析的，而不是在运行时间确定的。因此在调用属性成员与静态方法时只与调用它的引用类型相关。

class Super {

       public int field = 0;

       public int getField() {

              return field;

       }

}

class Sub extends Super {

       public int field = 1;

       public int getField() {

              return field;

       }

       public int getSuperField() {

              return super.field;

       }

}

public class FieldAccess {

       public static void main(String[] args) {

              Super sup = new Sub(); // Upcast

              System.out.println("sup.field = " + sup.field + ", sup.getField() = "

                            + sup.getField());

              Sub sub = new Sub();

              System.out.println("sub.field = " + sub.field + ", sub.getField() = "

                            + sub.getField() + ", sub.getSuperField() = "

                            + sub.getSuperField());

       }

} /*

* Output:

* sup.field = 0, sup.getField() = 1

* sub.field = 1, sub.getField() = 1, sub.getSuperField() = 0

*/// :~

上面实例中，为Super.field和Sub.field分配了不同的存储空间。这样，Sub实际上包含两个称为field的属性成员：它自己的和它从Super类中得到的。因此在子类中要得到父类中的同名属性成员时，则要使用super.field来获取。

class StaticSuper {

  public static String staticGet() {

    return "Base staticGet()";

  }

  public String dynamicGet() {

    return "Base dynamicGet()";

  }

}

class StaticSub extends StaticSuper {

  public static String staticGet() {

    return "Derived staticGet()";

  }

  public String dynamicGet() {

    return "Derived dynamicGet()";

  }

}

public class StaticPolymorphism {

  public static void main(String[] args) {

    StaticSuper sup = new StaticSub(); // Upcast

    System.out.println(sup.staticGet());

    System.out.println(sup.dynamicGet());

  }

} /* Output:

Base staticGet()

Derived dynamicGet()

*///:~

如果自己处理清理动作，则销毁的顺序应该和初始化顺序相反。对于字段，则意味着与声明的顺序相反（因为字段的初始化是按照声明的顺序进行的）。对于基类，应该首先对其子类进行清理，然后才是基类，这是因为子类的清理可能会调用基类中的某些方法，所以需要使用基类中的构件仍起作用而不应过早地销毁它们，这与C++中的析构函数形式是一样的。

在父类的构造函数中调用多态方法时，可能会引发问题：

class Glyph {

       void draw() {

              System.out.println("Glyph.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);

       }

} /* Output:

Glyph() before draw()

RoundGlyph.draw(), radius = 0

Glyph() after draw()

RoundGlyph.RoundGlyph(), radius = 5

*///:~

在构造函数内唯一能够安全调用的那些方法是基类中的final方法（当然也适用于private方法，它们自动属于final方法）。

子类覆盖父类方法时，子类的返回类型可以是父类返回类型的某个子类型，但返过来不行。

注，没有父子关系时返回类型要一样，如果允许子类返回类型是父类返回类型的子类型，则要求在J2SE5或以上版本

class Grain {}

class Wheat extends Grain {}

class Mill {

       Grain p() { return new Grain(); }

       Wheat f() { return new Wheat(); }

       float g() { return 0;}

}

class WheatMill extends Mill {

       Wheat p() { return new Wheat(); }

       //子类覆盖父类方法时返回类型不能比子类宽

       //!! Grain f() { return new Grain(); }

       //虽然int可以隐式的转换成float，但int不是float的子类，所以编译不能通过

       //!! int g() { return 0;}

}

向上转型是安全的，因为基类不会具有大于子类的接口，因此，通过基类接口发送的消息保证都能被接；由于向下转型是不安全的，所以在Java语言中，所有向下转型都会得到检查！所以即使我们只是进行一次普通宾加括弧形式的类型转换，但在进入运行期时仍然会对其进行检查，以便保证它的确是我们希望的那种类型，如果不是，运行时就会抛出一个ClassCastException的类型转换异常，这种在运行期间对类型进行检查的行为称作“运行时类型识别”（RTTI），这种我们也可以通过编程的方式来保证，在后面反射章节我们会看到。

第九章接口

一个类同时继承与实现一个类与接口时，extends要在implements前。

接口中的方法前可以加abstract关键字，也可以不加，这都将是一种抽象方法。

接口中可以什么都没有，这时是一个标志性接口，如Serializable接口。

接口其实是一种很特殊的抽象类，是一种纯的抽象类。

接口中方法前不能用static关键字，所以接口中没有静态的方法。

abtract关键词不能与static，private同时使用。

接口与抽象类不能用final来修饰。

接口中的有成员都是public，即使没有明确指出。

抽象类中抽象方法前默认访问修饰符为包访问限制，而不是public，这不象接口抽象方法前一定是public。

接口中不能有具体的方法，接口中的数据成员默认为public static final，数据成员如果写上访问控制符，只能是public，接口中的方法默认为public abstract，但可以省略。

接口中的数据成员一定要初始化，因为他是final型，但也只能在定义时就初始化，不能在静态区中赋值，因为在接口中是不能定义静态与非静态块的。

>>>>完全解耦<<<<

只要一个方法操作的是类而非接口，那么你就只能使用这个类及其子类。如果你想要将这个方法应用于不在此继承结构中的某个类，那么你就会发现在不修改当然程序应用的情况下很难做到功能动态的扩展。但接口可以在很大程度上具有灵活性，因此，它使得我们可以编写可复用性更好的代码。

下面是程序的第一个版本：

刚开始时没有考虑到后期会有不同Processor处理器扩展，对当然应用来说，它已经是完美的了，程序基本上已做到了可扩展，我们可以随时添加一种其它字符处理器。

//处理器类

class Processor {

   public String name() {

      return getClass().getSimpleName();

   }

       Object process(Object input) {

      return input;

   }

}

//大写处理器

class Upcase extends Processor {

       String process(Object input) {

      return ((String) input).toUpperCase();

   }

}

//小写处理器

class Downcase extends Processor {

       String process(Object input) {

      return ((String) input).toLowerCase();

   }

}

//应用

public class Apply {

   public static void process(Processor p, Object s) {

      System.out.println("Using Processor " + p.name());

      System.out.println(p.process(s));

   }

   public static String s = "Disagreement with beliefs is by definition incorrect";

   public static void main(String[] args) {

      process(new Upcase(), s);

      process(new Downcase(), s);

   }

}/* Output:

Using Processor Upcase

DISAGREEMENT WITH BELIEFS IS BY DEFINITION INCORRECT

Using Processor Downcase

disagreement with beliefs is by definition incorrect

*///:~

上面例子中，Apply.process()方法可以接受任何类型的Processor，并将其应用到一个Object对象上，然后输出结果，在本例中，创建一个能够根据所传递参数对象的不同而具有不同行为的方法被称为策略模式。这一类方法包含所要执行的算法是不变的，在这里不变的为Apply.process方法中的算法，而“策略”包含了变化的部分。策略就是传递进去的参数对象，它包含了动态执行的代码，在这里Processor对象就暗一个策略类，所有Processor类型的对象都能应用到Apply.process中。

下面我们来看看另一种与Processor功能相似的过滤器Filter（滤波器）：

//波形

public class Waveform {

  private static long counter;

  private final long id = counter++;

  public String toString() { return "Waveform " + id; }

}

//滤波器，与Processor接口相同

public class Filter {

  public String name() {

    return getClass().getSimpleName();

  }

  public Waveform process(Waveform input) { return input; }

}

//低通滤波器

public class LowPass extends Filter {

  double cutoff;

  public LowPass(double cutoff) { this.cutoff = cutoff; }

  public Waveform process(Waveform input) {

    return input; // 什么都不做，直接返回

  }

}

//高通滤波器

public class HighPass extends Filter {

  double cutoff;

  public HighPass(double cutoff) { this.cutoff = cutoff; }

  public Waveform process(Waveform input) { return input; }

}

上面是另一种处理器，与第一个版本“字符处理器”用途相当，都是用来过滤的，这就意味着我们能否重用Apply.process()代码呢？第一个版本的Processor肯定是不行的，因为Filter并非继承自Processor（假设它来自于其它厂商），因为Filter类的创建者压根不清楚你想要将它用作Processor，因此你不能将Filter用于Apply.process()方法。这主要原因是Apply.process()与Processor之间的耦合过紧，已经超出了所需要的程度，这就无法复用Apply.process()的代码。

但是，如果Processor是一个接口，那么这些限制就会变得宽松，就可以重用Apply.process()方法算法。

下面是Processor和Apply的修改版本：

//处理器接口，只要是处理器，都会遵循此接口，那么就可以重用Apply.process

public interface Processor {

  String name();

  Object process(Object input);

}

public class Apply {

  public static void process(Processor p, Object s) {

    System.out.println("Using Processor " + p.name());

    System.out.println(p.process(s));

  }

}

下面是重写“字符处理器”后的应用：

//字符处理器，实现处理接口

public abstract class StringProcessor implements Processor{

  public String name() {

    return getClass().getSimpleName();

  }

  //处理接口

  public abstract String process(Object input);

  public static String s ="If she weighs the same as a duck, she‘s made of wood";

  public static void main(String[] args) {

    Apply.process(new Upcase(), s);

    Apply.process(new Downcase(), s);

  }

} 

//字符大写处理器

class Upcase extends StringProcessor {

  public String process(Object input) {

    return ((String)input).toUpperCase();

  }

}

//字符小写处理器

class Downcase extends StringProcessor {

  public String process(Object input) {

    return ((String)input).toLowerCase();

  }

}/* Output:

Using Processor Upcase

IF SHE WEIGHS THE SAME AS A DUCK, SHE‘S MADE OF WOOD

Using Processor Downcase

if she weighs the same as a duck, she‘s made of wood

*///:~

下面来将Filter应用到Apply.process()方法中。由于在前面Filter已经开发完毕，假如我们现在不能修改Filter的源码，在这种情况下，我们可以使用适配器设计模式：

//适配器，适配成Processor接口

class FilterAdapter implements Processor {

  Filter filter;//对象适配器

  public FilterAdapter(Filter filter) {

    this.filter = filter;

  }

  public String name() { return filter.name(); }

  public Waveform process(Object input) {

    return filter.process((Waveform)input);

  }

} 

//重用Apply.process算法

public class FilterProcessor {

  public static void main(String[] args) {

    Waveform w = new Waveform();

Apply.process(new FilterAdapter(new LowPass(1.0)), w);

w = new Waveform();

    Apply.process(new FilterAdapter(new HighPass(2.0)), w);

  }

} /* Output:

Using Processor LowPass

Waveform 0

Using Processor HighPass

Waveform 1

*///:~

在这种使用适配器的方式中，FilterAdapter的构造器接受接口Filter，然后返回你所需要的Processor接口对象，另外，在FilterAdapter类中用到了代理。

将接口从具体实现中解耦使得接口可以应用于多种不同的具体实现，因此代码也就更具可复用性了。

>>>>Java中的多重继承<<<<

有时我们需要“一个X是一个A和一个B以及一个C”，在C++中，组合多个类的接口的行为被称为“多重继承”，这可能会出现隐藏的问题，因为每个类都有一个具体实现，但在Java中，你只能继承一个类，因些，组合多个接口，C++中的问题是不会在Java发生的。

如果一个类继承了一个类，同时实现了某个接口，父类中有一个方法与接口中的方法签名是一样，则这个类默认就已实现了这个接口，无需再实现接口中的方法，这就是默认适配器模式。

我们应该如何选择接口还是抽象类？如果要创建不带任何方法定义和成员变量的基类，那么就应该选择接口而不是抽象类，一般接口灵活性高。

接口（interface）可以继承（extends）多个接口，但只能继承一个类。

组合多个接口时名字冲突：
interface I1 { void f(); }

interface I2 { int f(int i); }

interface I3 { int f(); }

class C { public int f() { return 1; } }

class C2 implements I1, I2 {

  public void f() {}

  public int f(int i) { return 1; } // 重载

}

class C3 extends C implements I2 {

  public int f(int i) { return 1; } // 重载

}

class C4 extends C implements I3 {

  // 重写C中的方法，实现I3接口中的方法，这里可以省去该方法

  public int f() { return 1; } //重写

}

// 仅根据返回类型不同是不行的

//! class C5 extends C implements I1 {}

//! interface I4 extends I1, I3 {}

在打算组合的不同接口中使用相同的方法名通常会造成代码可读性混乱，请尽量避免这种情况。

>>>>嵌套接口<<<<