內部類一般來說包括這四種：成員內部類、區域性內部類、匿名內部類和靜態內部類

1.成員內部類（定義在類中的類叫成員內部類）

（1）成員內部類
public class DemolInnerClass {
    public static void main(String[] args) {
        //外部類名.內部類名 變數名= 外部類物件.內部類物件
        Outer.InnerClass oi = new Outer().new InnerClass();//外部類要訪問內部類的成員，必須建立物件。
        oi.getNumber();
    }
}


class Outer{
    /*public*/private int number = 10;//定義在類中的變數叫成員變數
    class InnerClass{//定義在類中的類叫做成員內部類
        public void getNumber(){
            System.out.println(number);//成員內部類可以直接訪問外部類的成員，包括私有
        }
    }
}
 

執行的結果：10

（2）成員內部類用private修飾，私有成員內部類

public class Demol2InnerClass {
    public static void main(String[] args) {
     OuterPrivate op = new OuterPrivate();
     op.getInnerPrivate();
    }
}

class OuterPrivate{
    private  int number = 10;
    private class InnerPrivate{ //成員內部類私有使用（private）
        public void  getNumber(){
            System.out.println(number);
        }
    }
 public void  getInnerPrivate(){//只能在外部類中建立內部物件進行訪問
     InnerPrivate ip = new InnerPrivate();
     ip.getNumber();
 }

}
 

2.區域性內部類

public class Demol3InnerClass {
    public static void main(String[] args) {
        OuterLocal outerLocal = new OuterLocal();
        outerLocal.LocalMethod();
    }
}
/* 區域性內部類：在方法中定義的內部類
 * 區域性內部類在訪問他所在方法中的區域性變數必須用final修飾,為什麼?
       因為當呼叫這個方法時,區域性變數如果沒有用final修飾,他的生命週期和方法的生命週期是一樣的,
       當方法彈棧,這個區域性變數也會消失,那麼如果區域性內部類物件還沒有馬上消失想用這個區域性變數,
       就沒有了,如果用final修飾會在類載入的時候進入常量池,即使方法彈棧,常量池的常量還在,
       也可以繼續使用
*/
class OuterLocal{
    public void LocalMethod(){

       class LocalInner{//區域性內部類:定義在成員方法中的類
           final int number = 10;
           public void getNumber(){
               System.out.println(number);
           }
       }
       LocalInner localInner = new LocalInner();
       localInner.getNumber();

    }
    /*public void run() {
        LocalInner localInner = new LocalInner();  //區域性內部類,只能在其所在的方法中訪問
        localInner.getNumber();
   }*/

}
 

3.靜態成員內部類，

public class Demol4InnerClass {
    public static void main(String[] args) {
        //外部類名.內部類名 物件名 = 外部類名.內部類物件;
        OuterStatic.Inner1 oi = new OuterStatic.Inner1();
        oi.method();
        OuterStatic.Inner2.print();
    }
    
}
class OuterStatic{
    static class Inner1{//靜態成員內部類:成員內部類被靜態修飾的類
        public void method() {
            System.out.println("method");
        }
    }
    
    static class Inner2{
        public static void print() {
            System.out.println("print");
        }
    }
}

4.匿名內部類，就是沒有名字的內部類

public class Demo1_NoNameInnerClass {
    public static void main(String[] args) {
        Outer1 outer1 = new Outer1();
        outer1.method();
    }
}
/* A:匿名內部類
   * 就是內部類的簡化寫法。
* B:前提：存在一個類或者介面
   * 這裡的類可以是具體類也可以是抽象類。
* C:格式：
      new 類名或者介面名(){
         重寫方法;
      }
* D:本質是什麼呢?
   * 是一個繼承了該類或者實現了該介面的子類匿名物件。
*/
interface InnerInterface{
    public void print();
}
class Outer1{
    /*abstract*/ class Inner implements InnerInterface{
        public void print() {
            System.out.println("print");
        }
    }

    public void method(){
//        Inner i = new Inner();
//        i.print();
//        new Inner().print();//建立InnerInterface的子類Inner
//        InnerInterface i1 = new Inner();       //父類引用指向子類物件

//        上面的內部類可以用匿名內部類來實現
        new Inner(){
            public void print() {
                System.out.println("print");
            }
        }.print();
    }
}