• 在元字符前面加一个反斜杠 (backslash）\
  
• 用 \Q 和 \E包含起来，例如 \? == \Q?\E

• Pattern : 用来表示一个经过编译处理后的正则表达式。通俗一点来说，就是用一个类来表示一个正则表达式，这个类是从正则表达式构造得到的。这个类并没有public constructor, 如果想得到一个这个类的一个对象则必须调用该类的public static方法：public static Pattern compile(String regex)或者 public static Pattern compile(String regex,int flags)。这两个方法返回一个Pattern型的对象。
• Matcher : 解释Pattern并执行匹配、查找工作的类，跟Pattern类一样，这个类也没有定义public constructor，要想获得一个Matcher对象必须调用Pattern类的方法 public Matcher matcher(CharSequence input) 来得到。
• PatternSyntaxException : 一个unchecked exception。当遇到不符和Java正则表达式的语法的时候程序就会抛出这个异常。

• 继承类java.lang.Thread ，覆盖其中的方法 run(); 实例化该子类，例如：
  public class MyThread extends Thread 
  {
     public void run() 
    {
        // do some work
     }
  }
  // code to use MyThread
  new MyThread().start();
  
• 定义一个实现接口 java.lang.Runnable; 的类，实现该接口的方法run(); 然后将该类的一个实例作为实参传给Thread的构造方法。例如：
  public class MyThread2 implements Runnable 
  {
     public void run() 
    {
        // do some work
     }
  }
  
  // code to use MyThread2
  Thread t = new Thread(MyThread2);
  t.start();
  
• 无论用哪种方法最终得到的都是一个Thread的object，当调用方法start()时，系统将创建一个新的线程来执行run() 方法，这个新的线程将一直运行知道run方法退出。在新线程开始运行的同时，原来的线程也将继续执行start()之后的代码。

• NEW : 线程已经被创建，但是start()方法还没被调用，所有的线程都是从这个状态开始的
• RUNABLE : 该线程已经在JVM上执行了，但可能还在等待操作系统种的其他资源，也就是说要么现在就在运行，要么只要操作系统调度到该线程时立即就可以执行。
• BLOCKED ： 线程并没有运行因为它必须等待直到获得一个锁以便进入一个synchronized的方法或者块。
• WAITING : 线程并没有运行因为它已经调用了方法 Object.wait()或者 Thread.join( ).
• TIMED_WAITING ：线程并没有运行因为它已经调用了Thread.sleep()或者调用了使用timeout值的Object.wait()或者 Thread.join( ).
• TERMINATED : 线程已经完成执行任务，即run()方法要么正常退出，要么抛出一个异常。
  

ArithmeticOp.java
package valspe;

public enum ArthmeticOp
{
    ADD(1)
    {
        
        //You will never be able to refer to this method
        //outside this block
        public void onlyForAdd()
        {
            System.out.println("hey");
        }
        
        public void showOperator()
        {
            System.out.println("+");
        }
        
        public double compute(double x, double y)
        {
            return (x+y);
        }
    },
    MINUS(2)
    {
        public void showOperator()
        {
            System.out.println("-");
        }
        
        public double compute(double x, double y)
        {
            return (x-y);
        }
    },
    TIMES(3)
    {
        public void showOperator()
        {
            System.out.println("*");
        }
        
        public double compute(double x, double y)
        {
            return (x*y);
        }
    },
    DIVIDE(4)
    {
        public void showOperator()
        {
            System.out.println("/");
        }
        
        public double compute(double x, double y)
        {
            return (x/y);
        }
    };
    
    ArthmeticOp(int flag)
    {
        this.flag = flag;
    }
    
    public void showOperator()
    {
        System.out.println(flag);
    }
    
    //Define a abstract method.You must implement this method
    // in all the enumeration constants, or you will get a 
    // compiler-time error
    public abstract double compute(double x, double y);
    
    private int flag; // a useless field, just for demo
}

TestOperator.java
package valspe;

public class TestOpeator
{
    public static void main(String [] args)
    {
        ArthmeticOp add = ArthmeticOp.ADD;
        System.out.println(add.compute(1, 2));
        add.showOperator();
        ArthmeticOp times = ArthmeticOp.TIMES;
        times.showOperator();
    }
}

1. 定义每一个 value-specific class body （不知如何翻译~~)将会创建一个该枚举类型的匿名子类（anonymous subclass), 对应的枚举常量将会唯一的指向该子类。这里需要注意的是，尽管枚举类型不能被extends，但是它却可以拥有匿名子类，从这个意义上来说，枚举类型并不是一个严格的final类。
2. 匿名子类就预示着这些子类没有自己的constructor，你也不能在你的代码中引用一些匿名子类自己拥有的方法或域（见上面例子ADD中的justForAdd方法），这是因为每个枚举类型的枚举常量的枚举类型都是该枚举类型的。可能这句话我表述的不好。举个例子，设有类 A, B是A的子类，B有一个自己的方法 bMethod()。在代码中，我先new一个B的实例b，然后再declare一个A的变量a,并让a指向b(a = b)，这时，尽管a，b指向同一个对象，但你可以b.bMethod()却不能够a.bMethod()。
3. 枚举类型可以定义abstract方法，但你必须至少定义一个枚举常量来实现这些abstract方法，否则将会产生编译错误。
4. 由2可以看出，定义value-specific class body实际上就是实现枚举类型中的abstract方法或者override枚举类型种存在的方法。
   

