Java的內部類
概念：
- 內部類就是在一個類的內部定義一個類，比如，A類中定義一個B類，那么B類相對于A類來說就是稱為內部類，而A類相對于B類來說就是外部類。
- 成員內部類
- 靜態內部類
- 局部內部類
- 匿名內部類
特點：
- 內部類編譯之后可以生成獨立的字節碼文件。
- 內部類可以直接訪問外部類的私有成員，而不破壞封裝。
- 內部類可為外部類提供必要的內部功能組件。
- 外部類要訪問內部類的成員，必須要建立內部類的對象
成員內部類
在內的內部定義，與實例變量、實例方法同級別的類。
成員內部類中不能包含靜態成員，但可以包含靜態常量。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package com.cnblogs;//這個類用于實現public class Application { public static void main(String[] args) { Outer outer = new Outer();//實例化 外部類 Outer.Inner inner = outer.new Inner();//實例化 內部類 //一步到位實例化內部類 //Inner inner = new Outer().new Inner(); //外部類的屬性 System.out.println(outer.age);//21 //外部類方法 outer.out1();//這是外部類的方法 //內部類屬性 System.out.println(inner.in);//內部類屬性 //內部類方法 inner.inner();//這是內部類方法 //內部類獲取外部類的私有屬性 inner.getName();//獲取到了外部類的私有屬性：柒 //內部類獲取外部類的私有方法 inner.getMethod();//這是外部類的私有方法 }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
package com.cnblogs;/* * 本類用于測試內部類可以直接訪問外部類的私有成員 */public class Outer { //外部類的私有屬性 private String name = "柒"; //外部類的屬性 public int age = 21; //外部類的私有方法 private void out() { System.out.println("這是外部類的私有方法"); } //外部類的方法 public void out1() { System.out.println("這是外部類的方法"); } class Inner{ //內部類屬性 public String in = "內部類屬性"; //內部類方法 public void inner() { System.out.println("這是內部類方法"); } //獲取外部類的私有屬性 public void getName() { System.out.println("獲取到了外部類的私有屬性：" + name); } //獲取外部類的私有方法 public void getMethod() { out(); } }} |
注意：當外部類、內部類存在重名屬性時，會優先訪問內部類屬性
|
1
2
3
4
5
6
7
8
9
10
11
|
package com.cnblogs;import com.cnblogs.Outer.Inner;/* * 本類用于實現 */public class Application { public static void main(String[] args) { Inner inner = new Outer().new Inner(); inner.show(); }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
package com.cnblogs;/* * 本類用于測試內部類和外部類的同名屬性 */public class Outer { //外部類屬性 private String name = "張三"; class Inner{ //內部類屬性 private String name = "柒"; //內部類方法,用于打印 public void show() { //這里打印出的是內部類的屬性：柒 System.out.println(name); //這是打印外部類的屬性：張三 System.out.println(Outer.this.name); } }} |
靜態內部類
不依賴外部類對象，可直接創建或通過類名訪問，可聲明靜態成員
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package com.cnblogs;import com.cnblogs.Outer2.Inner;/* * 本類用于實現 */public class Application { public static void main(String[] args) { //直接創建內部類對象 Inner inner = new Outer2.Inner(); //調用方法 inner.show(); }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
|
package com.cnblogs;/* * 本類用于測速靜態內部類 *///外部類public class Outer2 { private String name = "柒"; private int age = 21; //靜態內部類 用法和外部類一樣 static class Inner{ private String in = "靜態內部類屬性"; private int inner = 99; //靜態成員 private static int inners = 999; //調用方法 public void show() { //調用外部類屬性,先創建外部類對象 Outer2 outer = new Outer2(); //再調用外部類屬性 System.out.println(outer.name);//柒 System.out.println(outer.age);//21 //調用靜態內部類屬性 System.out.println(in);//靜態內部類屬性 System.out.println(inner);//99 //調用靜態內部類的靜態成員 System.out.println(inners);//999 System.out.println(Inner.inners);//999 } }} |
局部內部類
定義在外部類方法中，作用范圍和創建對象范圍僅限于當前方法。
局部內部類訪問外部類當前方法中的局部變量時，因無法保障變量的生命周期與自身相同，變量必須修飾為final。
限制類的使用范圍。
|
1
2
3
4
5
6
7
8
|
package com.cnblogs;//這個類用于實現public class Application { public static void main(String[] args) { Outer3 outer = new Outer3(); outer.show(); }} |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
package com.cnblogs;/* * 本類用于測試局部內部類 *///外部類public class Outer3 { private String name = "柒"; private int age = 21; public void show() { //定義局部變量 String in = "蘇州"; //局部內部類:不能加任何訪問修飾符 class Inner{ //局部內部類的屬性 private String phone = "10086"; //局部內部類方法 public void show2() { //訪問外部類屬性 System.out.println(name);//Outer3.this.name System.out.println(age); //訪問內部類屬性 System.out.println(phone);//this.phone //訪問局部變量:jdk1.7要求 變量必須是常量final，jdk1.8自動添加final System.out.println(in); } } //創建內部類對象 Inner inner = new Inner(); inner.show2(); }} |
匿名內部類
沒有類名的局部內部類（一切特征都與內部類相同）。
必須繼承一個父類或者實現一個接口。
定義類、實現類、創建對象的語法合并，只能創建一個該類的對象。
- 優點：減少代碼量
- 缺點：可讀性較差
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
package com.cnblogs;/* * 本類用于實現局部內部類 */public class TestUsb { public static void main(String[] args) { //創建接口類型的變量// Usb usb = new Mouse();// usb.service(); //局部內部類// class Fan implements Usb{//// @Override// public void service() {// System.out.println("鏈接成功，可以使用！！！！");// // }// // } //使用局部內部類創建對象// Usb usb = new Fan();// usb.service(); //使用匿名內部類優化（相當于創建了一個局部內部類） Usb usb = new Usb() { @Override public void service() { System.out.println("鏈接成功，可以使用！！！！"); } }; usb.service(); }} |
|
1
2
3
4
5
6
|
package com.cnblogs;//接口public interface Usb { //服務 void service();} |
|
1
2
3
4
5
6
7
8
|
package com.cnblogs;//實現接口public class Mouse implements Usb{ @Override public void service() { System.out.println("鏈接成功，可以使用！！！！！"); }} |
總結
本篇文章就到這里了，希望能給你帶來幫助，也希望你能夠多多關注服務器之家的更多內容！
原文鏈接：https://www.cnblogs.com/fangweicheng666/p/14970784.html
