Java

Java SE 版本变迁如表 1 所示。

Java EE 版本变迁如表 2 所示。Java EE API 如图 1 所示（以 Java EE 5 为例）。

Reference:
Java EE 版本变迁：http://en.wikipedia.org/wiki/Java_EE_version_history
Java EE at a Glance: http://www.oracle.com/technetwork/java/javaee/overview/index.html
Java EE 的各种实现：https://en.wikipedia.org/wiki/Java_Platform,_Enterprise_Edition#Certified_application_servers

// file FirstSample.java         // 文件名必须和类名一致
public class FirstSample {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

下面方法编译运行：

$ javac FirstSample.java    # 会生成FirstSample.class
$ java FirstSample
Hello World!

There are two kinds of types in the Java programming language: primitive types and reference types.

参考：
The Java Language Specification, Java SE 8 Edition, 4.1. The Kinds of Types and Values: https://docs.oracle.com/javase/specs/jls/se8/html/jls-4.html#jls-4.1

Java 是强类型语言，必须为每个变量声明一种类型。变量名是以字母开头的由字母或数字构成的序列。
声明一个局部变量后，必须用赋值语句对局部变量进行显式初始化。没有初始化就使用局部变量不能通过编译。如：

int i;
System.out.println(i);   // error: variable i might not have been initialized

说明：和 C/C++ 不同，Java 中不区分变量的声明与定义。

数组是一种数据结构，用来存储同一类型值的集合。
声明数组变量时，要指定数组类型（数据元素类型后紧跟[]）和数组变量的名字。如：

int[] a;                   // 也可以这样写 int a[]; 但Java程序员不喜欢这种风格。

上面语句只声明了数组变量 a，并没有将 a 初始化为一个真正的数组。应该使用 new 运算符创建数组。如：

int[] a = new int[100];    // 也可以这样写 int a[] = new int[100]; 但不推荐。

说明 1：如果没有显示初始化，创建数组时其元素会被设置为其对应类型的“默认值”：数值类型为 0，布尔值为 false，对象引用为 null。
说明 2：数组长度不要求是常量，如 new int[n] 会创建一个长度为 n 的数组。
说明 3：数组长度可以为 0，如 new int[0] 是合法的。在编写一个返回数组的方法时，如果碰巧结果为空，则这种语法形式显得非常有用。
说明 4：和 C/C++ 一样，数组起始元素的下标为 0。

Java 中的运算符与 C/C++ 中的基本相同。

为消除歧义，增加了 >>> 位运算符，它总是用 0 填充高位；而 >> 总是用符号位填充高位。没有 <<< 运算符。

Java 的控制流程结构和 C/C++ 的基本一样，只有很少的例外情况。如没有 goto 语句，但 break 语句可以带标号，利用标号可以实现从较深的内层循环跳出。

类是构造对象的模板或蓝图。由类构造对象的过程称为创建类的实例（instance）。
在 Java 中，类定义的基本形式为：

class ClassName {
    filed1
    filed2
    ...
    constructor1
    constructor2
    ...
    method1
    method2
    ...
}

下面看一个非常简单的 Employee 类：

class Employee {
    // instance fields
    private String name;
    private double salary;
    private Date hireDay;

    // constructor
    public Employee(String n, double s, int year, int month, int day) {
        name = n;
        salary = s;
        GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);  // GregorianCalendar uses 0 for January
        hireDay = calendar.getTime();
    }

    // a method
    public String getName() {
        return name;
    }

    // a method
    public double getSalary() {
        return salary;
    }

    // a method
    public Date getHireDay() {
        return hireDay;
    }

    // more methods ...
}

注意：和 C++ 不同， 在 Java 中，所有方法都必须在类的内部定义。

构造器与类同名，没有返回值。所有的 Java 对象都是在堆中构造的，构造器总是伴随着 new 操作符的执行被调用。

Employee staff = new Employee("James Bond", 100000, 1950, 1, 1);   // 构造器总是伴随着new操作符一起使用。
// Empoyee staff("James Bond", 100000, 1950, 1, 1);                // valid in C++, but invalid in Java

可以在类定义时，直接将一个值赋给某个域。如：

public class A {
    private int i = -1;
}

这个赋值操作会在执行构造器前先执行。 当一个类的所有构造器都希望把相同的值赋予某个域时，这种方式非常方便。

初始值不一定是常量，可以调用方法对域进行初始化。如：

public class A {
    private int i = fun1();
}

