內部類

• 概念：在一個類的內部再定義一個完整的類。
• 特點：
  • 編譯之後可生成獨立的位元組碼檔案。（內部類會生成class檔案）
  • 內部類可直接訪問外部類的私有成員，而不破壞封裝。
  • 可為外部類提供必要的內部功能元件。

package com.standardClass.demo01;
//身體
public class Body {
    public String name;

    //頭部
    class Header{

        public void show(){
            System.out.println(name);
        }
    }
}
 

成員內部類

• 在類的內部定義，與例項變數、例項方法同級別的類。
• 外部類的一個例項部分，建立內部類物件的時，必須依賴外部類物件。
  • Outer outer = new Outer();
  • Inner inner = outer.new Inner();
• 當外部類、內部類存在重名屬性時，會優先訪問內部類屬性。
• 成員內部類不能定義靜態成員。

package com.standardClass.demo01;
//外部類
public class Outer {
    //例項變數
    private String name = "張三";
    private int age = 20;

    //內部類
    class Inner{
        private String address = "北京";
        private String phone = "110";
        //屬性和外部類屬性名字相同，加Outer.this.可訪問外部類
        private String name = "李四";

        private static final String country = "中國";//成員內部類不能定義靜態成員。但可以包含靜態常量。

        //方法
        public void show(){
            //列印外部類中的屬性（內部屬性和外部類屬性名字相同，加Outer.this.可訪問外部類）
            System.out.println(Outer.this.name);

            System.out.println(Outer.this.age);//也可以加 Outer.this. 顯得目的更加明確
            //列印內部類中的屬性
            System.out.println(this.address);
            System.out.println(phone);
        }
    }
}
 

package com.standardClass.demo01;

import com.standardClass.demo01.Outer.Inner;

public class TestOuter {
    public static void main(String[] args) {
        //1建立外部類物件
//        Outer outer = new Outer();
//        //2建立內部類物件
//        Inner inner = outer.new Inner();

        //一步到位
        Inner inner = new Outer().new Inner();

        inner.show();
    }
}
 

靜態內部類

（相當於在成員內部類的基礎上加了一個static關鍵字）

• 不依賴外部類物件，可直接建立或通過類名訪問，可宣告靜態成員。（相當於一個外部類）
• 只能直接訪問外部類的靜態成員（例項成員需例項化外部類物件）
  • Outer.Inner inner = new Outer.Inner();
  • Outer.inner.show();

package com.standardClass.demo02;

//外部類
public class Outer {
    private String name = "xxx";
    private int age = 18;

    //靜態內部類：和外部類相同
    static class Inner{
        private String address = "上海";
        private String phone = "111";
        //靜態成員
        private static int count = 1000;

        public void show(){
            //如何呼叫外部類的屬性呢
            //1.先建立外部類物件
            Outer outer = new Outer();
            //2.呼叫外部類物件的屬性
            System.out.println(outer.name);
            System.out.println(outer.age);
            //呼叫靜態內部類的屬性和方法
            System.out.println(address);
            System.out.println(phone);
            //呼叫靜態內部類的靜態屬性
            System.out.println(Inner.count);
        }
    }

}

package com.standardClass.demo02;

public class TestOuter {
    public static void main(String[] args) {
        //直接建立靜態內部類物件
        Outer.Inner inner = new Outer.Inner();
        //呼叫方法
        inner.show();
    }
}

區域性內部類

• 定義在外部類方法中，作用範圍和建立物件範圍僅限於當前方法。
• 區域性內部類訪問外部類當前方法中的區域性變數時，因無法保障變數的生命週期與自身相同，變數必須修飾為final
• 限制類的使用範圍

package com.standardClass.demo03;

//外部類
public class Outer {
    private String name = "劉德華";
    private int age = 35;

    public void show(){
        //定義區域性變數
        final String address = "深圳";

        //區域性內部類：注意不能加任何訪問修飾符
        class Inner{
            //區域性內部類的屬性
            private String phone = "1558888888";
            private String email = "[email protected]";
            //private final static int count = 2000;

            public void show2(){
                //訪問外部類的屬性
                System.out.println(Outer.this.name);
                System.out.println(age);
                //訪問內部類的屬性
                System.out.println(this.phone);
                System.out.println(email);
                //訪問區域性變數，jdk1.7要求：變數必須是常量final，jdk1.8自動新增final
                System.out.println(address);
            }
        }
        //建立區域性內部類物件
        Inner inner = new Inner();
        inner.show2();
    }
}

package com.standardClass.demo03;

public class TestOuter {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}

匿名內部類

• 沒有類名的區域性內部類（一切特徵都與區域性內部類相同）
• 必須繼承一個父類或者實現一個介面
• 定義類、實現類、建立物件的語法合併，只能建立一個該類的物件
• 優點：減少程式碼量
• 缺點：可讀性較差

package com.standardClass.demo04;
//介面
public interface Usb {
    //服務
    void service();
}

package com.standardClass.demo04;

public class Mouse implements Usb{
    @Override
    public void service() {

        System.out.println("連線電腦成功，滑鼠開始工作了…");
    }
}

package com.standardClass.demo04;

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();

    }
}

筆記出處