• 跟类定义一样，枚举类型可以单独放在一个文件里，当一个枚举类型用public修饰时，它对其他包可见，否则只对同一个包中的类可见，这和类定义是一样的。
• 标识符 MONDAY, TUESDAY等就称为枚举常量（enumeration constants）
• 每一个枚举常量被隐式的声明成Day的一个public、static成员，而且其类型为Day，亦就是说这些常量是self-typed的
  

BasicMainClass.java
package  basic;

public   class  BasicMainClass
{
     public   static   void  main(String args[])
    {
        Day today  =  Day.SATURDAY;
        
        System.out.println( " Today is  "   +  today.toString().toLowerCase());
    }
}

OtherMainClass.java
package  other;
import  basic.Day;
public   class  OtherMainClass
{
     public   static   void  main(String [] args)
    {
        Day today  =  Day.SATURDAY;
        System.out.println( " Today is  "   +  today.toString().toLowerCase());
    }
}

• Enumerated types have no public constructor. The only instances of an enumerated type are those declared by the enum.

• Enums are not Cloneable, so copies of the existing instances cannot be created.

• Enums implement java.io.Serializable so they can be serialized, but the Java serialization mechanism handles them specially to ensure that no new instances are ever created.

• Instances of an enumerated type are immutable: each enum value retains its identity. (We'll see later in this chapter that you can add your own fields and methods to an enumerated type, which means that you can create enumerated values that have mutable portions. This is not recommended, but does not affect the basic identity of each value.)

• Instances of an enumerated type are stored in public static final fields of the type itself. Because these fields are final, they cannot be overwritten with inappropriate values: you can't assign the DownloadStatus.ERROR value to the DownloadStatus.DONE field, for example.

• By convention, the values of enumerated types are written using all capital letters, just as other static final fields are.

• Because there is a strictly limited set of distinct enumerated values, it is always safe to compare enum values using the = = operator instead of calling the equals() method.

• Enumerated types do have a working equals( ) method, however. The method uses = =finalso that it cannot be overridden. This working equals( ) method allows enumerated values to be used as members of collections such as Set, List, and Map. internally and is

• Enumerated types have a working hashCode() method consistent with their equals( )equals(), hashCode( ) is final. It allows enumerated values to be used with classes like java.util.HashMap. method. Like

• Enumerated types implement java.lang.Comparable, and the compareTo() method orders enumerated values in the order in which they appear in the enum declaration.

• Enumerated types include a working toString( ) method that returns the name of the enumerated value. For example, DownloadStatus.DONE.toString( ) returns the string "DONE" by default. This method is not final, and enum types can provide a custom implementation if they choose.

• Enumerated types provide a static valueOf( ) method that does the opposite of the default
  toString( ) method. For example, DownloadStatus.valueOf("DONE") would return DownloadStatus.DONE.

• Enumerated types define a final instance method namedordinal()that returns an integer for each enumerated value. The ordinal of an enumerated value represents its position (starting at zero) in the list of value names in the enum declaration. You do not typically need to use the ordinal( ) method, but it is used by a number of enum-related facilities, as described later in the chapter.

• Each enumerated type defines a static method named values( ) that returns an array of enumerated values of that type. This array contains the complete set of values, in the order they were declared, and is useful for iterating through the complete set of possible values. Because arrays are mutable, the values( ) method always returns a newly created and initialized array.

• Enumerated types are subclasses of java.lang.Enum, which is new in Java 5.0. (Enum is not itself an enumerated type.) You cannot produce an enumerated type by manually extending the Enum class, and it is a compilation error to attempt this. The only way to define an enumerated type is with the enum keyword.

• It is not possible to extend an enumerated type. Enumerated types are effectively final, but the final keyword is neither required nor permitted in their declarations. Because enums are effectively final, they may not be abstract.

• Like classes, enumerated types may implement one or more interfaces. 

ActionListener                  MouseMotionListener
AdjustmentListener              MouseWheelListener
FocusListener                   WindowListener
ItemListener                    WindowFocusListener
KeyListener                     WindowStateListener
MouseListener

常用的适配器类：
FocusAdapter                    MouseMotionAdapter
KeyAdapter                      WindowAdapter
MouseAdapter

类构造器的第一条语句。如果之类的构造器没有显示的调用超类的构造器，这将自动调用超类默认（没有参数）的构造器。如果超类没有不带参数的构造器，并且在子类的构造器中没有显示地调用超类的其它构造器，则Java编译器将报告错误，这个规则对与abstract base class 也是成立的。

2、关键字this有两个用途：一是引用隐式参数，二是调用该类的其它的构造器。在调用构造器时和super很相似，都只能作为另一个构造器的第一条语句出现。

3、多态。先看例子：

Manager boss = new Manager();
Employee [] staff = new Employee[3];
staff[0] = boss;

在这个例子中，变量staff[0]和boss引用同一个对象.但编译器将staff[0]看待成Employee对象.这意味着可以这样调用:
boss.setBonus(5000);
但不能这样调用
staff[0].setBonus(5000);//error，这样会引起一个编译错误
这是因为staff[0]声明的类型是Employee，而setBonus不是Empoyee类的方法。

4、动态绑定：

• 方法的名字和参数列表被称为方法的签名（signature).如果在子类中定义了一个与超类签名相同的方法，那么子类中的这个方法就覆盖了超类中的这个同签名的方法。但是，返回类型不是签名的一部分，因此在覆盖方法的时候，一定要保证返回类型的兼容性。在JDK 5.0以前的版本中，要求返回类型必须是一样的。而现在允许子类将覆盖方法返回类型定义为原返回类型的子类型。例如，假设Employee类有：
  public Employee getBuddy(){}
  在后面的子类Manager中，可以按照如下所示的方法覆盖这个方法：
  public Manager getBuddy(){} //OK in JDK 5.0