除了在构造器中设置域的值，和在类定义时初始化域的值。还可在初始化块（类定义时用大括号包围的部分）中设置。
有两种初始化块：普通初始化块和 static 初始化块。
普通初始化块在构造类的对象时会被执行，static 初始化块在类初始化时会被执行（即仅执行一次）。

public class Test {

    static int staticVariable;
    int nonStaticVariable;

    // Static initialization block:
    // Runs once (when the class is initialized).
    static {
        System.out.println("Static initalization.");
        staticVariable = 5;
    }

    // Instance initialization block:
    // Runs before the constructor each time you instantiate an object
    {
        System.out.println("Instance initialization.");
        nonStaticVariable = 7;
    }

    public Test() {
        System.out.println("Constructor.");
    }

    public static void main(String[] args) {
        new Test();
        new Test();
    }
}

上面代码会输出：

Static initalization.
Instance initialization.
Constructor.
Instance initialization.
Constructor.

参考：
http://stackoverflow.com/questions/3987428/what-is-an-initialization-block

Java 5 中引入了枚举类型。下面是一个典型的例子：

public enum Size { SMALL, MEDIUM, LARGE, EXTRA_LAGRE };

实际上，上面声明定义的类型是一个类，它刚好有 4 个实例。

下面是关于枚举类型的简单测试例子：

public class Test {
    public enum WeekDay {                     // 定义枚举类型，首字母大写（因为它是类）
        SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY  // 枚举实例可看作常量，一般用大写
    };

    public static void main(String[] args) {
        WeekDay today = WeekDay.SUNDAY;

        if (today == WeekDay.SUNDAY) {        // 用 == 可以测试枚举类型的相等性，也可以写为 WeekDay.SUNDAY.equals(today)
            System.out.println("today is Sunday");
        } else {
            System.out.println("today is not Sunday");
        }

        switch (today) {                      // switch case支持枚举类型
        case SUNDAY:                          // 无需（也不能）写为 case WeekDay.SUNDAY:
            System.out.println("today is Sunday");
            break;
        case SATURDAY:
            System.out.println("today is Saturday");
            break;
        default:
            break;
        }
    }
}

Java 中使用包来组织类。使用包的主要目的是确保类名的唯一性，减少冲突。
Sun 公司建议将公司的因特网域名以逆序的形式作为包名。
注意：从编译器角度来看，嵌套的包之间没有任何关系。如，java.util 包与 java.util.jar 包没有任何关系，每一个包都拥有独立的类集合。

如果没有指定 public 或 private，这个部分（类、方法或变量）可以被同一个包内所有的方法访问，这就是包作用域，又称为默认作用域。

Java 中的修饰符总结如表 5 和表 6 所示。

参考：
http://docstore.mik.ua/orelly/java-ent/jnut/ch03_14.htm
http://www.javacamp.org/javaI/modifier.html

Java 中的类都继承于 java.lang.Object ，这个类有一些内置方法，如 toString, wait, notify, hashCode, equals 等等，这里重点讲一下 hashCode 和 equals 方法。

Java 中用关键字 extends 表示继承，且所有继承都是公有继承。
备注：C++ 中用冒号（:）表示继承，除公有继承外，还有私有继承和保护继承。

// file Manager.java
public class Manager extends Employee {
  private double bonus;

  public Manager(String n, double s, int year, int month, int day) {
    super(n, s, year, month, day);              // 可用super调用超类的构造器
    bonus = 0;
  }

  public void setBonus(double b) { bonus = b; }

  public double getSalary () {
    double baseSalary = super.getSalary();       // super不能省略，否则会有自己调用自己的死循环
    return baseSalary + bonus;
  }
}

用下面类来测试 Manager：

// file ManagerTest.java
public class ManagerTest {
  public static void main(String[] args) {
    Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
    boss.setBonus(5000);

    Employee[] staff = new Employee[3];
    staff[0] = boss;
    staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
    staff[2] = new Employee("Tommy Tester", 40000, 1990, 3, 15);

    for (Employee e: staff) {
      System.out.println(e.getName() + " " + e.getSalary());     //e.getSalary()会进行动态绑定
    }
  }
}
/* 程序会输出：
Carl Cracker 85000.0
Harry Hacker 50000.0
Tommy Tester 40000.0
*/

要想一个类不能被继承，可以将它设置为 final。Java 中的 String 类就是 final 类。也可以只将类中的某个（些）方法声明为 final，这样，子类中不能覆盖这个（些）方法。

