Java核心技术-摘录

System.out的另一种打开方式

System.out还有一盒print方法，它在输出之后不换行。例如， System.out.print(“hello”)打赢“hello”之后不换行，后面的输出紧跟在字符 “o”之后

Java中0不能代替Boolean值

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

Java命名小技巧

变量名对大小写敏感，例如，hireday和hireDay是两个不同的变量名。在对两个不同的变量进行命名时，最好不要只存在大小写上的差异。不过，在有些时候，确实很难给变量取一个好的名字。于是许多程序员将变量名命名为列姓名，例如：
Box box; //ok…Box is the type and box is the variable name
还有一些程序员更加喜欢在变量名签名加上前缀“a”
Box aBox;

缘觉时刻：相同的变量，有多个的话，用“a”，“b”，“c”做前缀

2016-6-13·晚整理—^

变量初始化

声明一个变量之后，必须用赋值语句对变量进行显式初始化，千万不要使用未初始化的变量

C和C++区分变量的声明与定义

C和C++区分变量的声明与定义。例如：
int i = 10;
是定义一个变量，而
extern int i;
是申明一个变量。在Java中， 不区分变量的声明与定义

Java中常量定义的地方

需要注意，类常量的定义位于main方法的外部。因此，在同一个类的其他方法中也可以使用这个常量。而且，如果一个常量被声明为public，那么其他类的方法也可以使用这个常量。

Math库的近亲

在Math类中，为了达到最快的性能，所有的方法都是用计算机浮点单元中的例程。如果得到一个完全可预测的结果比运行速读更重要的话，那么就应该使用StrictuMath类。他我是用“自由发布的Math库”（fdlibm）实现算法，以确保在所有平台上得到相同的结果。

数值类型之间的转换

强制转换的注意事项

1. 如果试图将一个数值从一种类型强制转换为另一种类型，而有超出了目标类型的表示范围，结果就会截断成一个完全不同的值。例如，（byte）300的实际值为44
2. 不要在boolean类型与仍和数值类型之间进行强制类型转换，这样可以防止发生错误。只有极少数的情况才需要将布尔类型转换为数值类型，这时可以使用条件表达式b?1:0
   
   

枚举类型

有时候，变量的取值只在一个有限的集合内。例如：销售的服装或披萨饼只有小、中、大和超大这四种尺寸。当然，可以将这些吃妇女分别编码为1、2、3、4或S、M、L、X。但这样存在着一定的隐患。在变量中很可能保存的是一个错误的值（如0或m）。
从JDK5.0开始，针对这种情况，可以自定义枚举类型。枚举类型包括有限个命名的值。

例如：
 enmu Size{SMALL, MEDIUM, LARGE, EXTRA_LATGE}
现在可以申明这样一种类型的变量：
 Size s = Size.MEDIUM;
Size类型的变量智能存储这个类型声明中给定的某个枚举值，或者null值，null表示这个变量没有设置仍和值。

Java中String类的方法

Java中String类包含了50多个方法。令人惊讶的是绝大多数都很有用，可以摄像使用的频率非常高。下面API总结了几个常用的但是我不知道的方法

• int codePointAt(int index)
  返回从给定位置开始或结束的代码点
• int offsetByCodePoints(int startIndex, int cpCount)
  返回从startIndex代码开始，位移cpCount后的代码点索引
• int codePointCount(int startIndex, int endIndex)
  返回startIndex和endIndex-1之间的代码点数量。没有配成对的代用字符将计入代码点
  
  

联机API文档格式

屏幕被分成三个窗框。在左上方的小窗框中显示了可使用的所有包。在它下面少打的窗框中列出了所有的类。点击仍和一个类名之后，这个类的API文档就会显示在右侧的大窗框中。

构建字符串

有些时候，需要由较短的字符串构建字符串，例如，按键或来自文件中的单词。采用字符传连接的方式达到此目的效率比较第。每次连接字符串，都会构建一个新的String对象，即耗时，有浪费控件。用StringBuilder类就可以避免这个问题的发生。
如果需要用许都小段的字符串构建一个字符串，那么应该按照下列步骤进行。首先，构建一个空的字符串器：

StringBulder builder = new StringBuilder();

当每次需要添加一部分内容是，就调用append方法。

builder.append(ch); //appends a single character
builder.appedn(str); //appends a string

在需要构建字符串时就调用toString方法，将可以得到一个String对象，其中包含了构建器中的字符序列。

String completedString = builder.toString();

