读书，收获，分享
建议后面的五角星仅代表笔者个人需要注意的程度。
Talk is cheap.Show me the code
建议31：在接口中不要存在实现代码★☆☆☆☆
本书作者的认为：如果把实现代码写到接口中，那接口就绑定了可能变化的因素，这就会导致实现不再稳定和可靠，是随时都可能被抛弃、被更改、被重构的，应避免使用。
但是在Java8中引入了default关键字，是为了解决接口的修改与现有的实现不兼容的问题（可以在不破坏java现有实现架构的情况下能往接口里增加新方法）
"因地、因时制宜"
建议32：静态变量一定要先声明后赋值★☆☆☆☆
示例代码：
先声明，后赋值
public class Client {
public static int i = 1;
static {
i = 100;
}
public static void main(String[] args) {
//运行结果：100
System.out.println(i);
}
}
先赋值，后声明
public class Client {
static {
i = 100;
}
public static int i = 1;
public static void main(String[] args) {
//运行结果：1
System.out.println(i);
}
}
静态变量的加载及赋值过程如下：
int i = 100;//在JVM中是分开执行，等价于
int i; //先分配地址空间
i = 100; //然后再赋值
/**
* 静态变量是在类初始化时首先被加载的，
* JVM会去查找类中所有的静态声明，然后分配空间，
* 注意这时候只是完成了地址空间的分配，还没有赋值，
* 之后JVM会根据类中静态赋值（包括静态类赋值和静态块赋值）的先后顺序来执行。
* 对于程序来说，就是先声明了int类型的地址空间，并把地址传递给了i，然后按照类中的先后顺序执行赋值动作，
* 首先执行静态块中i=100，接着执行i=1，那最后的结果就是i=1了。
*/
建议33：不要覆写静态方法★☆☆☆☆
示例代码：
public class Client {
public static void main(String[] args) {
Person person = new Son();
person.doSomething();
//运行结果：我是父类方法
/**
* 其实IDE挺智能的，除非特意这么写，否则基本不会出现这样的低级错误
* 再者，静态方法及属性，也不会用实例去访问
*/
}
}
public class Person {
public static void doSomething(){
System.out.println("我是父类方法");
}
}
public class Son extends Person{
public static void doSomething(){
System.out.println("我是子类方法");
}
}
一个实例对象有两个类型：表面类型（Apparent Type）和实际类型（Actual Type），表面类型是声明时的类型，实际类型是对象产生时的类型，比如我们例子，变量person的表面类型是Person，实际类型是Son。
对于静态方法来说：
- 静态方法及属性不依赖实例对象，它是通过类名访问的
- 如果通过实例调用静态方法，JVM则会通过对象的表面类型查找到静态方法的入口来执行
在子类中构建与父类相同的方法名、输入参数、输出参数、访问权限（权限可以扩大），并且父类、子类都是静态方法，此种行为叫做隐藏（Hide），它与覆写有两点不同：
- 表现形式不同。隐藏用于静态方法，覆写用于非静态方法。在代码上的表现是：@Override注解可以用于覆写，不能用于隐藏。
- 职责不同。隐藏的目的是为了抛弃父类静态方法，重现子类方法，也就是期望父类的静态方法不要破坏子类的业务行为；而覆写则是将父类的行为增强或减弱，延续父类的职责。
建议34：构造函数尽量简化★☆☆☆☆
构造函数的简繁情况会直接影响实例对象的创建是否繁。
不建议的写方法，示例代码：
public abstract class Client {
public Client() {
//获得子类提供的端口号
int potr = getPort();
//例如这种有集成关系的类调用时，无法"一眼洞穿"
//...
}
protected abstract int getPort();
}
注意：构造函数简化，再简化，应该达到“一眼洞穿”的境界。
建议35：避免在构造函数中初始化其他类★☆☆☆☆
错误写法示例代码：
public class Client {
public static void main(String[] args) {
Son son = new Son();
son.doSomething();
}
}
//造成了死循环
//在现实项目中构造函数可不是一两个，类之间的关系更加复杂，到时候是否还能瞥一眼就能看出缺陷在哪儿吗？
//解决此类问题的最好办法就是：不要在构造函数中声明初始化其他类，养成良好的习惯。
public class Person {
Person(){
new Other();
}
}
public class Son extends Person{
public void doSomething(){
System.out.println("我是子类方法");
}
}
public class Other {
Other(){
new Son();
}
}
建议36：使用构造代码块精炼程序★★☆☆☆
在Java中一共有四种类型的代码块：
（1）普通代码块
就是在方法后面使用“{}”括起来的代码片段，它不能单独执行，必须通过方法名调用执行。
（2）静态代码块
在类中使用static修饰，并使用“{}”括起来的代码片段，用于静态变量的初始化或对象创建前的环境初始化。
（3）同步代码块
使用synchronized关键字修饰，并使用“{}”括起来的代码片段，它表示同一时间只能有一个线程进入到该方法块中，是一种多线程保护机制。
（4）构造代码块
在类中没有任何的前缀或后缀，并使用“{}”括起来的代码片段。
那么构造函数和构造代码块是什么关系？构造代码块是在什么时候执行的？
构造代码块会在每个构造函数内首先执行（需要注意的是：构造代码块不是在构造函数之前运行的，它依托于构造函数的执行），如下示例：
public class Other {
{
//构造代码块
System.out.println("执行构造代码块");
}
public Other(){
//构造函数在实行时，会把构造代码块中的代码加载到此处执行，注意是在构造函数内的第一行
System.out.println("执行构造代码块");
System.out.println("执行构造方法内容...");
}
}
（1）初始化实例变量（Instance Variable）
public class Other {
public Other(){
//虽然通过如下这种定义方法的方式也能实现，但是构造代码块不用定义和调用，会直接由编译器写入到每个构造函数中
init();
}
public void init(){
System.out.println("我也能实现构造代码块的功能啊！";
}
}
（2）初始化实例环境
例如在JEE开发中，要产生HTTP Request必须首先建立HTTP Session，在创建HTTP Request时就可以通过构造代码块来检查HTTP Session是否已经存在，不存在则创建之。
构造代码块的两个特性：
在每个构造函数中都运行
在构造函数中它会首先运行
注意：很好地利用构造代码块的这两个特性不仅可以减少代码量，还可以让程序更容易阅读
建议37：构造代码块会想你所想★☆☆☆☆
public class Other {
{
System.out.println("构造代码块");
}
public Other(){
}
public Other(String str){
//如果遇到this关键字（也就是构造函数调用自身其他的构造函数时）则不插入构造代码块
//Java知道把代码块插入到没有this方法的构造函数中即可，"智能"
this();
}
}
建议38：使用静态内部类提高封装性★★☆☆☆
静态内部类的两个优点：加强了类的封装性和提高了代码的可读性
静态内部类和一般定义的类有什么区别呢？又有什么吸引人的地方呢？
提高封装性。从代码位置上来讲，静态内部类放置在外部类内，其代码层意义就是：静态内部类是外部类的子行为或子属性，两者直接保持着一定的关系
提高代码的可读性。相关联的代码放在一起，可读性当然提高了。
形似内部，神似外部。静态内部类虽然存在于外部类内，而且编译后的类文件名也包含外部类（格式是：外部类+$+内部类），但是它可以脱离外部类存在.
那静态内部类与非静态内部类有什么区别呢？
（1）静态内部类不持有外部类的引用
在普通内部类中，我们可以直接访问外部类的属性、方法，即使是private类型也可以访问，这是因为内部类持有一个外部类的引用，可以自由访问。而静态内部类，则只可以访问外部类的静态方法和静态属性（如果是private权限也能访问，这是由其代码位置所决定的），其他则不能访问。
（2）静态内部类不依赖外部类
普通内部类与外部类之间是相互依赖的关系，内部类实例不能脱离外部类实例，也就是说它们会同生同死，一起声明，一起被垃圾回收器回收。而静态内部类是可以独立存在的，即使外部类消亡了，静态内部类还是可以存在的。
（3）普通内部类不能声明static的方法和变量
普通内部类不能声明static的方法和变量，注意这里说的是变量，常量（也就是final static修饰的属性）还是可以的，而静态内部类形似外部类，没有任何限制。
建议39：使用匿名类的构造函数★☆☆☆☆
public class Other {
public static void main(String[] args) {
//list1代表创建了一个ArrayList实例
List list1 = new ArrayList();
//list2代表的是一个匿名类的声明和赋值，定义了一个继承ArrayList的内部类
List list2 = new ArrayList(){};
//list3同list2，不过多了一个初始化块，起到了构造函数的功能，初始化块就是它的构造函数
List list3 = new ArrayList(){{}};
//以上三个虽然父类相同，但是类还是不同的。
}
}
建议40：匿名类的构造函数很特殊★★☆☆☆
带有参数的匿名类声明时到底是调用的哪一个构造函数呢？
匿名类的构造函数特殊处理机制，一般类（也就是具有显式名字的类）的所有构造函数默认都是调用父类的无参构造的，而匿名类因为没有名字，只能由构造代码块代替，也就无所谓的有参和无参构造函数了，它在初始化时直接调用了父类的同参数构造，然后再调用了自己的构造代码块。
示例代码：
public class Person {
private int i, j, result;
public Person() {
}
public Person(int i, int j) {
this.i = i;
this.j = j;
}
public void count() {
result = i + j;
}
}
public static void main(String[] args) {
Person person = new Person(1, 2) {
{
count();
}
};
}
//模拟上面程序的调用
public class Add extends Other {
{
count();
}
//覆写父类的构造方法
public Add(int _i, int _j) {
}
}
建议41：让多重继承成为现实★★☆☆☆
一个曲折的实现，示例代码：
//父亲
interface Father {
public int strong();
}
//母亲
interface Mother {
public int kind();
}
public class FatherImpl implements Father {
//父亲的强壮指数是8
@Override
public int strong() {
return 8;
}
}
public class MotherImpl implements Mother{
//母亲的温柔指数是9
@Override
public int kind() {
return 9;
}
}
//儿子
public class Son extends FatherImpl implements Mother{
@Override
public int strong() {
//儿子比父亲强壮
return super.strong()+1;
}
@Override
public int kind() {
return new MotherSpecial().kind();
}
private class MotherSpecial extends MotherImpl{
public int kind(){
//儿子的温柔指数降低了
return super.kind()-1;
}
}
}
儿子继承自父亲，变得比父亲更强壮了（覆写父类strong方法），同时儿子也具有母亲的优点，只是温柔指数降低了。注意看，这里构造了MotherSpecial类继承母亲类，也就是获得了母亲类的行为方法，这也是内部类的一个重要特性：内部类可以继承一个与外部类无关的类，保证了内部类的独立性，正是基于这一点，多重继承才会成为可能。MotherSpecial的这种内部类叫做成员内部类（也叫做实例内部类，Instance Inner Class）。
注意：Java的接口是可以多继承的，也可实现上述功能，需仔细体会两者之间的区别
建议42：让工具类不可实例化★★★☆☆
工具类的方法和属性都是静态的，不需要生成实例即可访问，而且JDK也做了很好的处理，由于不希望被初始化，于是就设置构造函数为private访问权限，表示除了类本身外，谁都不能产生一个实例。
java.lang. Math代码：
public final class Math {
/**
* Don't let anyone instantiate this class.
*/
private Math() {}
}
在项目开发中有没有更好的限制办法呢？示例如下：
public class Util {
//private访问权限
private Util(){
//还抛异常
throw new Error("不允许实例化");
}
}
注意：如果一个类不允许实例化，就要保证“平常”渠道都不能实例化它。
建议43：避免对象的浅拷贝★★★☆☆
浅拷贝，它的拷贝规则如下：
（1）基本类型
如果变量是基本类型，则拷贝其值，比如int、float等。
（2）对象
如果变量是一个实例对象，则拷贝地址引用，也就是说此时新拷贝出的对象与原有对象共享该实例变量，不受访问权限的限制。这在Java中是很疯狂的，因为它突破了访问权限的定义：一个private修饰的变量，竟然可以被两个不同的实例对象访问。
（3）String字符串
这个比较特殊，拷贝的也是一个地址，是个引用，但是在修改时，它会从字符串池（String Pool）中重新生成新的字符串，原有的字符串对象保持不变。
深拷贝：对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容
浅拷贝：对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝
注意：浅拷贝只是Java提供的一种简单拷贝机制，不便于直接使用。
建议44：推荐使用序列化实现对象的拷贝★★★☆☆
如果一个项目中有大量的对象是通过拷贝生成的，那我们该如何处理？每个类都写一个clone方法，并且还要深拷贝？想想看这是何等巨大的工作量呀，是否有更好的方法呢？
可以通过序列化方式来处理，在内存中通过字节流的拷贝来实现，也就是把母对象写到一个字节流中，再从字节流中将其读出来，这样就可以重建一个新对象了，该新对象与母对象之间不存在引用共享的问题，也就相当于深拷贝了一个新对象。
示例代码：
public class CloneUtils {
public static <T extends Serializable> T clone(T obj) {
//拷贝产生的对象
T cloneObj = null;
try {
//读取对象字节数据
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(baos);
oos.writeObject(obj);
oos.close();
//分配内存空间，写入原始对象，生成对象
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bais);
//返回新对象，并做类型转换
cloneObj = (T) ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return cloneObj;
}
}
被拷贝的类只要实现Serializable这个标志性接口即可，不需要任何实现，当然serialVersionUID常量还是要加上去的，然后我们就可以通过CloneUtils工具进行对象的深拷贝了。用此方法进行对象拷贝时需要注意两点：
（1）对象的内部属性都是可序列化的
如果有内部属性不可序列化，则会抛出序列化异常，这会让调试者很纳闷：生成一个对象怎么会出现序列化异常呢？从这一点来考虑，也需要把CloneUtils工具的异常进行细化处理。
（2）注意方法和属性的特殊修饰符
比如final、static变量的序列化问题会被引入到对象拷贝中来，这点需要特别注意，同时transient变量（瞬态变量，不进行序列化的变量）也会影响到拷贝的效果。当然，采用序列化方式拷贝时还有一个更简单的办法，即使用Apache下的commons工具包中的SerializationUtils类，直接使用更加简洁方便。
建议45：覆写equals方法时不要识别不出自己★☆☆☆☆
注意：equals方法的自反性原则：对于任何非空引用x，x.equals(x)应该返回true。
建议46：equals应该考虑null值情景★☆☆☆☆
注意：equals方法的称性原则：对于任何引用x和y的情形，如果x.equals(y)返回true，那么y.equals(x)也应该返回true。
建议47：在equals中使用getClass进行类型判断★☆☆☆☆
例：在覆写equals时，对于存在继承关系的两个类，用instanceof关键字检查，当然返回true。
所以在覆写equals时建议使用getClass进行类型判断，而不要使用instanceof。
注意：equals方法的传递性原则：对于实例对象x、y、z来说，如果x.equals(y)返回true，y.equals(z)返回true，那么x.equals(z)也应该返回true。
建议48：覆写equals方法必须覆写hashCode方法★★☆☆☆
覆写equals方法必须覆写hashCode方法，这条规则是每个Javaer都应该知道的
为什么要这样做呢？
hashcode是用于散列数据的快速存取，如利用HashSet/HashMap/Hashtable类来存储数据时，都是根据存储对象的hashcode值来进行判断是否相同的。
如果我们对一个对象重写了euqals，意思是只要对象的成员变量值都相等那么euqals就等于true，但不重写hashcode，那么我们再new一个新的对象，当原对象.equals（新对象）等于true时，两者的hashcode却是不一样的，由此将产生了理解的不一致，如在存储散列集合时（如Set类），将会存储了两个值一样的对象，导致混淆，因此，就也需要重写hashcode()
建议49：推荐覆写toString方法★☆☆☆☆
为什么要覆写toString方法?
因为Java提供的默认toString方法不友好，打印出来看不懂，不覆写不行。
(默认打印出来的内容是：类名+@+hashCode)
为什么通过println方法打印一个对象会调用对象的toString方法？
System.out.println(new Person("谨以书为马"));println的实现机制：如果是一个原始类型就直接打印，如果是一个类类型，则打印出其toString方法的返回值
建议50：使用package-info类为包服务★☆☆☆☆
Java中有一个特殊的类：package-info类，它是专门为本包服务的，为什么说它特殊呢？主要体现在3个方面：
（1）它不能随便被创建
会报“Type name isnotvalid”错误，类名无效。
创建方式：用记事本创建一个，然后拷贝进去再改一下就成了，更直接的办法就是从别的项目中拷贝过来。
（2）它服务的对象很特殊
它是描述和记录本包信息的。
（3）package-info类不能有实现代码
在package-info.java文件里不能声明package-info类。
package-info类还有几个特殊的地方，比如不可以继承，没有接口，没有类间关系（关联、组合、聚合等）等，
存在即有用，主要表现在以下三个方面：
（1）声明友好类和包内访问常量
这个比较简单，而且很实用，比如一个包中有很多内部访问的类或常量，就可以统一放到package-info类中，这样很方便，而且便于集中管理，可以减少友好类到处游走的情况。
（2）为在包上标注注解提供便利
比如我们要写一个注解（Annotation），查看一个包下的所有对象，只要把注解标注到package-info文件中即可，而且在很多开源项目也采用了此方法，比如Hibernate的@FilterDef等。
（3）提供包的整体注释说明
如果是分包开发，也就是说一个包实现了一个业务逻辑或功能点或模块或组件，则该包需要有一个很好的说明文档，说明这个包是做什么用的，版本变迁历史，与其他包的逻辑关系等，package-info文件的作用在此就发挥出来了，这些都可以直接定义到此文件中，通过javadoc生成文档时，会把这些说明作为包文档的首页，让读者更容易对该包有一个整体的认识。当然在这点上它与package.htm的作用是相同的，不过package-info可以在代码中维护文档的完整性，并且可以实现代码与文档的同步更新。
总结成一句话：在需要用到包的地方，就可以考虑一下package-info这个特殊类
建议51：不要主动进行垃圾回收★★★☆☆
主动进行垃圾回收(System.gc)是一个非常危险的动作
因为System.gc要停止所有的响应（Stop the world），才能检查内存中是否有可回收的对象，这对一个应用系统来说风险极大，如果是一个Web应用，所有的请求都会暂停，等待垃圾回收器执行完毕，若此时堆内存（Heap）中的对象少的话则还可以接受，一旦对象较多（现在的Web项目是越做越大，框架、工具也越来越多，加载到内存中的对象当然也就更多了），那这个过程就非常耗时了，可能0.01秒，也可能是1秒，甚至是20秒，这就会严重影响到业务的正常运行。
注意： 不要调用System.gc，即使经常出现内存溢出也不要调用，内存溢出是可分析的，是可以查找出原因的，GC可不是一个好招数！