注：final 也可以修饰域。对于 final 域，构造对象之后就不允许改变它的值。

abstract class Person {                      // 抽象类
    public abstract String getDescription(); // 抽象方法（有声明，但无实现）。往往在子类中实现
}

抽象类不能被实例化。

Java 中，含有抽象方法的类必须标记为抽象类。但一个类不含抽象方法，也可以将它标记为抽象类。

扩展抽象类可以有两种选择。一种是在子类中定义部分抽象方法或不定义抽象方法，这样就必须将子类也标记为抽象类；另一种是定义全部的抽象方法，这样子类就不是抽象的了。

备注：C++ 中包含有纯虚函数的类为抽象类。

接口用关键字 interface 定义。接口中的方法都为 public，且可以省略 public 关键字（实践中往往省略它们，使代码看起来更简洁）。

public interface Moveable {
    void move(double x, double y);  // 也可写为：public void move(double x, double y);
                                    // 也可写为：public abstract void move(double x, double y);
}

接口中的方法不能直接在接口中实现（可认为它们都是 abstract 方法）。
如，下面接口的定义不能编译成功：

public interface Moveable {
    // ERROR !
    void move(double x, double y) { return; };   // 编译出错，方法不能在接口中实现。
}

注意：接口中的 default Methods 和 static Methods 可以直接在接口中实现，后文将介绍。

用关键字 implements 可以实现一个接口。如果类实现某个接口，则必须实现这个接口里的所有方法，否则编译器会报错。

如：

// file Animal.java
interface Animal {
    void eat();
    void travel();
}

类 MammalInt 实现上面定义的接口 Animal：

/* File name : MammalInt.java */
public class MammalInt implements Animal{

    public void eat() {
        System.out.println("Mammal eats");
    }

    public void travel() {
        System.out.println("Mammal travels");
    }

    public static void main(String args[]) {
        Animal m = new MammalInt();
        m.eat();
        m.travel();
    }
}

我们知道每个类只能拥有一个直接超类，但却可以可以实现多个接口。使用逗号将实现的各个接口名分隔开即可。如：

class Employee implements Cloneable, Comparable {
    // somethings.
}

参考：http://www.tutorialspoint.com/java/java_interfaces.htm

使用关键字 extends，接口可以继承一个或多个接口。如：

// file A.java
public interface A {
    void methodA();
}
// file B.java
public interface B {
    void methodB();
}
// file C.java
public interface C extends A, B {
    void methodC();
}

参考：https://docs.oracle.com/javase/tutorial/java/IandI/nogrow.html

接口不能被实例化，和抽象类相似。
和抽象类相比，使用接口的好处在于一个类可以实现多个接口，而一个类只能继承一个抽象类。

和 static 方法类似，static 嵌套类关联外围类，而不是外围类的对象实例，所以 static 嵌套类无法访问外围类的对象实例。

当嵌套类不需要访问外围类对象的时候，应该使用 static 嵌套类。

Static 嵌套类可使用下面方式进行实例化：

OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();

内部类可以访问实例化它的外围类的对象。

class Outer_Demo {
  //private variable of the outer class
  private int num = 175;

  //inner class
  public class Inner_Demo{
    public int getNum(){
      System.out.println("This is the getnum method of the inner class");
      return num;   // 内部类可以访问外围类的成员num
    }
  }
}

public class My_class2{
  public static void main(String args[]){
    Outer_Demo outer=new Outer_Demo();                   //实例化外围类
    Outer_Demo.Inner_Demo inner=outer.new Inner_Demo();  //实例化内部类
    System.out.println(inner.getNum());
  }
}

上面程序运行，将输出：

This is the getnum method of the inner class
175

参考：
http://www.tutorialspoint.com/java/java_innerclasses.htm
https://docs.oracle.com/javase/tutorial/java/javaOO/innerclasses.html

Java 8 中引入了 Lambda Expressions，详情可参考：https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Lambda Expressions 的基本语法为：

(parameters) -> expression
(parameters) -> { statements; }  // 多个参数之间用逗号分开

parameters -> expression         // 如果只有一个参数，则参数外层括号可省略
parameter -> { statements; }     // 如果只有一个参数，则参数外层括号可省略

下面是 Lambda Expressions 的例子：

interface LambdaFunction {  // It's a functional interface because it contains only one abstract method. A functional interface can define as many default and static methods as it requires.
    void call();
}

