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

    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");        }    }