10（02）總結形式引數，包，修飾符，內部類

阿新 • • 發佈：2022-05-04

6:內部類(理解)

(1)把類定義在另一個類的內部，該類就被稱為內部類。

舉例：把類B定義在類A中，類B就被稱為內部類。

(2)內部類的訪問規則

A:可以直接訪問外部類的成員，包括私有

B:外部類要想訪問內部類成員，必須建立物件

內部類概述:

把類定義在其他類的內部，這個類就被稱為內部類。

舉例：在類A中定義了一個類B，類B就是內部類。

內部的訪問特點：

A:內部類可以直接訪問外部類的成員，包括私有。

B:外部類要訪問內部類的成員，必須建立物件。

*/
class Outer {
 private int num = 10;
 class Inner {
 public void show() {
 System.out.println(num);
 }
 }
 public void method() {
 //找不到符號
 //show();
 Inner i = new Inner();
 i.show();
 }
}
class InnerClassDemo {
 public static void main(String[] args) {
 }
}

(3)內部類的分類

A:成員內部類

B:區域性內部類

/*
 內部類位置
 成員位置:在成員位置定義的類，被稱為成員內部類。 
 區域性位置:在區域性位置定義的類，被稱為區域性內部類。
 成員位置:在成員位置定義的類，被稱為成員內部類。 
*/
class Outer {
 private int num = 10;
 //成員位置
 /*
 class Inner {
 }
 */
 public void method() {
 //區域性位置
 class Inner {
 }
 }
}
class InnerClassDemo2 {
 public static void main(String[] args) {
 }
}

(4)成員內部類

A:private 為了資料的安全性

B:static 為了訪問的方便性

成員內部類不是靜態的：

外部類名.內部類名物件名 = new 外部類名.new 內部類名();

成員內部類是靜態的：

外部類名.內部類名物件名 = new 外部類名.內部類名();

/*
 成員內部類:
 如何直接訪問內部類的成員。
 外部類名.內部類名 物件名 = 外部類物件.內部類物件;
*/
class Outer {
 private int num = 10;
 class Inner {
 public void show() {
 System.out.println(num);
 }
 }
}
class InnerClassDemo3 {
 public static void main(String[] args) {
 //需求：我要訪問Inner類的show()方法
 //Inner i = new Inner();
 //i.show();
 //格式：外部類名.內部類名 物件名 = 外部類物件.內部類物件;
 Outer.Inner oi = new Outer().new Inner();
 oi.show();
 }
}
/*
 成員內部類的修飾符：
 private 為了保證資料的安全性
 static 為了方便訪問資料
 注意：靜態內部類訪問的外部類資料必須用靜態修飾。
 案例：我有一個人(人有身體，身體內有心臟。)
 class Body {
 private class Heart {
 public void operator() {
 System.out.println("心臟搭橋");
 }
 }
 public void method() {
 if(如果你是外科醫生) {
 Heart h = new Heart();
 h.operator();
 }
 }
 }

按照我們剛才的講解，來使用一下

 Body.Heart bh = new Body().new Heart();
 bh.operator();
 //加了private後，就不能被訪問了，那麼，怎麼玩呢?
 Body b =  new Body();
 b.method();
*/
class Outer {
 private int num = 10;
 private static int num2 = 100;
 //內部類用靜態修飾是因為內部類可以看出是外部類的成員
 public static class Inner {
 public void show() {
 //System.out.println(num);
 System.out.println(num2);
 }
 public static void show2() {
 //System.out.println(num);
 System.out.println(num2);
 } 
 }
}
class InnerClassDemo4 {
 public static void main(String[] args) {
 //使用內部類
 // 限定的新靜態類
 //Outer.Inner oi = new Outer().new Inner();
 //oi.show();
 //oi.show2();
 //成員內部類被靜態修飾後的訪問方式是:
 //格式：外部類名.內部類名 物件名 = new 外部類名.內部類名();
 Outer.Inner oi = new Outer.Inner();
 oi.show();
 oi.show2();
 //show2()的另一種呼叫方式
 Outer.Inner.show2();
 }
}

(5)成員內部類的面試題(填空)

 30,20,10
 class Outer {
 public int num = 10;
 class Inner {
 public int num = 20;
 public viod show() {
 int num  = 30;
 System.out.println(num);
 System.out.println(this.num);
 System.out.println(Outer.this.num);
 }
 }
 }
/* 面試題：
 要求請填空分別輸出30，20，10。
 注意：
 1:內部類和外部類沒有繼承關係。
 2:通過外部類名限定this物件
 Outer.this
*/

class Outer {
 public int num = 10;
 class Inner {
 public int num = 20;
 public void show() {
 int num = 30;
 System.out.println(num);
 System.out.println(this.num);
 //System.out.println(new Outer().num);
 System.out.println(Outer.this.num);
 }
 }
}
class InnerClassTest {
 public static void main(String[] args) {
 Outer.Inner oi = new Outer().new Inner();
 oi.show();
 } 
}

(6)區域性內部類

A:區域性內部類訪問區域性變數必須加final修飾。

B:為什麼呢?

因為區域性變數使用完畢就消失，而堆記憶體的資料並不會立即消失。

所以，堆記憶體還是用該變數，而改變數已經沒有了。

為了讓該值還存在，就加final修飾。

通過反編譯工具我們看到了，加入final後，堆記憶體直接儲存的是值，而不是變數名。