class LambdaTest {          // 下面是Lambda Expression的例子
    public static void main(String []args) {
        LambdaFunction lambdaFunction = () -> System.out.println("Hello world");
        lambdaFunction.call();
    }
}

下面是使用 Lambda Expression 或 Method Reference（后方将介绍）遍历 List 的例子：

String[] array = {"Jack", "Tom", "Jones"};
List<String> players =  Arrays.asList(array);

// Java 8以前的风格
for (String player : players) {
     System.out.println(player);
}

// Java 8风格（使用lambda expression）
players.forEach((String item) -> System.out.println(item));
players.forEach((item) -> System.out.println(item));        // 参数类型可省，同上
players.forEach(item -> System.out.println(item));          // 单参数外层括号可省，同上

// Java 8风格（使用method reference）
players.forEach(System.out::println);

An exception is represented by an instance of the class Throwable (a direct subclass of Object) or one of its subclasses.

参考：The Java® Language Specification, Java SE 8 Edition, 11.1.1. The Kinds of Exceptions

Java 中异常类的层次如下所示：

              +-------------+
              |  Throwable  |
              +-------------+
              /             \
             /               \
            /                 \
     +--------+             +------------+
     | Error  |             | Exception  |
     +--------+             +------------+
       / | \                 /    |     \
     \________/           \________/     \
      unchecked           checked         \
                                       +-------------------+
                                       | RuntimeException  |
                                       +-------------------+
                                           /     |     \
                                       \___________________/
                                             unchecked

所有异常都是由 Throwable 继承而来，下一层分为两个分支：Error 和 Exception。

• Error 类层次结构描述了 Java 运行时系统的内部错误和资源耗尽错误。 应用程序不应该抛出这种类型的对象。 如果出现了这样的内部错误，除了安全地终止程序外，再也无能为力了。这种情况很少出现。
  
• Exception 类分解为两个分支：一个是 RuntimeException，另一个是除 RuntimeException 外的其它异常（如 I/O 错误 FileNotFoundException 等）。派生于 RuntimeException 的异常的例子有：错误的类型转换、数组访问越界(IndexOutOfBoundsException)、访问空指针(NullPointerException)等。
  

参考：
这里有一个完整的异常层次列表：https://www.cs.colorado.edu/~main/javasupp/throwable.html

如果方法中存在没有异常处理器的 checked 异常（如 IOException），你必须在方法首部用 throws 关键字声明这个 checked 异常，以表明“期望它的调用者处理它”。

public void writeList() throws IOException {
    // 下一行可能 throw IOException (checked exception)
    PrintWriter out = new PrintWriter(new FileWriter("OutFile.txt"));
    for (int i = 0; i < SIZE; i++) {
        // 下一行可能 throw IndexOutOfBoundsException (unchecked exception)
        out.println("Value at: " + i + " = " + list.get(i));
    }
    out.close();
}

说明：你可以在方法首部用 throws 关键字声明没有异常处理器的 unchecked 异常（如 IndexOutOfBoundsException），如：

// 上面函数 writeList 也可以声明为下面形式，但不推荐这么做！
public void writeList() throws IOException, IndexOutOfBoundsException {
    ......
}

但不推荐这么做。因为 unchecked 异常（如 IndexOutOfBoundsException）完全在我们的控制之下，如果你特别关心 IndexOutOfBoundsException 这样的错误，你应该花时间在程序中修正它，而不是声明这个错误会发生。

参考：https://docs.oracle.com/javase/tutorial/essential/exceptions/declaring.html

用 throw 关键字可以抛出异常，如：

public Object pop() {
    Object obj;

    if (size == 0) {
        throw new EmptyStackException();  // unchecked exception
    }

    obj = objectAt(size - 1);
    setObjectAt(size - 1, null);
    size--;
    return obj;
}

参考：https://docs.oracle.com/javase/tutorial/essential/exceptions/throwing.html

如果某个异常发生的时候没有在任何地方进行捕获，那么程序会终止执行。

要捕获一个异常，必须使用 try/catch 语句块。基本格式如下：

try {
    code
} catch (ExceptionType1 name) {
    handler for this type
} catch (ExceptionType2 name) {
    handler for this type
}

如果在 try 语句块中的任何代码抛出了一个在 catch 子句中说明的异常类，那么(1)程序将跳过 try 语句块的其余代码；(2)程序将执行 catch 子句中的处理器代码。
如果在 try 语句块中的代码没有抛出任何异常，那么程序将跳过 catch 子句。
如果方法中的任何代码抛出了一个在 catch 子句中没有声明的异常类型，那么这个方法就会立刻退出（期待调用者为这种类型的异常设计了 catch 子句）。

