一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class);类的五大成员：属性、方法、构造器、代码块、内部类

class Outer{  // 外部类
    class Inner{} // 内部类
}

1. 内部类的分布

• 定义在外部类局部位置上(比如方法上)：
  1. 局部内部类(有类名)
  2. 匿名内部类(没有内部类)
• 定义在外部类的成员位置上
  1. 成员内部类(没有static修饰)
  2. 静态内部类(使用static修饰)

2. 局部内部类

class Outer{
    private int anInt1 = 100;
    private void m2(){
        System.out.println("m2>>>");
    }
    public void m1(){
        // 1.局部内部类是定义在外部类的局部位置，通常是在方法
        // 3.不能添加访问修饰符，但是可以使用final修饰，修饰后不能被继承
        // 4.作用域：仅仅在定义它的方法或代码块中
       final class inner{
            public void f1(){
                // 2. 可以直接访问外部类的所有成员，包含私有的
                System.out.println("n1=" + anInt1); 
                m2();
            }
       }
       // 5. 外部类访问局部类的成员：创建对象，在访问
       inner inner = new inner();
       inner.f1();
       // class inner2 extends inner{}
    }
}

3. 匿名内部类

public class AnonymousInnerClass {
    public static void main(String[] args) {
        Inner02 inner02 = new Inner02();
        inner02.method();
    }
}
// 接口类型的匿名内部类
interface IA{
    public void cry();
}
class Inner02{
    public void method(){
        IA tiger = new IA(){
            @Override
            public void cry() {
                System.out.println("老虎叫");
            }
        };
        tiger.cry();
    }
}

4. 成员内部类

public class MeberInnerClass {
    public static void main(String[] args) {
        Outer03 outer03 =  new Outer03();
        Outer03.Inner07 inner07 = outer03.getInner07();  // 其他对象访问内部类
        inner07.say();
    }
}
class Outer03{
    private int n1 = 200;
    public String name = "张三";
    public class Inner07{  // 成员内部类
        private double sal = 99.8;
        public void say(){
            System.out.println("n1 = " + n1 + "name = " + name);
        }
    }
    // 本类访问内部类的方法
    public void say(){
        Inner07 inner07 = new Inner07();
        inner07.say();
        System.out.println(inner07.sal);
    }

    public Inner07 getInner07(){
        return new Inner07();
    }
}

5.静态内部类

class Outer10{
    private int n1 = 10;
    private static String name = "张三";
    public static class Inner10{
        public void say(){
//            System.out.println(n1);  不能访问非静态成员
            System.out.println(name); // 张三   可以直接访问外部的所有静态成员
        }
    }
    public void m1(){
        Inner10 inner10 = new Inner10();
        inner10.say();
    }
}