java學習-內部類

阿新 • • 發佈：2020-08-03

內部類

一個類定義在另外一個類的內部,這個類稱為內部類; 可以將內部類定義在方法中,也可以將內部類定義在成員位置, 根據定義位置不同, 功能和使用方式不同

　　class Car{ // 外部類

　　class 發動機{ // 內部類

　　　　}

　　2.根據內部類定義位置不同 :

　　　　1)成員內部類

　　　　　　普通成員內部類

　　　　　　私有成員內部類

　　　　　　靜態成員內部類

　　　　2)區域性內部類

　　有名普通區域性內部類

　　匿名內部類(掌握)

　　1.普通成員內部類

定義位置 : 定義在成員位置的內部類
語法結構:

class Body{

class Heart{ // 理解成普通成員變數

// 成員變數, 方法

　　　　}

　　3.普通成員內部類使用:

　　　　1)內部類可以直接使用外部類中的成員

　　　　2)在外部類中, 要使用普通成員內部類, 先創建出一個內部類物件,使用內部類物件.呼叫內部類中的成員變數和方法

　　　　3)除了外部類之外的其他型別中,如果想要直接使用內部類, 使用公式:

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

程式碼

 1 public class Body1 {// 外部類
 2     // blood表示血壓
 3     int blood = 120;
 4     // 普通成員內部類
 5     class 
 Heart{
 6         // 心跳變數
 7         int boom = 80;
 8         
 9         // 定義出一個心臟跳動的方法
10         public void jump() {
11             // 普通成員內部類可以直接使用外部類中的成員
12             System.out.println("血壓"+blood+",每分鐘心跳為:"+boom);
13         }
14     }
15     
16     // 定義出方法 : 使用Heart內部類
17     public void useHeart() {
 
18         Heart h = new Heart();
19         System.out.println(h.boom);
20         h.jump();
21     }
22 }

public class TestInnerClass {
    public static void main(String[] args) {
        // 1. 測試普通成員內部類
        // 1) 創建出一個外部類物件
        Body1 b1 = new Body1();
        b1.useHeart();
        
        // 2)除了外部類之外的其他型別中,如果想要直接使用內部類, 使用公式:
        //   外部類名.內部類名  內部類名字 = new 外部類物件().new 內部類物件();
        Body1.Heart heart = new Body1().new Heart();
        System.out.println(heart.boom);
        heart.jump();
    }
}

　　2.私有成員內部類

定義位置 : 定義在成員位置的內部類, 內部類使用關鍵字private修飾
語法結構:

class Body2{

private class Shen{

// 成員變數, 方法

　　　　}

　　3.私有成員內部類使用:

　　　　1)私有成員內部類可以直接使用外部類中的成員

　　　　2)私有成員內部類,只能在當前的外部類中使用, 除了外部類之外,其他型別無法直接使用私有成員內部類; 需要在外部類中,提供對外的訪問私有成員內部類的方式

程式碼

public class Body2 {
    int drink = 10;
    // 定義出私有成員內部類
    private class Shen{
        int wc = 5;
        
        public void goToWc() {
            // 1)私有成員內部類可以直接使用外部類中的成員
            System.out.println("一天喝了"+drink + "升水,去衛生間"+wc+"次,好好排毒~~");
        }
    }
    
    // 在外部類中,提供對外的訪私有成員內部類的方式
    public void useShen() {
        Shen sh = new Shen();
        System.out.println(sh.wc);
        sh.goToWc();
    }
}

public class TestInnerClass {
    public static void main(String[] args) {
        // 2. 測試私有成員內部類
        Body2 b2 = new Body2();
        b2.useShen();
    }
}

　　3.靜態成員內部類

定義位置 : 定義在成員位置的內部類, 內部類使用關鍵字static修飾
語法結構:

　　class Body3{

　　static class Gan{

　　// 成員變數,方法

　　　　}

　　3.靜態成員內部類使用:

　　　　1)靜態成員內部類中可以直接使用外部類中的靜態成員; 如果使用外部類中的非靜態成員, 需要先創建出一個外部類物件, 才能使用

　　　　2)靜態成員內部類中 : 靜態成員, 可以使用外部類名.內部類名.直接呼叫

　　　　3)靜態成員內部類中 : 非靜態成員, 需要創建出內部類物件才能使用