说明：从 Java 7 开始，可以一次捕获多个异常。如下面代码：

catch (IOException ex) {
     logger.log(ex);
     throw ex;
} catch (SQLException ex) {
     logger.log(ex);
     throw ex;
}

在 Java 7 中可以写为：

catch (IOException | SQLException ex) {
    logger.log(ex);
    throw ex;
}

在程序中，很可能会遇到任何标准异常类都没有能够充分地描述清楚的问题。在这种情况下，创建自己的异常类就是一件顺理成章的事情了。创建异常类很简单，只需要定义一个派生于 Exception（或者 Exception 的子类）的类。

习惯上，定义的类应该至少包含两个构造器，一个默认构造器；另一个是带有详细描述信息的构造器（超类 Throwable 的 toString 方法将会打印出这些详细信息）。

// 自定义异常类的例子：
class FileFormatException extends IOException {
    public FileFormatException() {
        super();
    }

    public FileFormatException(String msg) {
        super(msg);
    }
}

The try-with-resources statement is a try statement that declares one or more resources. A resource is an object that must be closed after the program is finished with it. The try-with-resources statement ensures that each resource is closed at the end of the statement. Any object that implements java.lang.AutoCloseable, which includes all objects which implement java.io.Closeable, can be used as a resource.

try-with-resources 是在 Java 7 中新增加的。使用实例：

static String readFirstLineFromFile(String path) throws IOException {
    try (BufferedReader br = new BufferedReader(new FileReader(path))) {
        return br.readLine();
    }
}

在 Java 7 之前，和上面代码功能相同的代码为：

static String readFirstLineFromFileWithFinallyBlock(String path)
                                                     throws IOException {
    BufferedReader br = new BufferedReader(new FileReader(path));
    try {
        return br.readLine();
    } finally {
        if (br != null) br.close();
    }
}

泛型类是指具有一个或多个“类型参数”的类。“类型参数”用尖括号括起来，放在类名的后面。

下面是一个泛型类的例子。T为类型参数。

public class Pair<T>                         // 泛型类
{
    private T first;
    private T second;
    public Pair() { first = null; second = null; }
    public Pair(T first, T second) { this.first = first; this.second = second; }
    public T getFirst() { return first; }      // 泛型方法
    public T getSecond() { return second; }
    public void setFirst(T newValue) { first = newValue; }
    public void setSecond(T newValue) { second = newValue; }
}

用具体的类型替换类型参数就可以实例化泛型类型。如：

Pair<String>                // 实例化泛型类型

接口也可以使用泛型的。如：

public interface List <E> {
    void add(E x);
    Iterator<E> iterator();
}

public interface Iterator<E> {
    E next();
    boolean hasNext();
}

可以定义一个带有“类型参数”的方法，称为泛型方法。
如：

class ArrayAlg
{
  public static <T> T getMiddle(T... a)    // 泛型方法（定义在普通类中）
  {
    return a[a.length/2];
  }
}

普通类中定义的泛型方法在其返回类型前面有尖括号和类型参数（注：泛型类中定义的泛型方法其返回类型前面不需要尖括号和类型参数）。

当调用一个泛型方法时，在方法名前加上尖括号，并放入具体的类型。如：

String middle = ArrayAlg.<String>getMiddle("ABC", "XYZ", "IJK");    // 调用泛型方法。方法名前的尖括号中放入具体的类型。
String middle = ArrayAlg.getMiddle("ABC", "XYZ", "IJK");            // 同上。不产生歧义时，泛型方法名前的<String>可以省略。

说明：Java 中为什么不像 C++ 那样将类型参数放在方法名后面呢？这是因为 C++ 的作法可能会导致语法分析的歧义。例如，g(f<a, b>(c))可能理解为“用 f<a, b>(c)的结果调用 g”，或者理解为“用两个布尔值 f<a 和 b>(c)调用 g”。

有时，想要对类或方法的“类型参数”加以约束。请看下面例子。

class ArrayAlg
{
    public static <T> T min(T[] a)     // almost correct
    {
        if (a == null || a.length == 0) return null;
        T smallest = a[0];
        for (int i = 1; i < a.length; i++)
            if (smallest.compareTo(a[i]) > 0) smallest = a[i];
        return smallest;
    }
}