注：在JDK5.0中引入StringBuilder类。这个类的前身是StringBuffer，其效果略微有些第，但允许采用多线程的方式执行添加或删除字符的操作。如果所有字符串在一个单线程中（通常都是这样）编辑，则应该用StringBuilder替代它。这两个的API是相同的

**缘觉时刻：**StringBuilder是线程不安全的，StringBuffer是线程安全的，但是效率会低点儿

2016-6-14·晚整理—^

Java中文件读取的路径

如果文件名中包含反斜杠符号，就要机主在每个反斜杠会签再加一个额外的反斜杠，”c:\mydirectory\myfile.txt”.

Java中的相对路径

当指定一个相对文件名是，例如：“mufile.txt”,“mydirectory/myfile.txt”或 ” ../myfile.txt”. 文件位于虚拟机启动路径的相对位置。如果在命令行方式下用下列命令启动程序：
java Myprog
启动路径就是命令解释器的当前路径。然而如果使用继承开发环境，那么启动路径将有IDE控制。可以使用下面的调用凡是找到路径的卫士：
String dir = System.getProperty(“user.dir);

如果觉得定位文件比较烦恼则可以考虑使用绝对路径，
例如：“c:\mydirectory\myfile.txt”或者/home/me/mydirectory/myfile.txt”

Java不允许在嵌套块中重定义变量

在c++中，可以在嵌套的块中重定义一个变量。在内层定义的变量会覆盖在外层定义的变量。这样，有可能会导致程序设计错误，因此在Java中不允许这样做。

switch中的break 和 default

switch语句将从与选项值相匹配的case标签出开始执行指导遇到break语句，或者执行到switch语句的结束处位置。如果没有相匹配的case标签，而有defaul子句，就执行这个句子。

警告：有可能触发多个case分支。如果在case分支语句的末尾没有break语句，那么就会接着执行下一个case分支语句。这种情况相当危险，常常会引发错误。为此，我们在恒续重从不使用switch语句。

带标签的break语句

与c++不同，Java还提供了一种带标签的break语句，用于跳出多重嵌套的循环语句。有时候，在嵌套很深的循环语句中会发生一些不可预料的事情。此时可能更加希望调到嵌套的所有循环语句之外。通过添加一些额外的条件判断试下各层循环的检测很不方便。

这里有一个实例说明了break语句的工作状态。请注意，标签必须放在希望跳出的最外层循环之前，并且必须紧跟一个冒号。

Scanner in = new Scanner(System.in);int n;read_data://此处用冒号while(...)//this loop statement is tagged with the label{    ...    for(...)//this inner loop is not labled    {        System.out.print("Enter a number >=0:");        n = in.nextInt();        if(n<0)//should never happen-can not go on            break read_data;            //break out of read_data loop        ...    }}//this statement is exeuted immediately after the labeled breakif(n<0)//check for bad situation{    //deal with bad situation}else{    //carry out normal processing}

如果输入有误，通过执行带标签的break跳转到带标签的语句块末尾。对于仍和使用break语句的代码都需要检测循环值正常结束，还是break跳出。

注释：试试阿红，可以将标签应用到仍和语句中，升值可以应用到if语句或者块语句中，如下所示：

label:{    ...    if(condition)break label;//exits block}//jumps here when the break statement executes

因此，如果希望使用一条goto语句，并将一个标签放在想要跳到的语句块之前，就可以使用break语句！，当然，并不提倡使用这种方式。另外需要注意，智能跳出语句块，而不能跳入语句块。

还有一种带标签的continue语句，将跳到与标签匹配的循环首部。

Java中的大数值

如果基本的整数和浮点数精度不能够满足需求，哪儿可以使用java.amth包中的两个很有用的类：BigInteger和BigDecimal。这两个类可以处理包含任意长度数据序列的数值。BigInteger类实现了任意精度的整数运算，BigDecimal实现了任意精度的浮点运算。

使用静态的valueOf方法可以将普通的数值转换为大数值：

BigInteger a = BigInteger.valueOf(100);

遗憾的是，不能使用人们熟悉运算符（如：+和*）处理大数据。而需要使用大数值类中的add和multiply方法。

BigInteger c = a.add(b); // c=a+bBigInteger d = c.mutiply(b.add(BigInteger.valueOf(2)));//d = c + （b + 2）

2016-6-15·晚整理—^

增强for循环优点

for each循环语句的循环变量将会遍历数组中的每个元素，而不需要使用下标值

Java中允许数组的长度为0

在Java中，允许数组的长度为0。在编写一个结果为数组的方法时，如果碰巧结果为空，则这种语法形式就显得非常有用。此时可以创建一个长度为0的数组：

new elementTyoe[0]

注意，数组长度为0与null不同

数组拷贝

在Java中，允许将一个数组变量拷贝给另一个数组变量。这时，两个变量引用同一个数组：

int[] luckNumber = smallPrimes;luckyNumber[5] = 12;//now smallPrimes[5] is also 12

下图显示了拷贝的结果。如果希望讲一个数组的所有值拷贝到一个新的数组中去，就要使用Arrays类中的copyOf方法：

int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length);