/*
 區域性內部類
 A:可以直接訪問外部類的成員
 B:在區域性位置，可以建立內部類物件，通過物件呼叫內部類方法，來使用區域性內部類功能
 面試題：
 區域性內部類訪問區域性變數的注意事項?
 A:區域性內部類訪問區域性變數必須用final修飾
 B:為什麼呢?
 區域性變數是隨著方法的呼叫而呼叫，隨著呼叫完畢而消失。
 而堆記憶體的內容並不會立即消失。所以，我們加final修飾。
 加入final修飾後，這個變數就成了常量。既然是常量。你消失了。
 我在記憶體中儲存的是資料20，所以，我還是有資料在使用。
*/
class Outer {
 private int num  = 10;
 public void method() {
 //int num2 = 20;
 //final int num2 = 20;
 class Inner {
 public void show() {
 System.out.println(num);
 //從內部類中訪問本地變數num2; 需要被宣告為最終型別
 System.out.println(num2);//20
 }
 }
 //System.out.println(num2);
 Inner i = new Inner();
 i.show();
 }
}
class InnerClassDemo5 {
 public static void main(String[] args) {
 Outer o = new Outer();
 o.method();
 }
}

(7)匿名內部類(掌握)

A:是區域性內部類的簡化形式

B:前提

存在一個類或者介面

C:格式:

new 類名或者介面名() {

重寫方法;

}

D:本質：

其實是繼承該類或者實現介面的子類匿名物件

/*
 匿名內部類
 就是內部類的簡化寫法。
 前提：存在一個類或者介面
 這裡的類可以是具體類也可以是抽象類。
 格式：
 new 類名或者介面名(){
 重寫方法;
 }
 本質是什麼呢?
 是一個繼承了該類或者實現了該介面的子類匿名物件。
*/
interface Inter {
 public abstract void show();
 public abstract void show2();
}
class Outer {
 public void method() {
 //一個方法的時候
 /*
 new Inter() {
 public void show() {
 System.out.println("show");
 }
 }.show();
 */
 //二個方法的時候
 /*
 new Inter() {
 public void show() {
 System.out.println("show");
 }
 public void show2() {
 System.out.println("show2");
 }
 }.show();
 new Inter() {
 public void show() {
 System.out.println("show");
 }
 public void show2() {
 System.out.println("show2");
 }
 }.show2();
 */
 //如果我是很多個方法，就很麻煩了
 //那麼，我們有沒有改進的方案呢?
 Inter i = new Inter() { //多型
 public void show() {
 System.out.println("show");
 }
 public void show2() {
 System.out.println("show2");
 }
 };
 i.show();
 i.show2();
 }
}
class InnerClassDemo6 {
 public static void main(String[] args) {
 Outer o = new Outer();
 o.method();
 }
}

(8)匿名內部類在開發中的使用

我們在開發的時候，會看到抽象類，或者介面作為引數。

而這個時候，我們知道實際需要的是一個子類物件。

如果該方法僅僅呼叫一次，我們就可以使用匿名內部類的格式簡化。

 interface Person {
 public abstract void study();
 }
 class PersonDemo {
 public void method(Person p) {
 p.study();
 }
 }
 class PersonTest {
 public static void main(String[] args) {
 PersonDemo pd = new PersonDemo();
 pd.method(new Person() {
 public void study() {
 System.out.println("好好學習，天天向上");
 }
 });
 }
 }
/*
 匿名內部類在開發中的使用
*/
interface Person {
 public abstract void study();
}
class PersonDemo {
 //介面名作為形式引數
 //其實這裡需要的不是介面，而是該介面的實現類的物件
 public void method(Person p) {
 p.study();
 }
}
//實現類
class Student implements Person {
 public void study() {
 System.out.println("好好學習,天天向上");
 }
}
class InnerClassTest2 {
 public static void main(String[] args) {
 //測試
 PersonDemo pd = new PersonDemo();
 Person p = new Student();
 pd.method(p);
 System.out.println("--------------------");
 //匿名內部類在開發中的使用
 //匿名內部類的本質是繼承類或者實現了介面的子類匿名物件
 pd.method(new Person(){
 public void study() {
 System.out.println("好好學習,天天向上");
 }
 });
 }
}

(9)匿名內部類的面試題(補齊程式碼)

 interface Inter {
 void show();
 }
 class Outer {
 //補齊程式碼
 public static Inter method() {
 return new Inter() {
 public void show() {
 System.out.println("HelloWorld");
 } 
 };
 }
 }
 class OuterDemo {
 public static void main(String[] args) {
 Outer.method().show(); //"HelloWorld"
 }
 }
/*
 匿名內部類面試題：
 按照要求，補齊程式碼
 interface Inter { void show(); }
 class Outer { //補齊程式碼 }
 class OuterDemo {
 public static void main(String[] args) {
   Outer.method().show();
   }
 }
 要求在控制檯輸出”HelloWorld”
*/
interface Inter { 
 void show(); 
 //public abstract
}
class Outer { 
 //補齊程式碼
 public static Inter method() {
 //子類物件 -- 子類匿名物件
 return new Inter() {
 public void show() {
 System.out.println("HelloWorld");
 }
 };
 }
}
class OuterDemo {
 public static void main(String[] args) {
 Outer.method().show();
 /*
 1:Outer.method()可以看出method()應該是Outer中的一個靜態方法。
 2:Outer.method().show()可以看出method()方法的返回值是一個物件。
 又由於介面Inter中有一個show()方法,所以我認為method()方法的返回值型別是一個介面。
 */
 }
}