深入瞭解Java內部類的用法

Posted on by

1.內部類分類和概念

java類的五大成員：屬性，方法，構造器（構造方法），代碼塊，內部類

內部類的分類：

定義在外部類局部的位置（比如方法內）：

  • 局部內部類（有類名）
  • 匿名內部類（無類名）

定義在外部類成員位置上：

  • 成員內部類（沒有static修飾）
  • 靜態內部類（有static修飾）

概念：在一個類的內部再定義一個完整的類，也會生成一個class文件

代碼示例：

/**
 * 內部類
 */
public class InnerClass {
    private int n = 521;

    public InnerClass(int n) {
        this.n = n;
    }

    class Inner { // 內部類

    }
}

謹記：內部類很重要，java底層源碼內部類使用場景很多！

2.局部內部類

class Outer001 { // 外部類
    private int n = 521;
    private void kaka() {
        System.out.println("我是外部類的方法！");
    }
    public void show() {
        // 局部內部類定義在外部類的局部位置，通常在方法中
        class Inner001 {
            // 局部內部類
            public void f() {
                // 可以直接訪問外部類的所有成員，包含私有的
                System.out.println(n);
            }
        }
    }
}

不能添加訪問修飾符，但是可以添加final

局部內部類的作用域隻在定義它的方法或者代碼塊中

外部類使用內部類的方法，直接new即可：

public void show() {
    // 局部內部類定義在外部類的局部位置，通常在方法中
    final class Inner001 {
        // 局部內部類
        public void f() {
            // 可以直接訪問外部類的所有成員，包含私有的
            System.out.println(n);
            kaka();
        }
    }
    // 外部類使用內部類的方法
    Inner001 inner001 = new Inner001();
    inner001.f();
}

外部其他類不能訪問局部內部類！

外部類和局部內部類的成員重名時，默認遵循就近原則，如果想要訪問外部類的成員，使用外部類名.this.成員進行訪問

3.匿名內部類（重要）

匿名內部類其實有名字，它的名字是底層的JDK給分配的~系統分配該類名的時候會在外部類的基礎上加上$1，存在多個內部類的，$後面的值進行遞增

基於接口的匿名內部類

/**
 * 匿名內部類
 */
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Outer002 outer002 = new Outer002();
        outer002.method();
    }
}

class Outer002 {
    private int n = 521;

    public void method() {
        // 基於接口的匿名內部類
        // tiger的編譯類型是IA，運行類型就是匿名內部類！
        // 系統分配該類名的時候會在外部類的基礎上加上$1，此處是Outer002$1
        // JDK底層在創建瞭匿名內部類之後，立即創建瞭一個實例，並且把地址返回給tiger
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("我是一隻小老虎🐅");
            }
        };
        tiger.cry();
        System.out.println(tiger.getClass());
    }
}

interface IA {
    public void cry();
}

輸出：

我是一隻小老虎🐅
class seniorobject.innerclass.Outer002$1

註意：匿名內部類使用一次就不能再使用瞭！

基於類的匿名內部類

基於類的匿名內部類和基於接口的差不太多

Father類：

class Father {
    private String name;

    public Father(String name) {
        this.name = name;
    }
    public void test() {

    }
}

匿名內部類：

// 基於類的匿名內部類，加入大括號就搖身一變變成內部類瞭
Father jack = new Father("jack"){
    @Override
    public void test() {
        super.test();
        System.out.println("♪(^∇^*)");
    }
};
System.out.println(jack.getClass());

輸出：

class seniorobject.innerclass.Outer002$2

一些細節

匿名內部類是類，同時，它也可以理解為是一個對象

匿名內部類可以訪問外部類的所有成員，包括私有的

不能添加訪問修飾符

定義域在定義它的方法或者代碼塊中，轉瞬即逝！

外部其他類不能訪問匿名內部類

外部類和匿名內部類成員重名時，參照局部內部類的方式即可

匿名內部類的最佳實踐

當作實參直接傳遞，簡潔高效