• 如果方法是private, static, final或者是构造器，那么编译器将可以准确地知道应该调用那个方法。我们将这种调用方式称为静态绑定。但是，子类不能继承父类private （方法,更谈不上覆盖）不能覆盖final修饰的方法，但可一覆盖static方法
• 覆盖一个方法的时候，子类方法不能低于超类方法的可见性。特别是如果超类得方法是public，那么子类方法一定要声明为public。
  

import java.*; util.Date date = new Date();来引用

（2）static imports: 从JDK 5.0开始，可以用static方法来import 某个类的静态方法和静态常量。例如：

ImportTest.java
 1 import java.util.*;
 2 import static java.lang.System.*;
 3 public class ImportTest
 4 {
 5     public static void main(String [] args)
 6     {
 7         Date date = new Date();
 8         out.println(date);
 9     }
10 }

static imports 的好处：例如：sqrt(pow(x, 2) + pow(y, 2))

TestBlock.java
 1 public class TestBlock
 2 {
 3     public static void main(String [] args)
 4     {
 5         int n;
 6         {
 7             int k;
 8         }//k 的作用域到此结束
 9     }
10 }

TestBlock.java
public class TestBlock
{
    public static void main(String [] args)
    {
        int n;
        {
            int k;
            int n;//n不能再这里声明
        }
    }
}