外部類名.內部類名靜態內部類名字 = new 外部類名.內部類名()

程式碼

public class Body3 {
    String name = "張三";
    static int drink = 10;
    
    // 靜態成員內部類
    static class Gan{
        int day = 2;
        static int drinkNow = 1;
        
        public void jiu() {
            // 1. 創建出一個外部類Body3物件, 為了使用外部類中的非靜態成員
            Body3 b3 = new Body3();
            System.out.println(b3.name + day + "天,喝了" + drink + "斤酒,喝多了,最好喝" + drinkNow + "斤比較合適");
        }
    }
}

public class TestInnerClass {
    public static void main(String[] args) {
    
        // 3. 靜態成員內部類測試
        // 靜態成員內部類中 : 靜態成員, 可以使用外部類名.內部類名.直接呼叫
        System.out.println(Body3.Gan.drinkNow);
        
        // 創建出一個靜態成員內部類物件
        // 外部類名.內部類名  靜態內部類名字 = new 外部類名.內部類名();
        Body3.Gan b3 = new Body3.Gan();
        System.out.println(b3.day);
        b3.jiu();
    }
}

　　4.普通區域性內部類

定義位置 : 定義在一個方法中的內部類
語法結構:

　　void breath(){

　　class Fei{

　　// 成員變數,方法

　　　　}

　　3.普通區域性內部類的使用:

　　　　1)在方法中定義出的區域性變數, 外界無法直接獲取到這個變數, 只能通過方法的執行間接使用區域性變數; 同理, 區域性內部類需要通過方法的執行, 間接訪問到這個區域性內部類

　　　　2)定義好了區域性內部類之後,在當前方法中,直接創建出一個區域性內部類物件, 呼叫區域性內部類中的屬性和方法

public class Demo_區域性內部類 {
    public static void main(String[] args) {
        breath();
        Demo_區域性內部類.breath();
    }
    
    // 定義出一個方法功能
    public static void breath() {
        int i = 10;
        // 定義出一個佈局內部類
        class Fei{
            String color = "黑色";
            
            public void smoke() {
               System.out.println("每天吸" + i + "根菸, 有一天你的肺有可能變成" + color);
            }
        }
        
        // 創建出一個區域性內部類物件
        Fei f = new Fei();
        System.out.println(f.color);
        f.smoke();
    }
}

　　5.匿名內部類

匿名內部類 : 定義在方法中, 沒有名字的內部類
匿名內部類作用:

可以作為一個類的子類或者是作為一個介面的實現類

　　3.匿名內部類語法結構:

new 父類或者父介面(){

// 大括號表示對於父類或者父介面的實現過程

父類或者父介面中的方法重寫;

　　};

　　4.匿名內部類的使用:

　　　　1)定義出一個匿名內部類之後, 只能使用一次, 使用方法:

　　　　new 父類或者父介面(){

　　　　}.呼叫一次資料內容;

　　　　2)匿名內部類使用優化 :

　　將匿名內部類物件通過多型表達方式, 使用一個父類或者父介面完成表示式

　　　　父類或者父介面變數名= new 父類或者父介面(){

　　　　};

　　　　變數名.可以任何的多次的呼叫匿名內部類實現和繼承到的方法功能;

程式碼

public interface MyInter {
     public abstract void fun();
     public abstract int getSum(int x, int y);
}

public class Demo_匿名內部類 {
    public static void main(String[] args) {
        
        // 1. 創建出一個MyInter介面匿名內部類
        new MyInter() {
            // 大括號表示式介面MyInter的實現類實現過程
            @Override
            public void fun() {
                System.out.println("匿名內部類實現fun");
            }

            @Override
            public int getSum(int x, int y) {
                return x + y;
            }
        }.fun();
        
        // 2. 匿名內部類物件優化
        // 使用多型, 利用父介面引用指向實現類物件
        MyInter my = new MyInter() {
            // 大括號表示式介面MyInter的實現類實現過程
            @Override
            public void fun() {
                System.out.println("匿名內部類實現fun");
            }

            @Override
            public int getSum(int x, int y) {
                return x + y;
            }
        };
        
        my.fun();
        int result = my.getSum(4, 5);
        System.out.println(result);
    }
}