第2个参数是数组的长度。这个方法通常用来增加数组的大小：

luckNumbers = Arrays.copyOf(luckyNumbers, 2* luckyNumbers.length);

如果数组的元素是数值型，那么多雨的元素将被赋值为0；如果数组元素是boolean型，则将赋值为false。相反，如果长度小于原始数组的长度，则只拷贝最前面的数据元素。

for each访问二维数组

for each循环语句不能自动处理二维数组的每一个元素。它是按照航，也就是一维数组处理的。要想访问二维数组的所有元素，需要使用两个嵌套的循环，如下所示：

for(double[] row : a)    for(double value : row)        do something with value

要想快速地打印一个二维数组对的元素列表，可以调用：

System.out.println(Arrays.deepToString(a));//输出//[[16,3,2,13],[5,10,11,8],[9,6,7,12],[4,15,14,1]]

类

类（class）是构造对象的模板或蓝图。我们可以将类想象成小甜饼的切割机，将对象想象为小甜饼。由类构造（construst）对象的过程成为创建类的实例（instance）。

正如前面所看到的，用Java编写的所有代码都位于某个类的内部。标准的Java库提供了几千个类，可以雍奴用户界面设计、日期、日历和网络程序实际。经管如此，还是需要在Java程序中穿件一些自己的类，一遍描述应用程序所对应的问题域中的对象。

封装（encapsulation，有时称为数据隐藏）是与对象有关的一个重要概念。从形式上看，封装不过是将数据和行为组合在一个包中，并对对象的使用者隐藏了数据的实现方式。对象中的数据称为实例域（instance field），操纵数据的过程称为方法（method）。对于每个特定的类实例（对象）都有一组特定的实例域值。这些值的集合就是这个对象的当前状态（state）。无论合适，只要向对象发送一个消息，它的状态就可能发生改变。

实现封装的关键在于绝对不能让类中的方法直接地访问其他类的实例域。程序仅通过对象的方法与对象数据进行交互。封装给予对象了“黑盒”特征，这是提高重用性和可靠性的关键。这意味着一个类可以完全地改变存储数据的方式，只要仍旧使用同样的方法操作数据，其他对象就不会知道或介意所发生的变化。

OOP的另一个原则会让用户自定义Java类变得轻松而易举，这就是：类可以通过扩展另一个类来简历。事实上，在Java中，所有的类都源自于一个“神通广大的超类”，它就是Object。

缘觉时刻： Object类，Java中的上帝

在对一个已有的类扩展时，这个扩展后的新类具有所扩展的类的全部属性和方法。在新类中，只需要提供那些仅适用与这个类的新方法和数据域就可以了。通过扩展一个类来简历另一个类的过程被成为继承（inheritance）。

对象

要想使用OOP，一定要清楚对象的三个主要特性：

• 对象的行为（behavior）——可以对对象施加哪些操作，或可以对对象施加哪些方法。
• 对象的状态（state）——当施加那些方法时，对象如何响应。
• 对象标识（identity）——如何辨别具有相同行为与状态的不同对象。

如何识别类

识别类的简单规则就是在分析问题的过程中寻找名词，而方法对应着动词。

类之间的关系

• 依赖（“uses-a”）
• 聚合（“has-a”）

• 继承（“is-a”）

  依赖（dopendence），即“uses-a”关系，是一种最明显的、最常见的关系。
  如果一个类的方法操纵另一个类的对象，我们就说一个类依赖于另一个类。
  我们应该尽可能地将相互一类的类减至最少。如果A不知道B的存在，它就不会关心B的任何改变（这意味着B的改变不会导致A产生任何bug）。即耦合度最小。

聚合（aggregation），即“has-a”关系，是一种具体且易于理解的关系。聚合的关系意味着类A的对象包含类B的对象。

