内部类：成员内部类，局部内部类，静态内部类，匿名内部类

    public class OuterClass {

        private String name = "123";
        private int  age = 20;
        private static char sex ='女';




    /**
     * 成员内部类
     *  1.可以无限制访问外部成员，包括私有的和静态的
     *  2.内部类不能含有static的变量或方法；因为含有static修饰的变量或成员在类加载的时候初始化，此时还没有外部类
     *      有static修饰的变量或方法只能放在静态内部类中
     *  3.外部类访问内部类的成员和方法
     *      外部类名.成员内部类名  对象名 = new 外部类名().new 内部类名();
     *      对象名.成员
     *  4.外部类无法访问内部类的私有属性或方法
     *  5.当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员。
     *      如果要在内部类中访问外部类的同名成员，需要以下面的形式进行访问
     *          外部类.this.成员变量
     *          外部类.this.成员方法
     *  练习：
     *  1. 创建一个外部类，含有一个成员变量age=30;
     *  2. 创建一个内部类，含有一个内部成员变量age=20；
     *  3. 在内部类里创建一个方法，里面有一个局部变量age=10，在这个方法里分别打印值不同的三个age
     *  4. 在main方法中，调用内部类的方法
     *  
     */
        class InnerClass{
            private char sex ='男';
            private int age = 30;
            public void print(){
                int age = 10;
                System.out.println(name);
                System.out.println(OuterClass.this.sex);

                System.out.println(age);
                System.out.println(this.age);
                System.out.println(OuterClass.this.age);
            }

        }


    /**
     * 2.局部内部类
     *  局部内部类，是定义在一个方法或者一个作用域里面的类
     *  局部内部类不能被public、protected、private以及static修饰符的。他的作用域被限定在声明这个局部类的块中
     *  除了method方法，没有任何方法知道此类的存在
     */
        public void method(){

            int a = 10;

            class InnerClass2{
                public void print(){
                    System.out.println("哈哈哈");
                }
            }

            InnerClass2 inner = new InnerClass2();
            inner.print();
        }

        {
            class InnerClass2{

            }

        }


    /**
     * 3.静态（嵌套）内部类
     * a.成员内部类前加上了static修饰，它不能使用外部类的非static成员变量或者方法
     * b.外部类调用该内部类的成员
     *      调用静态成员：外部类名.内部类名.静态成员
     *      调用非静态成员：new 外部类名.内部类名().非静态成员
     *  int age = OutClass1.StaticInnerClass.b;//不需要创建外部类，也不需要创建内部类
        int age1 = new OutClass1.StaticInnerClass().a;//调用静态内部类的非静态方法
     *
     */
        static class InnerClass3{

            static int i = 100;
            String j = "你好";

            public void print(){
                System.out.println(sex);
            }

        }
        public void method2(){
            System.out.println(OuterClass.InnerClass3.i);
            System.out.println(new OuterClass.InnerClass3().j);

        }



        public static void main(String[] args) {
            OuterClass.InnerClass oi = new OuterClass().new InnerClass();
            System.out.println(oi.sex);
            oi.print();
            //System.out.println(OuterClass.this.sex);

            OuterClass out = new OuterClass();
            out.method();
            out.method2();
        }


    }

/**
 * 4. 匿名内部类
 * 匿名内部类也就是没有名字的内部类正因为没有名字，所以匿名内部类只能使用一次，
 * 它通常用来简化代码编写，但使用匿名内部类还有个前提条件：
 * 必须继承一个父类或实现一个接口，但最多只能继承一个父类，或实现一个接口。
 * 匿名内部类不能有构造方法。 
 * 匿名内部类不能定义任何静态成员、方法和类。 
 * 匿名内部类的本质：是继承了一个类或者实现接口的匿名子类对象
    关于匿名内部类还有如下两条规则：
    1）匿名内部类不能是抽象类，因为系统在创建匿名内部类的时候，会立即创建内部类的对象。
            因此不允许将匿名内部类定义成抽象类。
    2）匿名内部类不能定义构造器（构造方法），因为匿名内部类没有类名，所以无法定义构造器，
            但匿名内部类可以定义实例初始化块，
    匿名内部类的格式：
        new 类名或者接口(){
        重写或者实现的方法
    };
 */

    public class NoNameClassDemo {
        public static void main(String[] args) {
            A a = new Aa();
            a.testA();

            new A(){
                public void testA(){
                    System.out.println("匿名内部类的aaa");
                }
            }.testA();

            A a1 = new A(){
                public void testA(){
                    System.out.println("匿名内部类的aaa1111");
                }
            };
            a1.testA();

            B b= new B(){
                public void testB(){
                    System.out.println("BBBB");
                }
            };
            b.testB();
            new B(){
                public void testB(){
                    System.out.println("BBBB");
                }
            }.testB();


            new C(){
                public void testC(){
                    System.out.println("匿名内部类的CCC");
                }
            }.testC();

        }
    }

    interface A{
        public void testA();
    }
    abstract class B{
        abstract  void testB();
    }
    class C{
        public void testC(){
            System.out.println("父类的c");
        }
    }
    class Aa implements A{
        @Override
        public void testA() {
            System.out.println("AAA");
        }

    }