2. 程式人生 > 實用技巧 >Java基礎 -- 內部類

Java基礎 -- 內部類

阿新 • • 發佈：2020-09-17

1、內部類

內部類是定義在一個類的內部的類，內部類 不能定義靜態變數和方法。介面內也可以使用內部類，但沒必要

  • 更好的實現隱藏：內部類可以被 private 與 protected 修飾
  • 內部類擁有外部類的所有元素的訪問許可權：可以直接呼叫所有外部類的成員，包括 private 修飾的變數和方法、非靜態變數和方法等
  • 可以間接的實現多重繼承：一個類中可以寫多個內部類，分別繼承不同的類
  • 可以避免實現的介面或繼承的類中有同名的方法
  • 當想要定義一個回撥函式且不想編寫大量程式碼時，使用匿名內部類比較便捷

1.1 內部類區別

1.2 成員內部類

public class Test {
    public int x = 1;
    private static int y = 10;
    String str = "Test";

    public void m1() {
        System.out.println("Test m1");
    }

    private static void m2() {
        System.out.println("Test m2");
    }

    void str() {
        System.out.println("Test str");
    }

    // 成員內部類
    class InnerClass {
        String str = "InnerClass";

        void method() {
            // 外部類成員變數
            System.out.println(x);
            // 外部類靜態變數
            System.out.println(y);
            // 同名變數，優先呼叫內部類變數
            System.out.println(str);
            // 外部類同名變數
            System.out.println(Test.this.str);
            // 外部類方法
            m1();
            // 外部類靜態方法
            m2();
            // 同名方法，優先呼叫內部類方法
            str();
            // 外部類同名方法
            Test.this.str();
        }

        void str() {
            System.out.println("InnerClass str");
        }
    }

    public static void main(String[] args) {
        // 先建立外部類物件
        Test test = new Test();
        // 通過外部類物件建立內部類物件
        Test.InnerClass inner = test.new InnerClass();
        // 呼叫內部類方法
        inner.method();
        // 呼叫內部類成員變數
        System.out.println(inner.str);
    }
}

1.3 靜態內部類

被 static 修飾的成員內部類，不需要依賴於外部類的，可以看做靜態變數，不能直接使用外部類的非靜態變數或方法

public class Test {
    public int x = 1;
    private static int y = 10;
    String str = "Test";

    public void m1() {
        System.out.println("Test m1");
    }

    private static void m2() {
        System.out.println("Test m2");
    }

    void str() {
        System.out.println("Test str");
    }

    static class InnerClass {
        private String str = "InnerClass";
        static int i = 10;

        void method() {
            // 外部類成員變數
            System.out.println(new Test().x);
            // 外部類靜態變數
            System.out.println(y);
            // 同名變數，優先呼叫內部類變數
            System.out.println(str);
            // 外部類同名變數
            System.out.println(new Test().str);
            // 外部類方法
            new Test().m1();
            // 外部類靜態方法
            m2();
            // 同名方法，優先呼叫內部類方法
            str();
            // 外部類同名方法
            new Test().str();
        }

        static void staticMethod() {
            // 同名變數，優先呼叫內部類變數
            System.out.println(new InnerClass().str);
            // 外部類同名變數
            System.out.println(new Test().str);
            // 同名方法，優先呼叫內部類方法
            new InnerClass().str();
            // 外部類同名方法
            new Test().str();
        }

        void str() {
            System.out.println("InnerClass str");
        }
    }

    public static void main(String[] args) {
        // 與成員內部類相比，無需建立外部類物件
        InnerClass inner = new InnerClass();
        // 呼叫內部類方法
        inner.method();
        // 呼叫內部類靜態方法
        InnerClass.staticMethod();
        // 呼叫內部類成員變數
        System.out.println(inner.str);
        // 呼叫內部類靜態成員變數
        System.out.println(InnerClass.i);
    }
}

1.4 區域性內部類

public class Test {
    public int x = 1;
    private static int y = 10;
    String str = "Test";

    public void m1() {
        System.out.println("Test m1");
    }

    private static void m2() {
        System.out.println("Test m2");
    }

    void str() {
        System.out.println("Test str");
    }

    public static void main(String[] args) {
        class InnerClass {
            private String str = "InnerClass";

            void method() {
                // 外部類成員變數
                System.out.println(new Test().x);
                // 外部類靜態變數
                System.out.println(y);
                // 同名變數，優先呼叫內部類變數
                System.out.println(str);
                // 外部類同名變數
                System.out.println(new Test().str);
                // 外部類方法
                new Test().m1();
                // 外部類靜態方法
                m2();
                // 同名方法，優先呼叫內部類方法
                str();
                // 外部類同名方法
                new Test().str();
            }

            void str() {
                System.out.println("InnerClass str");
            }
        }
        // 建立內部類物件
        InnerClass inner = new InnerClass();
        // 呼叫內部類方法
        inner.method();
        // 呼叫內部類成員變數
        System.out.println(inner.str);
    }
}

1.5 匿名內部類

沒有名稱的類，利用父類的建構函式和自身類體構造成一個類，其他地方不能引用，沒有構造器，不能例項化，只能使用一次

public class Test {
    int i = 10;

    One o1 = new One() {
        int i = 1;

        @Override
        void show() {
            System.out.println("o1 show");
        }
    };

    void say() {
        System.out.println("Test say");
    }

