什麼是 Java 中的內部類
問：什麼是內部類呢？
答：內部類（ Inner Class ）就是定義在另外一個類裡面的類。與之對應，包含內部類的類被稱為外部類。
問：那為什麼要將一個類定義在另一個類裡面呢？清清爽爽的獨立的一個類多好啊！！
答：內部類的主要作用如下：
1. 內部類提供了更好的封裝，可以把內部類隱藏在外部類之內，不允許同一個包中的其他類訪問該類
2. 內部類的方法可以直接訪問外部類的所有資料，包括私有的資料
3. 內部類所實現的功能使用外部類同樣可以實現，只是有時使用內部類更方便，重寫外部類的方法
問：內部類有幾種呢？
答：內部類可分為以下幾種：
1. 成員內部類
2. 靜態內部類
3. 方法內部類
4. 匿名內部類

下面是一個內部類例子

//外部類HelloWorld
public class HelloWorld {

    // 內部類Inner，類Inner在類HelloWorld的內部
    public class Inner {

        // 內部類的方法
        public void show() {
            System.out.println("welcome to imooc!");
        }
    }

    public static void main(String[] args) {

        // 建立外部類物件
        HelloWorld hello = new
 
 HelloWorld();
        // 建立內部類物件
        Inner i = hello.new Inner();
        // 呼叫內部類物件的方法
        i.show();
    }
}

匿名內部類:
是不能有名稱的類，所以沒辦法引用它們。必須在建立時，作為new語句的一部分來宣告它們。這就要採用另一種形式的new語句，如下所示： new <類或介面> <類的主體>
作用是：
1.和內部類一樣，可以對外部類進行擴充套件，重寫或新增加方法。
2.用於實現介面
3.沒有類名

//新建一個介面
public interface
 
 Animal {
    void eat();

    void sleep();
}

//新建一個類，在類裡面使用 內部類和內部匿名類去實現介面
public class Zoo {
    private class Tiger implements Animal {
        public void eat() {
            System.out.println("tiger eat");
        }

        public void sleep() {
            System.out.println("tiger sleep");
        }
    }

    /**
     *  這裡不明白，Animal不是介面麼，怎麼可以定義方法？
     *  ---答案 介面可以作為返回型別,指定返回的型別必須是實現當前介面的類.
     * @return
     */

    /**
     * // 由於介面不是不能例項化的，所以必須通過類來實現，這裡使用返回一個（已實現該介面的物件）
     * 具體寫法有兩種，寫法2容易理解
     * @return
     */
    //---------------------------寫法1-----匿名內部類--------------------------------
    Animal getAnimal1(){
        return new Animal(){
            public void eat() {
                System.out.println("---1---animal eat");
            }

            public void sleep() {
                System.out.println("---1---animal sleep");
            }
        };
    }


    //---------------------------寫法2------內部類--------------------------
    Animal getAnimal2(){
        return new TempAnimal();
    }

    class TempAnimal implements Animal{
        int a = 0;
        public void eat() {
            System.out.println("---2---animal eat");
        }

        public void sleep() {
            System.out.println("---2---animal sleep");
        }   
    }

}

//新建一個測試類
public class Test {
    public static void main(String[] args) {
        Zoo z = new Zoo();
        Animal an = z.getAnimal1();
        an.eat();
        an.sleep();


        Animal one = z.getAnimal2();
        one.eat();
        one.sleep();
    }
}

匿名內部類是內部類的一種簡化寫法：return new Wrapper{...};等價於：Wrapped extends Wrapper{...}return new Wrapped();難道匿名內部類就只這一點作用嗎？考慮一下這樣的case:

interface ICount {
    int count();
}

class Parent {
    int i = 0;

    int count() {
        return i++;
    }
}
有一個類Child，它既想繼承Parent的count()方法，又想實現ICount介面中的count方法，這個時候怎麼辦呢？內部類就可以大顯身手了：

class Child extends Parent {
    ICount getCount() {
        return new ICount {
            int i = 0;

        int count() {
            return (i *= 2);
        }
    }
}