继承（inheritance），即“is-a”关系，是一种用于表示特殊与一般关系的。

废弃，不鼓励使用的类的由来

实际上，Date类还有getDay、getMonth以及getYear等方法，然而并不推荐使用这些方法。

当类库的设计者意识到某个方法不应该存在时，就把它标记为不鼓励使用。

当类库的设计者意识到单独设计日历类更有实际意义时，这些方法已经是Date类的一部分。引入日历类之后，Date类中的这些方法被标明为不鼓励使用，虽然在程序中仍然可以使用它们，但是如果这样做，编译时会出现警告。最好还是不要使用这部分方法，它们有可能会从未来的类库版本中删去。

更改器方法，访问器方法

对实例做出修改的方法称为修改器方法（mutator method）， 仅访问实例域而不进行修改的方法被称为访问器方法（accessor method）。

2016-6-18·晚整理—^

Java不允许重载参数和方法签名的方法

注释：Java允许重载任何方法，而不只是构造器方法。因此，要完整地描述一个方法，需要指出方法名以及参数类型。这叫做方法的签名（signature）。例如，String类有4个称为indexOf的公有方法。它们的签名是：

    indexOf(int)    indexOf(int, int)    indexOf(String)    indexOf(String, int)

返回类型不是方法签名的一部分。也就是说，不能有两个名字相同、参数类型也相同却返回不同的类型值的方法。

实例域前缀

注释：在c++中，经常一共下划线或某个固定的字母（一般选用m或x）作为实例域的前缀。例如，salary域可能被命名为_salary、mSalary或xSalary。Java程序员通常不这样做。

下面是调用构造器的具体处理步骤：

1. 所有数据域被初始化为默认值（0、false或null）。
2. 按照在类声明中出现的次序，一次执行所有域名初始化语句和初始化块。
3. 如果构造器第一行调用了第二个构造器，则执行第二个构造器主体。
4. 执行这个构造器的主体。
   
   

不再使用某个类一定要关闭

如果某个资源需要在使用完毕后like被关闭，那么就需要由人工来管理。可以应用一个类似dispose或close的方法完成相应的清理操作。特别需要说明，如果一个类使用了这样的方法，当对象不再被使用时一定要调用它。

为了使类能够被多个程序共享，需要做到下面几点：

提示: JAR文件使用ZIP格式组织文件和子目录。可以使用所有ZIP使用程序查看内部的rt.jar以及其他的JAR文件。
为了使类能够被多个程序共享，需要做到下面几点：
1. 把类防盗一个目录中，例如/home.user.classdir。需要注意，这个目录是包树状结构的基目录。如果希望将com.horstmann.corejava.Employee类添加到其中，这个Employee.class类文件就必须位于子目录/home/user/classdir/com/horstmann/corejava中。
2. 将JAR文件放在一个目录中，例如：/home/user/archives。
3. 设置类路径（class path）。类路径是所有包含类文件的路径的集合。

方法注释

* @param variable description    这个标记将对当前方法的“param”（参数）部分添加一个条目。这个描述可以占据多行，并可以使用HTML标记。一个方法的所有@param标记必须放在一起。* @return description    这个标记将对当前方法添加“return”（返回）部分。这个描述可以跨越多行， 并可以使用HTML标记。* @throws class description    这个标记将添加一个注释，用于表示这个方法有可能抛出异常。

域注释

只需要对共有域（通常值得是静态常量）简历文档。例如，

    只需要对共有域（通常值得是静态常量）简历文档。例如，

2016-6-28·晚整理—^

通用注释

下面的标记可以用在类文档的注释中。

• @author name
  这个标记将产生一个“author”（作者）条目。可以使用多个@author标记，每个@author标记对应一名作者。

• @version text
  这个标记将产生一个“version”（版本）条目。这里的text可以是对引入特性的版本描述。下面的标记可以用于所有的文档注释。

• @science text
  这个标记将产生一个“since”（始于）条目。这里的text可以是对引入特性的版本描述。例如@since version 1.7.1

• @deprecated text
  这个标记将对类、方法或变量添加一个不再使用的注释。 text中给出了取代的建议。例如

     @deprecated Use <code>setVisible(true)</code> instead

通过@see 和 @link标记，可以使用超级链接，连接到javadoc文档的相关部分或外部文档。

• @see reference
  这个标记将在“see also”部分增加一个超级链接。它可以用于类中，也可以用于方法中。这里的reference可以选择下列情形之一：

            package.class#feature label            <a href="...">label</a>            "text"

