1、java多線程資料：
http://ifeve.com/java-concurrency-thread-directory/
2、enum 類，單例模式
必須提供一個私有得構造函數，並且提供一個無任何修飾符的構造函數： adapterGateeay();private Gateway() {}
3、繼承類初始化順序（構造器也是static方法，儘管static關鍵字沒有顯示地寫出來。因此更確切地講，類是在其任何static成員被訪問時加載的）
1）調用類的static的方法是，首先加載static 的成員，從父類到子類一次類推
2）創建類的對象時，首先加載父類：先是普通成員變量，然後是構造方法；接着是子類：先是普通成員變量，然後是構造方法
例子如下：
package chapter07;
import staticutil.Print.*;
class Insect {
privateint i=9;
privateint m = printInit("Insect.m initialized");
protectedint j;
Insect(){
print("i="+ i + ", j=" + j);
j=39;
}
privatestatic int x1 = printInit("static Insect.x1 initialized");
staticint printInit(String s){
print(s);
return47;
}
}
public class Bettleextends Insect {
privateint k = printInit("Bettle.k initialized");
publicBettle(){
print("k="+ k);
print("j="+ j);
}
privatestatic int x2 = printInit("static Bettle.x2 initialized");
publicstatic void main(String[] args){
print("Bettleconstructor");
Bettleb = new Bettle();
}
}
static Insect.x1initialized
static Bettle.x2initialized
Bettle constructor
Insect.m initialized
i=9, j=0
Bettle.k initialized
k=47
j=39
4、訪問修飾符範圍public>protected>默認(fridenly)>private
1）public 所有的類都能訪問
2）protected 同一個包內可以訪問，繼承的子類可以訪問
3）默認不加修飾符，只是包內訪問權限
4）private 只在本類中可以訪問
5、static關鍵字的作用
1）修飾變量：只類加載時被初始化，屬於類級別的範圍，所有對象共享此變量，切值加載一次
2：修飾方法：不需要創建對象即可訪問的方法
6、final關鍵字的作用
1）修飾變量：說明該對象的變量在初始化後不能再改變，不同對象可以有不同的值；如果是引用類型只引用的地址不可變
2）修飾方法：說明該方法不能被繼承，private修飾的方法默認是final的
3）修飾類：說明該類不能被繼承，由於不能被繼承隱式指定final的所有方法爲final的
7、動態綁定
1）java中除static方法和final方法（private方法屬於final方法）之外，其他所有方法都是動態綁定
2）變量是在編譯時確定的
classSuper {
public int field = 0;
public int getField() { return field; }
}
classSub extends Super {
public int field = 1;
public int getField() { return field; }
public int getSuperField() { returnsuper.field; }
}
publicclass FieldAccess {
public static void main(String[] args) {
Super sup = new Sub(); // Upcast
System.out.println("sup.field = "+ sup.field +
", sup.getField() = " +sup.getField());
Sub sub = new Sub();
System.out.println("sub.field = "+
sub.field + ", sub.getField() =" +
sub.getField() +
", sub.getSuperField() = " +
sub.getSuperField());
}
}/* Output:
sup.field= 0, sup.getField() = 1
sub.field= 1, sub.getField() = 1, sub.getSuperField() = 0
*///:~
//:polymorphism/StaticPolymorphism.java
//Static methods are not polymorphic.
classStaticSuper {
public static String staticGet() {
return "Base staticGet()";
}
public String dynamicGet() {
return "Base dynamicGet()";
}
}
classStaticSub extends StaticSuper {
public static String staticGet() {
return "Derived staticGet()";
}
public String dynamicGet() {
return "Derived dynamicGet()";
}
}
publicclass StaticPolymorphism {
public static void main(String[] args) {
StaticSuper sup = new StaticSub(); //Upcast
System.out.println(sup.staticGet());
System.out.println(sup.dynamicGet());
}
}/* Output:
BasestaticGet()
DeriveddynamicGet()
*///:~
8、抽象類
1）關鍵字abstract，在抽象類中可以包含一個或多個抽象方法，也可以不包含抽想方法
2）抽象類不可以創建具體對象，只能創建子類對象
9、接口（interface）
1）所有變量都隱含是static和final的
2）所有方法都隱含是public abstract的，即使不寫
10、內部類
1）內部類可以訪問外部類的所有成員方法
2）創建內部類之前必須創建外部類對象，通過外部類對象創建內部類：.new
publicclass DotNew {
public class Inner {}
public static void main(String[] args) {
DotNew dn = new DotNew();
DotNew.Inner dni = dn.new Inner();
}
}///:~
3）內部類返回外部類對象用.this
publicclass DotThis {
void f() {System.out.println("DotThis.f()"); }
public class Inner {
public DotThis outer() {
return DotThis.this;
// A plain "this" would beInner's "this"
}
}
public Inner inner() { return new Inner(); }
public static void main(String[] args) {
DotThis dt = new DotThis();
DotThis.Inner dti = dt.inner();
dti.outer().f();
}
}/* Output:
DotThis.f()
*///:~
4）匿名內部類，調用用參數的構造器，public class Parcel8 {
public Wrapping wrapping(int x) {
// Base constructor call:
return new Wrapping(x) { // Passconstructor argument.
public int value() {
return super.value() * 47;
}
}; // Semicolon required
}
public static void main(String[] args) {
Parcel8 p = new Parcel8();
Wrapping w = p.wrapping(10);
}
}///:~
publicclass Wrapping {
private int i;
public Wrapping(int x) { i = x; }
public int value() { return i; }
}///:~
使用外部定義的對象例子，需要final修飾參數
publicinterface Destination {
String readLabel();
}///:~
publicclass Parcel9 {
// Argument must be final to use inside
// anonymous inner class:
public Destination destination(final String dest) {
return new Destination() {
private String label = dest;
public String readLabel() { return label;}
};
}
public static void main(String[] args) {
Parcel9 p = new Parcel9();
Destination d =p.destination("Tasmania");
}
}///:~
5）嵌套類，不需要內部類對象與外圍類對象之間有聯繫，可以將內部類聲明爲static
11、java泛型