/**
 * 匿名內部類的最佳實踐
 * 當作實參直接傳遞，簡潔高效
 */
public class AnonymousInnerClassPractice {
    public static void main(String[] args) {
        f(new IL() {
            @Override
            public void show() {
                System.out.println("你好啊");
            }
        });
    }

    public static void f(IL il) {
        il.show();
    }
}

interface IL {
    void show();
}

4.成員內部類

定義在外部類的成員位置上：

實例：

/**
 * 成員內部類
 */
public class MemberInnerClass {
    public static void main(String[] args) {
        Outer003 outer003 = new Outer003();
        outer003.t();
    }
}

class Outer003 {
    private int n = 521;
    public String name = "dahe";

    class Inner003 { // 成員內部類
        public void say() {
            System.out.println(n + name);
        }
    }

    public void t() {
        // 使用成員內部類
        Inner003 inner003 = new Inner003();
        inner003.say();
    }
}

輸出：

521dahe

可以訪問外部類的所有成員，包括私有的

可以添加任意的訪問修飾符

作用域為整個類體中

外部類想要使用成員內部類，創建對象調用即可！

外部其他類想要訪問成員內部類，存在兩種方式：

// 直接創建對象
Outer003.Inner003 inner003 = outer003.new Inner003();
// 註意：這裡的outer003是外部類的對象實例

// 成員內部類的外部類創建一個返回內部類對象的公有方法
public Inner003 getInner003Instance() {
    return new Inner003();
}

// 外部其他類進行調用該共有方法
Outer003.Inner003 inner0031 = outer003.getInner003Instance();
inner0031.say();

外部類和成員內部類的成員重名時，參考局部內部類和匿名內部類即可

5.靜態內部類

可以直接訪問外部類的靜態成員

可以添加任意的訪問修飾符

作用域為整個類體

外部類想要訪問靜態內部類依然是創建對象訪問

外部其他類想要訪問靜態內部類：

// 通過類名直接訪問
Outer004.Inner004 inner004 = new Outer004.Inner004();
inner004.say();

// 靜態內部類的外部類創建一個返回內部類對象的公有方法
// 返回靜態內部類的對象實例
public Inner004 getInner004() {
    return new Inner004();
}

Outer004.Inner004 inner0041 = outer004.getInner004();
inner0041.say();

// 返回靜態內部類的對象實例，但是是靜態方法
public static Inner004 getInner004_() {
    return new Inner004();
}

// 靜態內部類的外部類創建一個返回內部類對象的公有靜態方法
Outer004.Inner004 inner0042 = Outer004.getInner004_();
inner0042.say();

整體代碼示例：

/**
 * 靜態內部類
 */
public class StaticInnerClass {
    public static void main(String[] args) {
        Outer004 outer004 = new Outer004();
        // 通過類名直接訪問
        Outer004.Inner004 inner004 = new Outer004.Inner004();
        inner004.say();
        // 靜態內部類的外部類創建一個返回內部類對象的公有方法
        Outer004.Inner004 inner0041 = outer004.getInner004();
        inner0041.say();
        // 靜態內部類的外部類創建一個返回內部類對象的公有靜態方法
        Outer004.Inner004 inner0042 = Outer004.getInner004_();
        inner0042.say();
    }
}

class Outer004 {
    private int n = 521;
    private static String name = "dahe";
    public static class Inner004 {
        public void say() {
            // 可以直接訪問外部類的靜態成員
            System.out.println(name);
        }
    }

    // 返回靜態內部類的對象實例
    public Inner004 getInner004() {
        return new Inner004();
    }

    // 返回靜態內部類的對象實例，但是是靜態方法
    public static Inner004 getInner004_() {
        return new Inner004();
    }
}

外部類和成員內部類的成員重名時，遵循就近原則，如果想要訪問外部類的成員，使用外部類名.成員即可

以上就是深入瞭解Java內部類的用法的詳細內容，更多關於Java內部類的資料請關註WalkonNet其它相關文章！

推薦閱讀：