上面例子中，变量 smallest 的类型为 T，它可以是任何一个类的对象。那怎么确保 T 所属的类一定有 compareTo 方法呢？
解决这个问题的方法是将 T 限制为实现了 Comparable 接口的类。可以通过对类型参数 T 设置相应的限定来实现。如：

public static <T extends Comparable> T min(T[] a)  {...}

现在，泛型方法 min 只能被实现了 Comparable 接口的类（如 String,Date 等）的数组调用。

说明：Comparable 是一个接口，为什么在这里使用关键字 extends，而不是 implements 呢？下面符号：

<T extends BoundingType>

表示 T 应该是 BoundingType 的子类型。T和 BoudingType 可以是类，也可以是接口。选择关键字 extends 的原因是它更接近子类的概念。

A wildcard describes a family of types.

There are 3 different flavors of wildcards:
(1) "?" - the unbounded wildcard. It stands for the family of all types.
(2) "? extends Type" - a wildcard with an upper bound. It stands for the family of all types that are subtypes of Type , type Type being included.
(3) "? super Type" - a wildcard with a lower bound. It stands for the family of all types that are supertypes of Type , type Type being included.

参考：http://www.angelikalanger.com/GenericsFAQ/FAQSections/TypeArguments.html#FAQ101

Java 泛型的实现采取了“伪泛型”的策略，即 Java 在语法上支持泛型，但是在编译阶段会进行所谓的“类型擦除”（Type Erasure），将所有的泛型表示（尖括号中的内容）都替换为具体的类型（其对应的原生态类型），就像完全没有泛型一样。

参考：https://docs.oracle.com/javase/tutorial/java/generics/erasure.html

参考：http://java-performance.info/java-collections-overview/

在 Java 中，可以从中读入字节序列的对象称为“输入流（可用 read 方法操作）”；可以向其中写入字节序列的对象称为“输出流（可用 write 方法操作）”。

由于面向字节的流不便于处理 Unicode 字符。Java 单独实现了一套处理 Unicode 字符流的 API。

Java 中有两套 I/O 相关 API，一套是面向字节的，另一套面向 Unicode 字符的（需要用户指定编码，若不指定则采用默认编码）。 默认编码可以这样得到 System.getProperty("file.encoding")。Linux 下测试时得到的默认编码是 UTF-8。

面向字节的 API 的基类为 InputStream 和 OutputStream。
面向 Unicode 字符的 API 的基类为 Reader 和 Writer。

参考：《Java 与模式，第 27 章 设计模式在 Java I/O 库中的应用》

Java I/O 中主要应用的装饰者模式和适配器模式，其中 装饰者模式（Decorator Pattern）是 Java I/O 所使用的基本模式。

例如：BufferedInputStream 中有个 readline 方法。PushbackInputStream 中有 unread 方法。BufferedInputStream 和 PushbackInputStream 都扩展了 InputStream 的功能，是它的不同装饰者。

下面简单介绍一下装饰者模式。

适用性（以下情况适用 Decorator 模式）

1. 需要扩展一个类的功能，或给一个类添加附加职责。
   
2. 需要动态的给一个对象添加功能，这些功能可以再动态的撤销。
   
3. 需要增加由一些基本功能的排列组合而产生的非常大量的功能，从而使继承关系变的不现实。
   
4. 当不能采用生成子类的方法进行扩充时。一种情况是，可能有大量独立的扩展，为支持每一种组合将产生大量的子类，使得子类数目呈爆炸性增长。另一种情况可能是因为类定义被隐藏，或类定义不能用于生成子类。
   

优点

1. Decorator 模式与继承关系的目的都是要扩展对象的功能，但是 Decorator 可以提供比继承更多的灵活性。
   
2. 通过使用不同的具体装饰类以及这些装饰类的排列组合，设计师可以创造出很多不同行为的组合。
   

缺点

1. 这种比继承更加灵活机动的特性，也同时意味着更加多的复杂性。
   
2. 装饰模式会导致设计中出现许多小类，如果过度使用，会使程序变得很复杂。
   
3. 装饰模式是针对抽象组件（Component）类型编程。但是，如果你要针对具体组件编程时，就应该重新思考你的应用架构，以及装饰者是否合适。当然也可以改变 Component 接口，增加新的公开的行为，实现“半透明”的装饰者模式。在实际项目中要做出最佳选择。
   

