Java中那些容易忽略的点

读书笔记

【Eckel B, 陈昊鹏. Java 编程思想[J]. 2005.】

• 类描述了有相同特性（数据元素）和行为（功能）的对象集合，即数据类型
• 将对象看做服务提供者有一个好处：有助于提高对象的内聚性。高内聚是软件设计的基本要求，意味着一个软件构建的各个方面"组合"的很好
• 每个对象都可以很好的完成一项任务，但它并不试图做更多的事
• 导出类和基类具有相同的类型。如"一个圆形也是一个几何形"
• 一个非面向对象编程的编译器产生的调用会引起所谓的"前期绑定"，但面向对象的程序设计语言使用了"后期绑定"的概念，当向对象发送消息时，被调用的代码直到运行时才能确定，而不是在编译的时候确定
• 同C++不同，部分OOP语言（包括Java）是单根集成的，这保证了所有的对象都具备某些功能，并且使得垃圾回收的实现容易很多
• Java是动态内存分配方式，且由于"垃圾回收器"机制的存在，Java减少了很多思考的问题和编写的代码
• 异常处理提供了一种从错误状况进行可靠恢复的途径。现在不再只能退出程序，你可以经常进行校正并恢复程序的执行
• 在单处理器上的多线程并发是为了提高处理器的利用率，而多处理器上的多线程并发是真正的并发执行
• 信息存储池、用于分发信息的软件以及信息与软件所驻留的机器或机群被总称为服务器。Web最初的"服务器-浏览器"设计是为了能够提供交互性的内容。但Java的applet并没有获得预想的成功
• Java中操作的标识符是对象的一个引用。引用可以独立存在而不与对象关联（如：String s；这时s是一个独立的引用不指向任何对象）
• 程序运行时有五个不同的地方可以存储数据：寄存器（最快，位于处理器内部，无法自主控制）、堆栈（位于RAM（随机访问存储器）中，创建程序时Java系统必须知道存储在堆栈内的所有项的确切生命周期，以便上下移动堆栈指针分配和释放内存）、堆（位于RAM中，编译器无需知道存活时间）、常量存储（常量值通常直接存放在程序内部）、非RAM存储（如流对象用于传输；持久化对象用于对象的保存于恢复）
• Java中有几种基本类型，不像常规对象new一个后存于堆中，而是直接创建一个并非是引用的"自动"变量，直接存储"值"并置于堆栈中【注1】
• 基本类型的生命周期脱离了作用于就会消失，但是Java对象可与存活早作用域之外【注2】
• 除了静态方法是通过类调用之外，其他方法都是通过对象调用
• void方法中可以使用return关键字，此时其作用只是推出方法，因此可以在任何地方返回
• main（）方法的输入参数必须是"String[] args"，这是Java编译器要求的，因为args要用来存储命令行参数
• Javadoc文档注释，在/**···*/中可以有很多标签，如@see，@version，@since，@author，@param，@throws等等
• 对于赋值操作，要注意：对于基本类型而言，由于基本类型存储的实际的数值，而并非指向一个对象的引用，所以赋值实际上是将一个地方的内容复制到了另一个地方。但对于对象而言，赋值是将"引用"从一个地方复制到了另一个地方，对象不会复制
• 逻辑运算中存在短路现象，即当计算A&&B时，如果A为false，则B不计算；同理A||B时若A为true则B不计算
• 位运算符"与"(&)、"或"(|)、"非"(~)。注意，由于我们把布尔类型作为一种单比特值对待，所以可以对布尔值执行与、或、异或（非除外）操作，只是它们不会中途"短路"
• "<<"左移位操作符，低位补0；">>"右移位操作符，若符号为正，则高位补0；否则高位补1；当然，Java中的"无符号"右移操作符">>>"高位补0
• 如果对基本数据类型执行算术运算或者按位运算，那么只要类型比int小（即char、byte或short），则运算前都会被自动转换为int。那么再把结果赋给较小的类型时就必须使用类型转换
• 基本类型中，除了boolean外其他的都可以通过类型转换变为其他类型
• break与continue和标签的配合能够其他goto的作用（Java没有goto，但是有这个关键字）：一般的continue会退回最内层循环的开头（顶部），并继续执行；带标签的continue会到达标签的位置，并重新进入紧接在那个标签后的循环；一般的break会中断并跳出当前循环；带标签的break会中断并跳出标签所指的循环
• switch的选择因子必须是int或char那样的整数值（还可以是enum）
• 方法重载时，参数顺序的不用也足以区分两个方法，但是不建议这么用
• this关键字只能在方法内部使用，表示对"调用方法的那个对象"的引用
• Java允许在类中定义一个名为finalize（）的方法。它的工作原理"假定"是：一旦垃圾回收器准备好释放对象占用的存储空间，将首先调用其finalize方法，并且下一次垃圾回收动作发生时才会真正的回收对象占用的内存，但这种情况一般发生在使用"本地方法"的情况下
• Java虚拟机的垃圾回收针对具体情况的自适应回收方式，这种方式为成为"自适应的、分代的、停止-复制、标记-清扫"
• 在类的内部，变量定义的先后顺序决定了出售计划的顺序。即使变量定义散步在方法之间，他们仍旧会在任何方法（包括构造器）初始化之前被初始化
• 对于对象创建的过程，假设有个名为Dog的类，则：即使没有使用static，构造器实际上也是静态方法，因此当首次创建类型为Dog的对象时，或者Dog类的静态方法/静态域首次被访问时，Java解释器必须查找类路径，以定位Dog.class文件；然后载入Dog.class（这会创建一个class对象），有关静态初始化的所有动作都会执行。因此，静态初始化只在class对象首次加载时进行一次；当用new Dog（）创建对象时，首先在堆上为Dog对象分配足够的存储空间；这块存储空间会被清零，这就自动将Dog对象中所有基本类型都设置成了默认值，而引用被设置为null；执行所有出现于字段定义出的初始化工作；执行构造器
• 枚举类enum的用法：enum的实例可以使用如ordinal（）方法、values（）方法，并且enum可以用于switch中
• Java的访问权限public、protected、default（friendly）、private【注3】
• 一个Java文件并不等于一个类，因为1个Java文件可以有多个类，相应的编译后会有多个class文件
• 取得对某一成员的访问权限的途径有一种方式是提供访问器和变异器（也称set/get方法），而这也是JavaBean的基本原理
• 可以为每一个类都创建main方法，这种每个类都设置一个main（）方法的技术可以使每个类的单元测试都变得简便可行
• Java会自动在导出类的构造器中插入对基类构造器的调用，并且，构造过程是从基类"向外"扩散的，所以最底层的最先被初始化
• 想要的，如果基类是带参数的构造器，则在子类构造器中的第一件事就是调用基类的构造器（显式的super调用）
• 代理：基类Class A，代理类Class B中取得A的实例，并对A的相关方法进行封装，则可以通过B实现A的方法但是却不对外保罗A的方法，这是代理相对于继承的好处
• "为新的类"A并不是继承技术A最重要的方面，其最重要的方面是用来实现新类与基类的关系，即"新类是现有类的一种类型"
• final数据：final用于基本类型时，作用是使数值恒定不变；final用于对象引用时，作用是使引用恒定不变，但是引用的对象而言，其对象变身是可以修改的，这一限制同样适用于数组，因为数组也是对象
• final方法：final方法主要用于禁止子类对父类的覆盖。因此，类中所有的private方法都隐中式的指定为final，因为它们都不会被继承，更不会被覆盖了
• final类：final类表明你不打算继承该类，也不打算允许别人继承
• Java中出了static方法和final方法（所有private方法默认属于final方法）之外，其他的方法都是后期绑定（动态绑定/运行时绑定），即程序运行时能确定类型，这正是Java实现多态的基础
• 复杂对象调用构造器的顺序为：调用从基类开始到导出类的构造器；按声明顺序调用成员的初始化方法；调用导出类构造器的主体
• 有抽象方法的类一定是抽象类，则不可实例化，但是抽象类可以没有抽象方法，此时纯粹是为了不被实例化
• 接口的一中常见用法就是策略设计模式；接口的任何域都自动是static和final的；接口是实现多重继承的途径
• 生成遵循某个接口的对象的典型方式是工厂方法设计模式
• 将一个类的定义放在另一个类的定义内部，这就是内部类
• 要从外部类的非静态方法之外的人员位置创建某个内部类的对象必须指明这个对象的类型：OutClassName.InnerClassName
• 内部类对象能访问其外围对象的所有成员而不需要任何特殊条件，此内部类还拥有外围类的所有元素的访问权
• 在内部类要生成对外部类对象的引用可以使用OutClassName.this；创建某个内部类的对象可以用.new，即OutClassName.InnerClassName A = outObject.new InnerClassName（）
• 内部类不仅可以定义在类的内部，还可以定义在方法中活任意的作用域内
• 如果不需要内部类对象与其外围类对象之间有联系，那么可以将内部类声明为static，这通常称为"嵌套类"。此时意味着：要创建嵌套类的对象不需要其外围类对象；不能从嵌套类对象中访问非静态的外围类对象
• 普通内部类不能有static数据和static方法，也不能包含嵌套类，但是嵌套类可以包含所有的这些东西
• 正常情况下不能在接口中放置任何代码，但是嵌套类可以作为借口的一部分，一个内部类被嵌套多少层并不重要，它能透明的访问所有它所嵌入的外围类的所有成员
• 内部类的特性（即为什么我们需要内部类）：内部类可以有多实例，并且每个实例都有自己的状态信息，且与其外围类对象的信息相互独立；单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或继承同一个类；创建内部类对象的时刻并不依赖于外围类对象的创建；内部类没有令人迷惑的"is-a"关系，他就是一个独立实体
• Java的集合类/容器类的基本类型有List、Set、Queue和Map【注4】
• 迭代器：一个轻量级的对象，不必确切的知道容器类型，有hasNext（）、next（）、remove（）可供使用，可以通过collection.Iterator得到
• ListIterator：只用于List的可双向移动的迭代器
• LinkedList提供方法支持队列以及栈的行为，并且它实现了Queue接口，因此LinkedList可以看做Queue的一种实现
• priorityQueue：优先级队列
• 新程序不应该使用过时的Vector、HashTable以及Stack
• Map与Collection之间的重叠点在于Map可以使用entrySet（）取到Collection
• 事务的基本保障是我们所需的在分布式计算中的异常处理。事务是计算机中的合同法，如果出了什么问题，我们只需要放弃整个计算--By 图灵奖得主Jim Gray
• printStackTrace（）方法提供的信息可以通过getStackTrace（）方法来直接访问，这个方法返回栈轨迹中元素构成的数组，其中每一个元素都表示栈中的一帧【注5】
• 常常会想在捕获一个异常时抛出另一个异常，并且希望把原始异常的信息保存下来，这成为异常链。Throwable子类中Error、Exception以及RuntimeException提供带cause参数的构造器，可以实现异常链
• Throwable子类中Error通常不用我们来关心，所以Exception是可以被抛出的基本类型
• 只能在代码中忽略RuntimeException（及其子类）的异常，其他类型的异常的处理都是由编译器强制实施的
• 当要把除内存之外的资源回复到它们的初始状态时，就需要finally子句，包括：已经打开的文件或网络连接，在屏幕上画的图形等等
• catch（AException a）会捕获AException以及所有从它派生的异常
• 异常使用指南（应该在下列情况下使用异常）：在恰当的级别处理问题（即只有在你知道如何处理的情况下才捕获异常）；解决问题并重新调用产生异常的方法；进行少许修补，然后绕过异常发生的地方继续执行；用别的数据计算，以代替方法预计返回的值；把当前运行环境下能做的事尽量做完，然后把相同的异常抛到更高层；把当前运行环境下能做的事尽量做完，然后把不同的异常抛到更高层；终止程序；进行简化；让类库和程序更安全
• 每当把String对象作为方法的参数时，都会复制一个引用，而该引用所指的对象其实一直待在单一的物理位置上，从未动过
• Formatter类提供了相当多的格式化功能
• 正则表达式是一种强大而灵活的文本处理工具，它提供了一种完全通用的方式，能够解决各种字符串处理的问题：匹配、选择、验证等
• Pattern类的compile（）方法有一种可以接受一个标记参数，以调整匹配的行为，如Pattern.CANNON_EQ、Pattern.INSENSITIVE等，典型用法见【注6】
• 默认情况下，scanner会根据空白字符对输入进行分词，但是你也可以用正则表达式指定自己的定界符。此时可以使用useDelimiter（）
• 被称为class对象的特殊对象包含了与类有关的信息，Java使用class对象来执行RTTI（Run Time Type Information）：运行时类型信息。所有的类都是对其第一次使用时动态加载至JVM中的。当程序创建第一个对类的静态成员的引用时就会加载这个类。这种动态加载的行为，让很多特性的实现成为了可能
• 无论何时，只要你想在运行时使用类型信息，就必须首先获得对恰当class对象的引用，而Class.forName（）就是实现此功能的途径，如Class classA = Class.forName（）；或者可以用另一种形式：Class classA = CLassA.class；
• Java的三种RTTI形式：传统的类型转换，如（Cicle）shape；代表对象类型的class对象，通过查询class对象获取运行时信息；使用关键字instanceof
• 当通过反射与一个未知类型的对象打交道时，JVM只是简单的检查这个对象，看它属于哪个特性的类（就像RTTI那样）。在用它做其他事前必须加载哪个类的class对象。也就是说哪个类的.class文件对JVM来说必须是可获取的。所以RTTI与反射的区别只在于：对于RTTI来说，编译器在编译时打开和检查.class文件；对于反射磊说，.class文件在编译时不可获取，是在运行时打开和检查
• 泛型实现了参数化类型的概念，使代码可以应用于多种类型
• 这种尖括号括起来的叫做类型参数，无论何时，只要你能做到，就应该尽量使用泛型方法取代将整个类泛型化
• 无论使用哪种类型的数组，数组标识符起始只是一个引用，指向在堆中创建的一个真实对象，这个对象用以保存指向其他对象的引用
• Java.util类库中可以找到Arrays类，它有一套用于数组的statci使用方法，如sort（）、fill（）、binarySearch（）、hashcode（）等，此外，Arrays.asList（）可以接受任一序列或数组，将其转为List
• System.arraycopy（）可以复制数组，效率比for循环高很多（底层实现是native的。一个native方法就是一个java调用非java代码的接口。一个native方法是这样一个java的方法：该方法的实现由非java语言实现，比如C。）
• 某些编程语言被设计为可以将并发任务彼此隔离，这些语言通常被称为函数性语言，其中每个函数调用都不会产生任何副作用
• Java的线程机制是抢占式的，这表示调度机制会周期性的中断线程，将上下文切换到另一个线程，从而为每个线程都提供时间片
• Thread.yield（）这个静态方式是对线程调度器的一种建议，它在声明："我已经执行完生命周期中最重要的部分了，此刻正是切换到其他任务执行一段时间的大好时机"
• 尽管Thread.start（）方法看起来是产生了一个对长期运行方法的调用，但实际是它会迅速返回，因为它只是启动另一个线程，所以不会影响当前线程的继续执行
• 线程的优先级是将线程的重要性传递给了调度器。尽管CPU处理现有线程集的顺序是不确定的，但是调度器将倾向于让优先级最高的线程执行。优先级高低仅仅表示执行的频率高低
• yield（）：让步。给线程调度机制一个暗示：你的工作已经做得差不多了，可以让别的线程使用CPU了（仅暗示，不保证被采纳）
• 一个线程可以在其他线程之上调用join（）方法，其鲜果是等待一段时间直到第二个线程结束才继续执行，这里可以设定超时参数
• 所有对象都自动含有单一的锁（也称监视器），对于某个特定对象来说，其所有synchronized方法共享同一个锁，这可以被用来防止多个任务同时访问
• 同步规则：如果你正在写一个变量，它可能接下来将被另一个线程读取，或者正在读取一个上一次已经被另一个线程写过的变量，那么你必须使用同步，并且，读写线程必须用相同的监视器锁同步
• volatile关键字确保了应用中的可视性。如果你将一个域声明为volatile，那么只要对这个域产生了写操作，那么所有的读操作都可以看到这个修改。即使使用了本地缓存，情况也确实如此。volatile域会被立即写入主存
• 调用sleep的时候锁被没有被释放，调用yield也一样。另一方面，当一个任务在方法里遇到了wait的时候，线程执行会被挂起，锁也会被释放
• 使用notify而不是notifyAll是一种优化。使用notify时，在众多等待同一个锁的任务中只有一个会被唤醒
• 在解决任务互操作问题上，同步队列是比notify与notifyAll更高级的方式，通常可以使用LinkedBlockingQueue/ArrayBlockingQueue
• 死锁发生有四个必须的条件【注7】，破坏其中一个即可避免死锁

【注1】

【注2】

int x = 12;
{
    int y = 9;
    ...
}//y已经消失
{
    String s = new String("a");
    ...
}//虽然s消失了，但是s指向的对象仍然存在于内存中等待被回收

【注3】

【注4】

【注5】

public void e(){
    try{
        throw new Exception();
    }catch (Exception e){
        for(StackElement ste : e.getStackTrace()){
            Syste,.out.println(ste.getMethodName());
        }
    }
}

【注6】

Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(s);//Matcher对象可以通过m.reset（）重置

【注7】
死锁发生的四个条件：

• 互斥条件，即任务使用的志愿中至少有一个是不能共享的
• 至少有一个任务它必须持有一个资源且正在等待获取一个当前被憋的任务持有的资源
• 资源不能被任务抢占，任务必须把资源释放当作普通事件
• 必须有循环等待，这时，一个任务等待其他任务所持有的资源，后者又在等待另一个任务所持有的资源，这样一直下去直到有一个任务在等待第一个任务所持有的资源