一、什麼是嵌套類及內部類
可以在一個類的內部定義另一個類，這種類稱為嵌套類（nested classes），它有兩種類型：靜態嵌套類和非靜態嵌套類。靜態嵌套類使用很少，最重要的是非靜態嵌套類，也即是被稱作為內部類（inner）。嵌套類從JDK1.1開始引入。其中inner類又可分為三種：
其一、在一個類（外部類）中直接定義的內部類；
其二、在一個方法（外部類的方法）中定義的內部類；
其三、匿名內部類。
下面，我將說明這幾種嵌套類的使用及注意事項。
二、靜態嵌套類
如下所示代碼為定義一個靜態嵌套類，
public class StaticTest {
private static String name = "javaJohn";
private String id = "X001";
static class Person{
private String address = "swjtu,chenDu,China";
public String mail = "[email protected]";//內部類公有成員
public void display(){
//System.out.println(id);//不能直接訪問外部類的非靜態成員
System.out.println(name);//只能直接訪問外部類的靜態成員
System.out.println("Inner "+address);//訪問本內部類成員。
}
}
public void printInfo(){
Person person = new Person();
person.display();
//System.out.println(mail);//不可訪問
//System.out.println(address);//不可訪問
System.out.println(person.address);//可以訪問內部類的私有成員
System.out.println(person.mail);//可以訪問內部類的公有成員
}
public static void main(String[] args) {
StaticTest staticTest = new StaticTest();
staticTest.printInfo();
}
}
在靜態嵌套類內部，不能訪問外部類的非靜態成員，這是由Java語法中"靜態方法不能直接訪問非靜態成員"所限定。若想訪問外部類的變量，必須通過其它方法解決，由於這個原因，靜態嵌套類使用很少。注意，外部類訪問內部類的的成員有些特別，不能直接訪問，但可以通過內部類來訪問，這是因為靜態嵌套內的所有成員和方法默認為靜態的了。同時注意，內部靜態類Person只在類StaticTest 范圍內可見，若在其它類中引用或初始化，均是錯誤的。
三、在外部類中定義內部類
1、內部類分為成員內部類、靜態嵌套類、方法內部類、匿名內部類。
幾種內部類的共性：
A、內部類仍然是一個獨立的類，在編譯之後會內部類會被編譯成獨立的.class文件，但是前面冠以外部類的類命和$符號。
B、內部類不能用普通的方式訪問。內部類是外部類的一個成員，因此內部類可以自由地訪問外部類的成員變量，無論是否是private的。
如下所示代碼為在外部類中定義兩個內部類及它們的調用關系：
public class Outer {
int outer_x = 100;
class Inner{
public int y = 10;
private int z = 9;
int m = 5;
public void display(){
System.out.println("display outer_x:"+ outer_x);
}
private void display2(){
System.out.println("display outer_x:"+ outer_x);
}
}
void test(){
Inner inner = new Inner();
inner.display();
inner.display2();
//System.out.println("Inner y:" + y);//不能訪問內部內變量
System.out.println("Inner y:" + inner.y);//可以訪問
System.out.println("Inner z:" + inner.z);//可以訪問
System.out.println("Inner m:" + inner.m);//可以訪問
InnerTwo innerTwo = new InnerTwo();
innerTwo.show();
}
class InnerTwo{
Inner innerx = new Inner();
public void show(){
//System.out.println(y);//不可訪問Innter的y成員
//System.out.println(Inner.y);//不可直接訪問Inner的任何成員和方法
innerx.display();//可以訪問
innerx.display2();//可以訪問
System.out.println(innerx.y);//可以訪問
System.out.println(innerx.z);//可以訪問
System.out.println(innerx.m);//可以訪問
}
}
public static void main(String args[]){
Outer outer = new Outer();
outer.test();
}
}
總結：
1、對於內部類，通常在定義類的class關鍵字前不加public 或 private等限制符，若加了沒有任何影響。
2、內部類中可以直接訪問外部類的數據成員和方法。
3、另外，就是要注意，內部類Inner及InnterTwo只在類Outer的作用域內是可知的，如果類Outer外的任何代碼嘗試初始化類Inner或使用它，編譯就不會通過。同時，內部類的變量成員只在內部內內部可見，若外部類或同層次的內部類需要訪問，需采用示例程序中的方法，不可直接訪問內部類的變量。
四、方法內部類
顧名思義，把類放在方法內。
class Outer {
public void doSomething(){
class Inner{
public void seeOuter(){
}
}
}
}
A、方法內部類只能在定義該內部類的方法內實例化，不可以在此方法外對其實例化。
B、方法內部類對象不能使用該內部類所在方法的非final局部變量。
因為方法的局部變量位於棧上，只存在於該方法的生命期內。當一個方法結束，其棧結構被刪除，局部變量成為歷史。但是該方法結束之後，在方法內創建的內部類對象可能仍然存在於堆中！例如，如果對它的引用被傳遞到其他某些代碼，並存儲在一個成員變量內。
正因為不能保證局部變量的存活期和方法內部類對象的一樣長，所以內部類對象不能使用它們。
下面是完整的例子：
class Outer {
public void doSomething(){
final int a =10;
class Inner{
public void seeOuter(){
System.out.println(a);
}
}
Inner in = new Inner();
in.seeOuter();
}
public static void main(String[] args) {
Outer out = new Outer();
out.doSomething();
}
}
五、匿名內部類
沒有名字的內部類。表面上看起來它們似乎有名字，實際那不是它們的名字。
A、繼承式的匿名內部類。
class Car {
public void drive(){
System.out.println("Driving a car!");
}
}
class Test{
public static void main(String[] args) {
Car car = new Car(){
public void drive(){
System.out.println("Driving another car!");
}
};
car.drive();
}
}
結果輸出了：Driving another car! Car引用變量不是引用Car對象，而是Car匿名子類的對象。
B、接口式的匿名內部類。
interface Vehicle {
public void drive();
}
class Test{
public static void main(String[] args) {
Vehicle v = new Vehicle(){
public void drive(){
System.out.println("Driving a car!");
}
};
v.drive();
}
}
上面的代碼很怪，好像是在實例化一個接口。事實並非如此，接口式的匿名內部類是實現了一個接口的匿名類。而且只能實現一個接口。
C、參數式的匿名內部類。
class Bar{
void doStuff(Foo f){}
}
interface Foo{
void foo();
}
class Test{
static void go(){
Bar b = new Bar();
b.doStuff(new Foo(){
public void foo(){
System.out.println("foofy");
}
});
}
}
以上就是本文的全部內容，希望對大家的學習有所幫助，也希望大家多多支持。
