摘要：要注意的是，成員內部類不能含有的變量和方法。匿名內部類是唯一一種沒有構造器的類。靜態嵌套類又叫靜態局部類嵌套內部類，就是修飾為的內部類。以上是對內部類的一些學習和總結，紕漏之處希望各位小伙伴友情指點，共同進步。

內部類（inner class）是定義在另一個類中的類，類名不需要和文件夾相同。但為什么要使用內部類呢？其主要原因有以下三點：
　　1.內部類方法可以訪問該類定義所在的作用域中的數據，包括私有數據。
　　2.內部類可以對同一個包中的其他類隱藏起來。
　　3.當想要定義一個回調函數且不想編寫大量代碼時，使用匿名內部類比較便捷。
內部類可以分為以下幾種：成員內部類、局部內部類、匿名內部類和靜態嵌套類。

1.成員內部類

成員內部類是最普通的內部類，它的定義為位于另一個類的內部，形如下面的形式：

class Outter {
    private int age = 12;
    class Inner {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部變量：" + age);
            System.out.println("內部類變量：" + this.age);
            System.out.println("外部類變量：" + Out.this.age);
        }
    }
}
public class test {
    public static void main(String[] args) {
        Outter out = new Outter();
        Outter.Inner in = out.new Inner();
        in.print();
    }
}

運行結果如下：

局部變量：14
內部類變量：13
外部類變量：12

從本例可以看出：成員內部類，就是作為外部類的成員，可以直接使用外部類的所有成員和方法， 即使是private的 。雖然成員內部類可以無條件地訪問外部類的成員，而外部類想訪問成員內部類的成員卻不是這么隨心所欲了。在外部類中如果要訪問成員內部類的成員，必須先創建一個成員內部類的對象，再通過指向這個對象的引用來訪問：

class Outter {
    private int age = 12;
    public Outter(int age) {
        this.age = age;
        getInInstance().print();   //必須先創建成員內部類的對象，再進行訪問!
    }
    private Inner getInInstance() {
        return new Inner();
    } 
    class Inner {
        public void print() {
            System.out.println("內部類沒同名，所以直接調用外部類成員變量：" + age);
        }
    }
}
public class test {
    public static void main(String[] args) {
        Outter out = new Outter(10);
    }
}

運行結果：

內部類沒有同名，所以直接調用外部類成員變量：10
內部類可以擁有private訪問權限、protected訪問權限、public訪問權限及包訪問權限。
比如上面的例子，如果成員內部類Inner用private修飾，則只能在外部類的內部訪問，如果用public修飾，則任何地方都能訪問；如果用protected修飾，則只能在同一個包下或者繼承外部類的情況下訪問；如果是默認訪問權限，則只能在同一個包下訪問。
這一點和外部類有一點不一樣， 外部類只能被public和包訪問兩種權限修飾 。
由于成員內部類看起來像是外部類的一個成員，所以可以像類的成員一樣擁有多種權限修飾。要注意的是，成員內部類不能含有static的變量和方法。因為成員內部類需要先創建了外部類，才能創建它自己的。

2.局部內部類

局部內部類是定義在一個方法或者一個作用域里面的類，它和成員內部類的區別在于局部內部類的訪問僅限于方法內或者該作用域內。

定義在方法里的內部類：

class Outter {
    private int age = 12;
        public void Print(final int x) {    //這里局部變量x必須設置為final類型！
            class Inner {
                public void inPrint() {
                    System.out.println(x);
                    System.out.println(age);
                }
            }
            new Inner().inPrint();
        }
}
public class test {
    public static void main(String[] args) {
        Outter out = new Outter();
        out.Print(10);
    }
}

運行結果：

10
12

本例中我們將內部類移到了外部類的方法中，然后在外部類的方法中再生成一個內部類對象去調用內部類方法。如果此時我們需要往外部類的方法中傳入參數，那么外部類的方法形參必須使用 final定義。
換句話說，在方法中定義的內部類只能訪問方法中final類型的局部變量，這是因為在方法中定義的局部變量相當于一個常量，它的生命周期超出方法運行的生命周期，由于局部變量被設置為final，所以不能在內部類中改變局部變量的值。
定義在作用域內的內部類：

class Outter {
　　private int age = 12;
　　public void Print(final boolean x) {    //這里局部變量x必須設置為final類型！
        if(x){
             class Inner {
                 public void inPrint() {
                     System.out.println(age);
                 }
             }
             new Inner().inPrint();
        }       
    }
}
public class test1 {
    public static void main(String[] args) {
        Outter out = new Outter();
        out.Print(true);
    }
}

運行結果： 12

3.匿名內部類

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

scan_bt.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
    }
});
history_bt.setOnClickListener(new OnClickListener() {       
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
    }
});

這段代碼為兩個按鈕設置監聽器，這里面就使用了匿名內部類。具體位置是這段：

new OnClickListener() {   
    @Override
        public void onClick(View v) {
            // TODO Auto-generated method stub
        }
    }

代碼中需要給按鈕設置監聽器對象，使用匿名內部類能夠在實現父類或者接口中的方法情況下同時產生一個相應的對象，但是前提是這個父類或者接口必須先存在才能這樣使用。當然像下面這種寫法也是可以的，跟上面使用匿名內部類達到效果相同：

private void setListener(){
    scan_bt.setOnClickListener(new Listener1());       
    history_bt.setOnClickListener(new Listener2());
}
class Listener1 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
    }
}
class Listener2 implements View.OnClickListener{
    @Override
    public void onClick(View v) {
    // TODO Auto-generated method stub
    }
}

這種寫法雖然能達到一樣的效果，但是既冗長又難以維護，所以一般使用匿名內部類的方法來編寫事件監聽代碼。同樣的，匿名內部類也是不能有訪問修飾符和static修飾符的。
匿名內部類是唯一一種沒有構造器的類。正因為其沒有構造器，所以匿名內部類的使用范圍非常有限，大部分匿名內部類用于接口回調。匿名內部類在編譯的時候由系統自動起名為Outter$1.class。一般來說，匿名內部類用于繼承其他類或是實現接口，并不需要增加額外的方法，只是對繼承方法的實現或是重寫。

4.靜態嵌套類

又叫靜態局部類、嵌套內部類，就是修飾為static的內部類。聲明為static的內部類，不需要內部類對象和外部類對象之間的聯系，就是說我們可以直接引用outer.inner，即不需要創建外部類，也不需要創建內部類。

class Outter {
    private static int age = 12;
    static class Inner {
        public void print() {
            System.out.println(age);
        }
    }
}
public class test {
    public static void main(String[] args) {
        Outter.Inner in = new Outter.Inner();
        in.print();
    }
}

運行結果：

12

可以看到，如果用static將內部內靜態化，那么內部類就只能訪問外部類的靜態成員變量，具有局限性。
其次，因為內部類被靜態化，因此Outter.Inner可以當做一個整體看，可以直接new 出內部類的對象（通過類名訪問static，生不生成外部類對象都沒關系）。

以上是對Java內部類的一些學習和總結，紕漏之處希望各位小伙伴友情指點，共同進步。