內部類
定義:將一個類定義在另一個類的里面,里面那個類就稱為內部類(內置類,嵌套類)。
訪問特點:
- 內部類可以直接訪問外部類中的成員,包括私有成員。
- 而外部類要訪問內部類中的成員必須要建立內部類的對象。
用法:
一般用于類的設計。分析事物時,發現該事物描述中還有事物,而且這個事物還在訪問被描述事物的內容,這時就將里面的事物定義成內部類。
細節:
Example 1:為什么內部類能直接訪問外部類的成員呢?是因為內部持有了外部類的引用-->外部類.this
。
class Outer
{
int num = 3;
class Inner
{
int num = 4;
void show()
{
int num = 5;
System.out.println(num); //打印5
System.out.println(this.num); //打印4,或者可寫為Inner.this.num
System.out.println(Outer.this.num); //打印3
}
}
public void method()
{
new Inner().show();
}
}
class Demo
{
public static void main(String[] args)
{
new Outer().method();
}
}
成員內部類
定義:內部類定義在成員位置上。
特點:
- 可以被private static成員修飾符修飾。
- 被static修飾的內部類只能訪問外部類中的靜態成員。
Example 1:內部類和其成員都是非靜態的
class Outer
{
private int num = 3;
class Inner
{
void show()
{
System.out.println("show run..."+num);
}
}
public void method()
{
Inner in = new Inner();
in.show();
}
}
class Demo
{
public static void main(String[] args)
{
//直接訪問外部類中的內部類中的成員
Outer.Inner in = new Outer().new Inner(); //不常用,因為一般都將內部類封裝了
in.show();
}
}
Example 2:內部類為靜態,其成員為非靜態的
class Outer
{
private static int num = 3;
static class Inner
{
void show()
{
System.out.println("show run..."+num);
}
}
public void method()
{
Inner in = new Inner();
in.show();
}
}
class Demo
{
public static void main(String[] args)
{
//如果內部類是靜態的,相當于一個外部類
Outer.Inner in = new Outer.Inner();//不需要再創建Outer對象
in.show();
}
}
Example 3:內部類和其成員都為靜態
class Outer
{
private static int num = 3;
static class Inner
{
static void show()
{
System.out.println("show run..."+num);
}
}
public void method()
{
Inner.show();
}
}
class Demo
{
public static void main(String[] args)
{
Outer.Inner.show();//不需要再創建Outer和Inner對象
}
}
如果內部類中定義了靜態成員,則該內部類也必須是靜態的。
如果類中的靜態函數想訪問內部類,則該內部類必須是靜態的。
局部內部類
定義:內部類定義在局部位置上。
特點:
- 也可以直接訪問外部類中的成員。
- 同時可以訪問所在局部中的局部變量,但必須是被final修飾的。
Example 1:示例
class Outer
{
int num = 3;
void method()
{
int x = 9;
final int y = 8;
class Inner
{
void show()
{
System.out.println("show..."+num);//可以直接訪問外部類中的成員。
System.out.println("show..."+x); //編譯錯誤,從內部類中訪問所在局部中的局部變量x,需要被聲明為最終類型
System.out.println("show..."+y); //可以訪問所在局部中的局部變量,但必須是被final修飾的。
}
}
Inner in = new Inner();
in.show();
}
//method()方法外不能訪問Inner
}
class Demo
{
public static void main(String[] args)
{
new Outer().method();
}
}
Example 2:為什么局部變量需要被final修飾,局部內部類才可訪問?
class Outer
{
int num = 3;
Object method()//若method函數有參數int y,如果想在內部類Inner中訪問,也需要寫為final int y
{
int x = 9;
class Inner
{
void show()
{
System.out.println("show..."+x);
}
}
Object in = new Inner();
return in;
}
}
class Demo
{
public static void main(String[] args)
{
Outer out = new Outer();
Object obj = out.method();
}
}
method函數執行完就出棧了,x便不存在了,而obj對象仍然存在,于是訪問不了x,因此需把x聲明為常量。
實質上是,java把局部內部類對象要訪問的final型局部變量,復制過來變成該內部類對象中的一個成員變量,這樣即使棧中局部變量(含final)已死亡,但由于它是final的,其值是不會發生改變的,因而內部類對象在局部變量死亡后,照樣可以訪問自己內部維護的一個值跟局部變量一樣的成員變量,從而解決這個問題。
注意:java8中匿名/局部內部類訪問局部變量時,局部變量已經可以不用加final了,但其實這個局部變量還是final的(表現為對該值初始化后不能再賦值了),只不過不用顯式的加上而已,推測可能是編譯機制發生了改變。
匿名內部類
定義:局部內部類的簡化寫法。
前提:內部類必須繼承或實現一個外部類或者接口。
格式:new 外部類名或者接口名(){覆蓋類或者接口中的代碼,也可以自定義內容}
簡單理解:就是建立一個帶內容的外部類或者接口的子類匿名對象。
Example 1:匿名類中重寫一個函數
abstract class Demo
{
abstract void show();
}
class Outer
{
int num = 4;
/*
class Inner extends Demo
{
void show()
{
System.out.println("show..."+num);
}
}
*/
public void method()
{
//new Inner().show();
new Demo()//new了Demo類的子類對象
{
void show()
{
System.out.println("show..."+num);
}
}.show();
}
}
class Demo
{
public static void main(String[] args)
{
new Outer().method();
}
}
Example 2:匿名類中重寫兩個函數
interface Demo
{
void show1();
void show1();
}
class Outer
{
int num = 4;
public void method()
{
Demo demo = new Demo() //類似于多態,父類引用指向了子類對象
{
public void show1()
{
System.out.println("show1..."+num);
}
public void show2()
{
System.out.println("show2..."+num);
}
}
demo.show1();
demo.show2();
}
}
應用:當函數參數是接口類型時,而且接口中的方法不超過三個,可以用匿名內部類作為實際參數進行傳遞。
/*---以前的寫法----*/
interface Inter
{
void show1();
void show2();
}
class InterImpl implements Inter
{
public void show1(){}
public void show2(){}
}
class Demo
{
public static void main(String[] args)
{
show(new InterImpl());
}
public static void show(Inter in)
{
in.show1();
in.show2();
}
}
/*---可以改為以下寫法----*/
interface Inter
{
void show1();
void show2();
}
class Demo
{
public static void main(String[] args)
{
show(new Inter()
{
public void show1(){}
public void show2(){}
});
}
public static void show(Inter in)
{
in.show1();
in.show2();
}
}
細節:
class Outer
{
void method()
{
new Object()
{
public void show()
{
System.out.println("show run");
}
}.show();//創建的Object的子類對象,調用的子類對象的方法
/*
Object obj = new Object(){
public void show()
{
System.out.println("show run");
}
};
obj.show(); //編譯錯誤,在java.lang.Object里找不到show()方法,因為匿名內部類這個子類對象已經被向上轉型為了Object類型,這樣就不能使用子類特有的方法了,只能調用父類或接口中存在的方法。
*/
}
}
class Demo
{
public static void main(String[] args)
{
new Outer().method();
}
}