TestBlock.java
public class TestBlock
{
    public static void main(String [] args)
    {
        {
            int k;
            int n;
        }
        int n;
    }
}

• 内部类方法可以访问该类定义所在的作用域的数据，包括私有的数据
• 内部类可以对同一个包中的其它类隐藏起来
• 当想要定义一个回调函数且不想编写大量代码时使用匿名（anonymous)内部类比较便捷。（?)

• && || ! 的操作数只能用于boolean 或 Boolean
• &  | 的操作数既可以用于boolean(Boolean)或者整形(不仅仅是int型），但两个操作数的类型必须一致
• ~不能用于boolean(Boolean)型，但可以用于整形，大概是为了和 ! 区别开来吧
• & | 没有短路计算的
  

3、一个抽象类可以有数据域和非抽象方法（concrete data and concrete methods)。

4、当一个子类继承某个抽象类时，它可以有两个选择：
    (1)    部分实现或完全不实现父类的所有抽象方法，但此时子类必须声明为抽象类。
    (2)    实现父类所有的抽象方法，此时之类不比声明为抽象类。

5、抽象类不能被实例化（be instantiated)，但可以实例化非抽象子类（concrete subclass)。
   可以声明抽象类变量，但该变量必须指向一个非抽象子类.看下面一个例子：

   1.  Person [] people = new Person[2];    
   2. people[0] = new Employee();    
   3. people[1] = new Student();  
   4. for (Person p : people)  
   5.    System.out.println(p.getName() + "," + p.getDescription());  

6、摘自《Core Java 2》的一个例子：

PersonTest.java
/**
   @version 1.01 2004-02-21
   @author Cay Horstmann
*/

import java.text.*;
import java.util.*;

public class PersonTest
{  
   public static void main(String[] args)
   {  
      Person[] people = new Person[2];

      // fill the people array with Student and Employee objects
      people[0] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
      people[1] = new Student("Maria Morris", "computer science");

      // print out names and descriptions of all Person objects
      for (Person p : people)
         System.out.println(p.getName() + ", " + p.getDescription());
   }
}

abstract class Person
{  
   public Person(String n)
   {  
      name = n;
   }

   public abstract String getDescription();

   public String getName()
   {  
      return name;
   }

   private String name;
}

class Employee extends Person
{  
   public Employee(String n, double s,
      int year, int month, int day)
   {  
      super(n);
      salary = s;
      GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
      hireDay = calendar.getTime();
   }

   public double getSalary()
   {  
      return salary;
   }

   public Date getHireDay()
   {  
      return hireDay;
   }

   public String getDescription()
   {  
      return String.format("an employee with a salary of $%.2f", salary);
   }

   public void raiseSalary(double byPercent)
   {  
      double raise = salary * byPercent / 100;
      salary += raise;
   }

   private double salary;
   private Date hireDay;
}


class Student extends Person
{  
   /**
      @param n the student's name
      @param m the student's major
   */
   public Student(String n, String m)
   {  
      // pass n to superclass constructor
      super(n);
      major = m;
   }

   public String getDescription()
   {  
      return "a student majoring in " + major;
   }

   private String major;
}

参考资料：

Core Java 2 Volume I - Fundamentals, Seventh Edition

by Cay S. Horstman, Gary Cornell