    public static void main(String[] args) {
        One o2 = new One() {
            @Override
            void show() {
                System.out.println("o2 show");
            }

            void say() {
                System.out.println("o2 say");
            }
        };
        // 定義在方法體外，則需要建立外部類物件
        Test test = new Test();
        // 呼叫內部類方法，o1重寫後的方法
        test.o1.show(); // o1 show
        // 呼叫內部類成員變數
        System.out.println(test.o1.i);  // 0

        // 定義在方法體內，可以直接使用
        o2.show();	// o2 show
        // 只能呼叫One中包含的方法及變數
        o2.say();   // 編譯錯誤
    }
}

class One {
    int i = 0;
    void show() {
        System.out.println("one show");
    }
}

1.6 小夥汁，你見過內部內部內部內部內部內部類嗎

public class Test {

    class InnerClass {
        class InnerInnerClass {
            class InnerInnerInnerClass {
                class InnerInnerInnerInnerClass {
                    class InnerInnerInnerInnerInnerClass {
                        class InnerInnerInnerInnerInnerInnerClass {
                            void show() {
                                System.out.println("內部內部內部內部內部內部類");
                            }
                        }
                    }
                }
            }
        }
    }


    public static void main(String[] args) {
        Test test = new Test();
        Test.InnerClass.InnerInnerClass.InnerInnerInnerClass.InnerInnerInnerInnerClass.InnerInnerInnerInnerInnerClass.InnerInnerInnerInnerInnerInnerClass inner = test.new InnerClass().new InnerInnerClass().new InnerInnerInnerClass().new InnerInnerInnerInnerClass().new InnerInnerInnerInnerInnerClass().new InnerInnerInnerInnerInnerInnerClass();
        inner.show();
    }
}

相關推薦

Java基礎--內部類

內部類 外部類 內部類 靜態內部類 區域性內部類 匿名內部類 package oop.demo10; public class Outer {

Java基礎——內部類

內部類 我們學習類與物件後，知道了類的定義和使用 也知道抽象類以及包裝器類的用法

Java基礎 -- 內部類

1、內部類 內部類是定義在一個類的內部的類，內部類 不能定義靜態變數和方法。介面內也可以使用內部類，但沒必要

java基礎[ 內部類 外部類 ]

一、概念 定義在一個類內部的類叫內部類，包含內部類的類稱為外部類。 內部類可以宣告public、protected、private等訪問限制，

Java基礎-內部類（1）

package com.hspedu.innerclass_; // 外部類(外部其他類) public class Course412 { public static void main(String[] args) {

Java基礎----內部類

內部類分為 1.成員內部類 2.靜態內部類 3.區域性內部類 4.匿名內部類　 內部類概念：在一個類的內部再定義一個類

java匿名內部類例項程式碼詳解

這篇文章主要介紹了java匿名內部類例項程式碼詳解,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java靜態內部類實現單例過程

這篇文章主要介紹了Java靜態內部類實現單例過程,文中通過示例程式碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Java匿名內部類

package com.qf.demo01; //1.定義一個介面，抽象類 interface A{ public void test();//抽象方法

java學習-內部類

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

java 靜態內部類

簡介 靜態內部類，就是內部類不需要this，也就是說內部類不需要引用外部類的時候使用。

為什麼Java匿名內部類訪問方法引數或者方法區域性變數需要用final來修飾

下面是摘自於https://www.cnblogs.com/z-sm/p/7058864.html 在外部類的方法內定義類（只能是匿名內部類），則該內部類的例項的生命週期有可能超過區域性變數的生命週期（此場景即所謂的閉包，在javascript等很多語言

Java匿名內部類的寫法示例

前言 在Java中呼叫某個方法時，如果該方法的引數是一個介面型別，除了可以傳入一個引數介面實現類，還可以使用匿名內部類實現介面來作為該方法的引數。

【Java】內部類

做題目時經常遇到，始終沒能完全搞清楚，這裡總結一下 內部分類： 成員內部類

Java-C#-內部類

Java code: public class Outer{ private int outerNum = 1; public int getOuterNum() { return outerNum; } public class Inner{

Java 匿名內部類

匿名內部類應該是平時我們編寫程式碼時用得最多的，在編寫事件監聽的程式碼時使用匿名內部類不但方便，而且使程式碼更加容易維護。

java靜態內部類理解

java靜態內部類的理解 需要了解2個概念：內部類和靜態修飾符static1）首先，用內部類是因為內部類與所在外部類有一定的關係，往往只有該外部類呼叫此內部類。所以沒有必要專門用一個Java檔案存放這個類。2）靜態

Java的內部類與常用類

內部類 1. 概念：在一個類內再定義一個完整的類。 2. 特點：①編譯後可以生成獨立的位元組碼檔案。②內部類可直接訪問外部類的私有成員，而不破壞封裝性。③可為外部類提供必要的內部功能條件。

JAVA面試——內部類

技術標籤：JAVA 定義在類內部的類稱為內部類。內部類根據不同的定義方式，可分為靜態內部類/成員內部類/區域性內部類和匿名內部類。

Java：內部類

內部類：在Java中，一個類中可以再定義一個類，前者稱為外部類，後者稱為內部類。分為成員內部類、靜態內部類、區域性內部類、匿名內部類。一般用在定義它的類或語句塊之內，在外部引用它時必須給出完整的名稱，