Java NIO(New Input/Output)——新的输入/输出 API 包——是 2002 年引入到 J2SE 1.4 里的。Java NIO 的目标是提高 Java 平台上的 I/O 密集型任务的性能。过了十年，很多 Java 开发者还是不知道怎么充分利用 NIO，更少的人知道在 Java SE 7 里引入了更新的输入/输出 API（NIO.2）。

参考：5种调优Java NIO和NIO.2的方式

参考：Java 核心技术(原书第 8 版)卷 II：高级特性，第 1.2.1 和 1.2.2 节

OpenJDK 中内置了很多实用的小工具，如调试器 jdb ，java 进程查看程序 jps 等等。

/usr/lib/jvm/java-7-openjdk-amd64/bin/jcmd
/usr/lib/jvm/java-7-openjdk-amd64/bin/xjc
/usr/lib/jvm/java-7-openjdk-amd64/bin/javap
/usr/lib/jvm/java-7-openjdk-amd64/bin/jrunscript
/usr/lib/jvm/java-7-openjdk-amd64/bin/jdb
/usr/lib/jvm/java-7-openjdk-amd64/bin/jsadebugd
/usr/lib/jvm/java-7-openjdk-amd64/bin/jmap
/usr/lib/jvm/java-7-openjdk-amd64/bin/jhat
/usr/lib/jvm/java-7-openjdk-amd64/bin/jconsole
/usr/lib/jvm/java-7-openjdk-amd64/bin/jstat
/usr/lib/jvm/java-7-openjdk-amd64/bin/wsgen
/usr/lib/jvm/java-7-openjdk-amd64/bin/javah
/usr/lib/jvm/java-7-openjdk-amd64/bin/jinfo
/usr/lib/jvm/java-7-openjdk-amd64/bin/jstatd
/usr/lib/jvm/java-7-openjdk-amd64/bin/native2ascii
/usr/lib/jvm/java-7-openjdk-amd64/bin/javadoc
/usr/lib/jvm/java-7-openjdk-amd64/bin/rmic
/usr/lib/jvm/java-7-openjdk-amd64/bin/javac
/usr/lib/jvm/java-7-openjdk-amd64/bin/schemagen
/usr/lib/jvm/java-7-openjdk-amd64/bin/jarsigner
/usr/lib/jvm/java-7-openjdk-amd64/bin/idlj
/usr/lib/jvm/java-7-openjdk-amd64/bin/jps
/usr/lib/jvm/java-7-openjdk-amd64/bin/jstack
/usr/lib/jvm/java-7-openjdk-amd64/bin/extcheck
/usr/lib/jvm/java-7-openjdk-amd64/bin/serialver
/usr/lib/jvm/java-7-openjdk-amd64/bin/appletviewer
/usr/lib/jvm/java-7-openjdk-amd64/bin/wsimport
/usr/lib/jvm/java-7-openjdk-amd64/bin/jar

参考：
JDK 内置工具使用：http://blog.csdn.net/fenglibing/article/details/6411999

C/C++ 中，程序名存储在 args 数组中。而 Java 中，程序名并没有存储在 args 数组中。

public class Testargs {
    public static void main(String[] args) {
        for (String s: args) {
            System.out.println(s);
        }
    }
}

测试如下：

$ javac Testargs.java
$ java Testargs arg1 arg2
arg1
arg2

可知，程序名并没有存储在 args 数组中，java 或 Testargs 并不会被输出。

A JavaBean is just a standard:

1. All properties private (use getters/setters)
   
2. A public no-argument constructor
   
3. Implements Serializable.
   

That's it. It's just a convention.

参考：
http://stackoverflow.com/questions/3295496/what-is-a-javabean-exactly
http://www.tutorialspoint.com/jsp/jsp_java_beans.htm

强引用：它是 Java 中默认的引用类型，即使用 A obj=new A(); 这种用法得到的引用。当内存不够用时，JVM 宁愿抛出 OutOfMemoryError，也不会将强引用对象进行回收。

软引用（可方便实现 cache）： 软引用不会保证对象一定不会被回收，只能最大可能保证。 如果内存有剩余，那么软引用对象不会被回收，如果内存不足，那么 gc 会回收软引用对象。这种特性可以用来实现缓存技术。

import java.lang.ref.SoftReference;

public class SoftTest{
    public static void main(String[] args) {
        Object ref = new Object();           //ref是Object对象的强引用

        //将一个软引用指向对象，此时Object对象有两个引用
        SoftReference<Object> sf = new SoftReference<Object>(ref);

        ref = null;        //去除对象的强引用
        System.gc();       //gc只有在内存不足是才会回收软引用对象
    }
}

