Java 內部類

一 . 非靜態成員內部類


public class MemberOuter {

/**
* @param args
*/
// 成員變量 i 未賦值，默認值爲0
private static int i;// 定義一個靜態私有的成員變量 i
private int j = 10;
private int k = 10;

/**
* 定義一個外部的靜態方法
*/
public static void outer_f1() {
System.out.println("this is outer_f1");
}

public void outer_f2() {
System.out.println("this is outer_f2");
}

/**
* 成員內部類中，不能定義靜態成員 成員內部類中，可以訪問外部類的所有成員
*
* @param args
*/
class Inner {
/**
* static int inner_i = 100; 內部類中不允許定義靜態變量
*/
/**
* 內部類和外部類的實例變量可以共存
*/
int j = 100;
int inner_i = 1;

void inner_f1() {
/**
* 如果內部類中沒有與外部類同名的變量，則可以直接用變量名訪問外部類變量
*/
System.out.println(i);
/**
* 在內部類中訪問內部類自己的變量直接用變量名
*/
System.out.println(j);
/**
* 在內部類中訪問內部類自己的變量也可以用this.變量名
*/
System.out.println(this.j);
/**
* 在內部類訪問外部類中與內部類同名的實例變量用外部類名.this.變量名
*/
System.out.println(MemberOuter.this.j);
System.out.println(k);
outer_f1();
outer_f2();
}
}

/**
* 外部類的非靜態方法訪問成員內部類
*
* @param args
*/
public void outer_f3() {
Inner inner = new Inner();
inner.inner_f1();
}

/**
* 外部類的靜態方法訪問成員內部類，與在外部類外部訪問成員內部類一樣
*
* @param args
*/
public static void outer_f4() {
/**
* step1 建立外部類對象
*/
MemberOuter out = new MemberOuter();
/**
* step2 根據外部類對象建立內部類對象
*/
Inner inner = out.new Inner();
/**
* step3 訪問內部類的方法
*/
inner.inner_f1();
}

public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* outer_f4(); //該語句的輸出結果和下面三條語句的輸出結果一樣
* 如果要直接創建內部類的對象，不能想當然地認爲只需要加上外部類Outer的名字就可以按照通常的樣***子生成
* 內部類的對象，而是必須使用此外部類的一個對象來創建其內部類的一個對象 Outer.Inner outin = out.new
* Inner(); 因此，除非你已經有了一個外部類的對象，否則不可能生成內部類的對象。因爲此內部類的對象會悄悄**地
* 連接到創建它的外部類的對象。如果你用的是靜態內部類那就不需要對其外部類對象的引用
*/
MemberOuter out = new MemberOuter();
MemberOuter.Inner outin = out.new Inner();
outin.inner_f1();

}
}


二. 局部內部類


/**
* 局部內部類也叫方法內部類，即在方法內部定義的內部類。
*/
public class LocalOuter {

/**
* @param args
*/
private int s = 100;
private int out_i = 1;

/**
* 局部內部類中，如果要訪問外部類的局部變量，則此變量必須是final修飾， 因爲方法的生命週期只是在調用時存在，方法調用完就結束而內部類實例化後並
* 不隨外部類成員方法的消失而消失，所有爲了提高局部變量的生命週期必須用final修飾
*/
public void method(final int k) {
final int s = 200;
int i = 1;
final int j = 10;
class Inner {
int s = 300;
/**
* 由於內部類的對象中保存有外部類對象的引用，因而在內部類中不能定義靜態的屬性
*/
// static int m = 20;
int inner_i = 100;

Inner(int k) {
inner_method(k);
}

void inner_method(int k) {
/**
* 如果內部類沒有與外部類同名的變量，在內部類中可以直接訪問外部類的實例變量
*/
System.out.println(out_i);
/**
* 可以訪問外部類的局部變量（即方法內的變量），該變量必須經過final修飾
*/
System.out.println(j);
// System.out.println(i); //不能通過編譯
/**
* 如果內部類中有與外部類同名的變量，直接用變量名訪問的是內部類的變量。 同樣也可以用this.變量名訪問內部變量。
*/
System.out.println(s);
System.out.println(this.s);
/**
* 用外部類名.this.變量名放問的是外部變量。
*/
System.out.println(LocalOuter.this.s);
}
}
/**
* 訪問局部內部類必須先有外部類對象
*/
new Inner(k);
}

public static void main(String[] args) {
// 訪問局部內部類必須先有外部類對象
LocalOuter out = new LocalOuter();
out.method(3);
}

}


三 . 靜態內部類


/**
* 用static修飾的內部類叫靜態內部類，這個內部類相當於一個外部定義的類
* 靜態內部類中可以聲明static成員或非靜態成員，並可以通過public，protected，private修飾。
*/
public class StaticOuter {

private static int i = 1;
private int j = 10;

public static void outer_method1() {
System.out.println("this is first outer_method");
}

public static void outer_method2() {
System.out.println("this is second outer_method");
}

static class Inner {
static int inner_i = 100;
int inner_j = 200;

static void inner_method1() {
/**
* 靜態內部類只能訪問外部類的靜態成員（包括靜態方法和靜態變量）
*/
System.out.println(i);
outer_method1();
}

void inner_method2() {
/**
* 靜態內部類只能訪問外部類的靜態成員（包括靜態方法和靜態變量）
*/
// System.out.println(j);
// outer_method2();
}
}

public void outer_method3() {
/**
* 外部類訪問內部類的靜態成員：內部類.靜態成員
*/
System.out.println(Inner.inner_i);
Inner.inner_method1();
/**
* 外部類訪問內部類的靜態成員時實例化內部類即可
*/
Inner inner = new Inner();
inner.inner_method2();
}

public static void main(String[] args) {
// TODO Auto-generated method stub
new StaticOuter().outer_method3();
}

}


四 . 匿名內部類


//接口
public interface A {
abstract public void method();
}

/**
* 匿名內部類就是沒有名字的內部類。所有匿名內部類是沒有構造器的。如果內部類繼承了一個帶有參數構造器的父類，則在創建
* 它的時候必須要帶上參數，並且在實現的過程中使用super關鍵字調用相應的內容
*/
public class AnonymosOuter {

/**
* @param args
*/
public void callInner(A a) {
a.method();
}

public void second_method() {
// 不能改變值
final int x = 10;
/**
* 匿名內部類爲局部內部類，所有局部內部類的限制都對其生效 局部變量x並不是真正的匿名在內部類中使用，x會被匿名內部類複製作爲數據成員來使用。
*/
Object obj = new Object() {
public String toString() {
return String.valueOf(x);
}
};
System.out.println(obj);
}

public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* 接口不能用new操作符，但此處比較特殊的是子類對象實現接口，只不過沒有爲對象命名
*/
new AnonymosOuter().callInner(new A() {
public void method() {
System.out.println("implement for method");
}
});
new AnonymosOuter().second_method();
}

}