第一种情况是最常见的。只要提供类、方法或变量的名字，Java东侧就在文档中插入一个超链接。例如，

建立一个连接到com.horstmann.corejava.Employee类的raiseSalary（double）方法的超链接。可以省略包名，甚至把包名和类名都省去，此时连接将定位于当前包或当前类。需要注意，一定要使用井号（#），而不要使用句号（.）分隔类名与方法名，或类名与变量名。Java编译器本省可以熟练的断定句点在分隔包、子包、类、内部类与方法名和变量时的不同含义。但是javadoc实用程序就没哟这么聪明了，因此必须对它提供帮助。

如果@see标记后面有一个<字符，就需要指定一个超链接。可以超连接到任何URL。例如：

    @see <a href="www.horstmann.com/corejava.html">The core Java home page</a>

在上述各种情况下，都可以指定一个可选的标签（label）作为锚链接（link anchor）。如果省略了label用户看到的锚的名称就是目标代码名或URL。
如果@see标记后面有一个双引号（*）字符，文本就会显示在“see also”部分。例如，

    @see “Core Java 2 volume 2"

可以为一个特性添加多个@see标记，但必须将他们放在一起。

如果愿意的话，还可以在主时钟的仍和位置指向其他类或方法的超级链接，以及插入一个专用的标记，例如，

    {@link package.class#feature label}

这里的特性描述规则与@see标记规则一样

类设计技巧

1. 一定要将数据设计为私有。
2. 一定要对数据初始化。
3. 不要在类中使用过多的基本数据类型。
4. 不是所有的域都需要独立的域访问器和域更改器。
5. 使用标准格式进行类的定义。
   一定采用下面的顺序书写类的内容：
   
   • 公有访问特性部分
   • 包作用域访问特性部分
   • 私有访问特性部分
   • 在每一部分中，应该按照下列顺序列出：
     
     • 静态域
     • 实例域
     • 静态方法
     • 实例方法
6. 将职责过多的类进行分解。
   
   

super不是一个对象的引用

注释：有些人认为super与this引用是类似的概念，实际上，这样比较并不太恰当。这是因为super不是一个对象的应用，不能将super赋给另一个对象变量，它只是一个只是编译器调用超类方法的特有关键字。

正向前面所看到的那样，在子类中可以增加域、增加方法或覆盖超类的方法，然而绝对不能删除继承的仍和域和方法。

C++中super的使用

C++注释：在Java中使用关键字super调用超类的方法，而在C++中则采用超类名加上::操作符的形式。例如，在Manager类的getSalary方法宏，应该讲super.getSalary替换为Employee::getSalary。

多态与动态绑定

一个对象变量（例如 ，变量e）可以引用多重实际类型的现象被称为 多态（polymorphism）。在运行时能够自动地选择调用哪个方法的现象称为动态绑定（dynamic binding）

动态绑定的解析过程

在运行的时候，调用e.getSalary()的解析过程为：

1. 首先，虚拟机提取e的实际类型的方法表。既可能是Employee、Manager的方法表，也可能是Employee类的其他子类的方法表。
2. 接下来，虚拟机搜索定义getSalary签名的类。此时，虚拟机已经知道应用调用哪个方法。
3. 最后虚拟机调用方法。
   
   

动态绑定的重要特性

动态绑定有一个非常重要的特性：无序对现存的代码进行修改，就可以对程序进行扩展。

下面给出编写一个完美的equals方法的建议：

1. 显示参数命名为otherObject, 稍后需要将它转换成另一个叫做other的变量。

2. 检测this与otherObject是否引用同一个对象：
   if(this==otherObject) return ture;
   这条语句只是一个优化。实际上，这是一种经常采用的形式。因为计算这个等式要比一个一个的比较类中域所付出的代价小得多。

3. 检测 otherObject是否为null， 如果为null，返回false。这项检测是很必要的。
   if(otherObject==null) return false;

4. 比较this与otherObject是否属于同一个类。如果equals的语义在每个子类中有所改变，就是用getClass检测：
   if(getClass() !=otherObject.getClass()) return false;
   if(!(otherObject instanceof ClassName)) reutrn false;

5. 将otherObject转换为相应的类类型变量：
   ClassName other = (ClassName)otherObject

6. 现在开始对所有需要比较的域进行比较了。使用==比较基本类型域，使用equals比较对象域。如果所有的域都匹配，就返回true，否则返回false。

    return field1 == other.field1                 && field2.equals(other.field2)                && ...;

如果在子类中重新定义equals，就要在其中包含调用super.equals(other).

提示：对于数组类型的域，就要在其中包含调用super.equals(ohter).

2016-6-29整理—^

类的equals写法：

public boolean eqyals(Object otherObject){    //a quick test to if the objects are identical    if(this == otherObject) return true;    //must return false if the explicit parameter is null    if(otherObject == null) return false;    //if the classes don't match, they can't be queal    if(getClass()!=otherObject.getClass()) return false;    //now we know otherObject is a non-null Emploee    Emploee other = (Employee)otherObject;    //test whether the fields have identical values    return name.equals(other.name) && salary == other.salary && hireDay.equals(other.hireDay);}

ArrayList可以传递初始容量：

另外，还可以把初始容量换递给ArrayList构造器：

ArrayList staff = new ArrayList(100);

警告：分配数组列表，如下所示：

new ArrayList(100) //capacity is 100;

它与为新数组分配空间有所不同：

new Employee[100] //size is 100

数组列表的容量与数组的大小有一个非常虫咬的区别。如果为数组分配100个元素的存储空间，数组就有100个空位可以使用。而容量为100个元素的数组列表只是拥有保存100个元素的潜力（实际上，重新分配空间的话，将会超过100），但是在最初，甚至完成初始化构造时候，数组列表根本就不含有任何元素。

关于ArrayList的，我不知道的两个方法签名：

void ensureCapacity（int capacity）

确保数组列表在不重新分配存储空间的情况下就能够保存给定数量的元素。
参数：capacity 需要存储的容量

void trimToSize()

将数组列表的存储铜梁削尖到当前尺寸

2016-8-25整理—^

参数列表中接受任意数量对象的方法：

前面已经看到过这样的方法：printf。例如，下面的方法调用：

System.out.printf("%d", n);

和

System.out.printf("%d %s", n, "widgets");

在上面两句语句中，尽管一个调用包含两个参数，另一个调用包含三个参数，但塔恩调用的都是同一个方法。printf方法是这样定义的：

public class PrintScream{    public PrintStream printf(String fmt, Object... args){ return format(fmt, args);}}

这里的省略号…是Java代码的一部分，它表明这个方法可以接受任意数量的对象（除fmt参数之外）。
换句话说，人对于printf的实现者来说，Object…参数类型域Object[]完全一样。

枚举：

enum Size{    SMALL("S"), MEDIUM("M"),LARGE("L"),EXTRA_LARGE("XL);    private Size(String abbreviation){this.abbreviation==abbreviation;}    public String getAbbreviation(){return abbreviation;}    private String abbreviation;}

java.lang.Enum5.0

• static Enum valueOf(Class enumClass, String name)
  返回指定名字、给定类的枚举常量。
• String toSteing()
  返回枚举常量名
• int ordinal()
  返回枚举常量在enum声明中的位置，位置从0开始计数。
• int comparaTo(E other)
  如果枚举常量出现在other之前，则返回一个负值；如果this==other,则返回0;否则，返回正值。枚举常量的出现次序在enum声明职工给出。

用反射强制访问一个类的方法：

java.lang.reflect.AccessibleObject 1.2

• void setAccessible(boolean flag)
  为反射对象设置可访问标志。flag为true表明屏蔽Java语言的访问检查，是的对象的私有属性也可以被查询和设置。
• boolean isAccessible()
  返回反射对象的可访问标志的值。
• static void setAccessible(AccessibleObject[] array.boolean flag)
  是一种设置对象数组可访问标志的快捷方法。

 

缘觉时刻： 暴力反射开关

2016-8-27整理—^

反射中在必要的时候才使用Method：

有鉴于此，建议仅在必要的时候才使用Method对象，而最好使用接口和内部类。特别要重申：建议Java开发者不要使用Method对象的回调功能。使用接口进行回调会是的代码的执行速度更快，更易于维护。

继承设计的技巧：

1. 将公共操作和域放在超类
2. 不要使用受保护的域
3. 使用继承实现“is-a”关系
4. 除非所有继承的方法都有意义，否则不要使用继承。
5. 在覆盖方法时，不要改变预期的行为。
6. 使用多态，而非类型信息。
7. 不要过多地使用反射。
   
   

代理是一种实现任意接口的对象：

代理是一种实现任意接口的对象。代理是一种非常专业的构造工具，它可以用来构建系统级工具。

2016-8-30整理—^