弱引用： 和软引用不同的是，gc 一旦发现弱引用就一定会回收它，不管内存是否充足。
不过，需要注意的是，gc 可能要运行多次才能找到弱引用对象。

弱引用也可以用来实现 cache，它适应于重建 cache 的代价很小的场景，我们一旦发现对象被回收，马上重建它即可。

import java.lang.ref.WeakReference;

public class WeakTest {
    public static void main(String[] args) throws InterruptedException {
        MyObj ref = new MyObj(); // ref是Object对象的强引用

        // 将一个弱引用指向对象，此时Object对象有两个引用
        WeakReference<MyObj> wf = new WeakReference<MyObj>(ref);

        System.out.println(wf.get());   // 输出MyObj@6d06d69c或其它类似值

        ref = null;  // 去除对象的强引用
        System.gc(); // 运行gc，发现弱引用对象，就会进行回收

        System.out.println(wf.get());    // 输出null
    }
}

class MyObj{ }

虚引用（又称幽灵引用，PhantomReference）：虚引用主要用来跟踪对象被垃圾回收的活动，比如 Netty 中 ResourceLeakDetector 的实现就使用了虚引用。

参考：
http://blog.csdn.net/mxbhxx/article/details/9111711
http://paddy-w.iteye.com/blog/986796
http://stackoverflow.com/questions/299659/what-is-the-difference-between-a-soft-reference-and-a-weak-reference-in-java
https://community.oracle.com/blogs/enicholas/2006/05/04/understanding-weak-references

A stream is a sequence of elements supporting sequential and parallel aggregate operations.

Using stream, you can process data in a declarative way similar to SQL statements. For example, consider the following SQL statement:

SELECT max(salary), employee_id, employee_name FROM Employee

The above SQL expression automatically returns the maximum salaried employee's details, without doing any computation on the developer's end. Using collections framework in Java, a developer has to use loops and make repeated checks. Another concern is efficiency; as multi-core processors are available at ease, a Java developer has to write parallel code processing that can be pretty error-prone.
To resolve such issues, Java 8 introduced the concept of stream that lets the developer to process data declaratively and leverage multicore architecture without the need to write any specific code for it.

Stream 还带来了编程风格的改变，更像函数式编程风格了。

double[] data = {7, 6, 8, 4, 2, 7, 6, 7, 6, 5};
double total1 = Arrays.stream(data).reduce(0, Double::sum);   // 求和
double total2 = Arrays.stream(data).sum();                    // 和上相同

double total3 = Arrays.stream(data).parallel().reduce(0, Double::sum);   // 求和（数据量非常大时可能更快）
double total4 = Arrays.stream(data).parallel().sum();                    // 和上相同

又如：

List<String> myList =
        Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList.stream()
    .filter(s -> s.startsWith("c"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);

    // 输出：
    // C1
    // C2

参考：
https://www.tutorialspoint.com/java8/java8_streams.htm
https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

下面通过一个对比例子来说明使用 Optional 类可以不用检测 null 值也不会出现 NullPointerException：

摘自：Java 8 Optional In Depth

In C++, an object can contain object directly as fields, whereas in Java objects can only hold references to those objects. That is, in C++, if you declare an object that has a string as a member, the storage space for that string is built directly into the space for the object itself, while in Java you just get space for a reference to some other String object stored elsewhere.

如下，类 A 的对象不会直接包含一个 String 类型的 s，B 类型的 b，数组类型的 arr，在类 A 的对象中仅会包含他们的引用（这和 C++ 很不同）。

public class A {
    private String s;   // 引用类型
    private B b;        // 引用类型
    int[] arr;          // 引用类型
}

在 Java 中，除基本类型外，其它都是引用类型。

Java 中创建对象的四种方式：
(1) 用 new 语句创建对象，这是最常见的创建对象的方法。
(2) 运用反射手段,调用 java.lang.Class 或者 java.lang.reflect.Constructor 类的 newInstance()实例方法。（Class 中的 newInstance()方法在初始化对象时使用的是没有参数的默认构造器，如果类没有默认构造器就会抛出异常；而 Constructor 类的 newInstance()方法更加强大，可以接受构造器的参数。）
(3) 调用对象的 clone()方法。
(4) 运用反序列化手段，调用 java.io.ObjectInputStream 对象的 readObject()方法。

参考：
Java 创建对象的四种方法：http://www.2cto.com/kf/201301/186080.html