內部類就是在一個類的內部再定義一個類，如A類中定義一個B類，那麼B類相對於A類來說就是內部類，A類相對於B類來說就是外部類

1.（成員）內部類

（1）成員內部類可以獲得外部類的私有屬性和方法

（2）注意如何建立內部類，先建立外部類，在此基礎上再建立內部類

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("這是外部類的方法");
    }
    public class Inner{
        public void in(){
            System.out.println(
 
"這是內部類的方法");
        }
        //獲得外部類的私有屬性或方法
        public void getID(){
            System.out.println(id);
            out();
        }
    }
}
class Test {
    public static void main(String[] args) {
        Outer outer=new Outer();
        Outer.Inner inner=outer.new Inner();
        inner.in();
 
//這是內部類的方法
        inner.getID();//10
    }
}

（3）可以定義內部介面，且可以定義另外一個內部類實現這個內部介面

public class Outer06 {
    public interface Fly{
        void fly();
    }
    public class Inner06 implements Fly{
        @Override
        public void fly() {
            System.out.println("fly");
        }
    }
    public
 
 static void main(String[] args) {
        Outer06 outer06=new Outer06();
        Outer06.Inner06 inner06=outer06.new Inner06();
        inner06.fly();//fly
    }
}

（4）內部類不能定義static元素

public class Outer {
    public class Inner{
        public static void in(){//報錯，不能使用static
            System.out.println("這是內部類的方法");
        }
    }
}

 （5）內部類可以多巢狀

public class Outer05 {
    public class Inner{
        public class In{
            
        }
    }
}
class TestOuter05{
    public static void main(String[] args) {
        Outer05 out =new Outer05();
        Outer05.Inner inner =out.new Inner();
        Outer05.Inner.In in =inner.new In();
    }
}

2.靜態內部類

（1）靜態內部類無法呼叫外部類非靜態的屬性

public class Outer1 {
    private int id=10;
    public void out(){
        System.out.println("這是外部類的靜態方法");
    }
    public static void out1(){
        System.out.println("這是外部類的靜態方法");
    }
    public static class Inner1{//靜態內部類無法呼叫外部類中非靜態的屬性和方法
        public void in(){
            System.out.println("這是靜態外部類的方法");
            out();//報錯
            out1();
        }
    }
}

（2）static內部類具備所有外部類的特性，注意建立靜態內部類的方法

public class Outer02 {
    public static class Inner2{
        public static void run(){//可以定義static方法
            System.out.println("run");
        }
        public void run1(){
            System.out.println("run1");
        }
    }
}
class Test {
    public static void main(String[] args) {
        Outer02.Inner2 inner1=new Outer02.Inner2();//特別注意
        inner1.run1();
        inner1.run();
    }
}

3.區域性內部類

在類的方法中定義類

public class Outer03 {
    public void method(){
        class Inner3{
            public void in3(){
                System.out.println("這是區域性內部類");
            }
        }
    }
}

4.匿名內部類

public class Outer04 {
    public static void main(String[] args) {
        //沒有名字初始化類，不用將十里儲存到變數中
        new A().eat();
        //new B()匿名內部類可以new介面
        B b=new B(){
            @Override
            public void speak() {
                System.out.println("speak");
            }
        };
        b.speak();
    }
}
class A{
    public void eat(){
        System.out.println("eat");
    }
}
interface B{
    void speak();
}