关于java中的内部类

/*      1：什么是内部类：将一个类A定义在类B中，那么A称为内部类，B为外部类
        2：未为什么要有内部类；简而言之，只想在B中单独使用的类，而外部不使用，遵循高内聚低耦合
*       划分：成员内部类:直接声明在外部类中
                    {
                        有static修饰的为：静态的成员内部类
*                       无static修饰的为：非静态的成员内部类
                    }
*
*              局部内部类：声明在方法内，构造器内，代码块的内部
                        >匿名的局部变量内部类
                        >非匿名的局部变量内部类
* */

public class EXer {
        public static void main(String[] args) {
            //1:创建Person静态成员内部类实例化
            Person.Dog dog = new Person.Dog();
            dog.eat();
            //2:创建Person非静态成员内部类实例化
            //Person.Bird bird = new Person.Bird();//错误，非静态
            Person p1 = new Person();//先创建实例才能调用非静态方法
            Person.Bird bird = p1.new Bird();//正确的方式
            bird.eat();
            //那么如何区分外部类和内部类中同名的属性呢
            bird.show("黄鹂鸟");
            bird.show1();

        }
    }
    class Person{//外部类
            int age=1;
            String  name = "TOM";
            public void eat(){
            System.out.println("人吃饭");
        }
        static class Dog{//静态内部类
            public void eat(){
                System.out.println("狗吃骨头");
            }


        }
        class Bird{//非静态内部类
            String name="青鸟";
            public void eat(){
                System.out.println("鸟觅食");
            }
            //内部类中声明方法
            public void show(String name){
                System.out.println("age:"+age);//实际上是Person.this.age
                System.out.println("name:"+name);//就近形参  黄鹂鸟
                System.out.println("name:"+this.name);//当前类的名字 青鸟
                System.out.println("name:"+Person.this.name);//Person的name 为TOM
            }
            public void show1(){
                //内部类调用自己类内的方法
                eat();
                this.eat();
                //调用外部类的方法
                Person.this.eat();

            }
        }


    }

--------------------------------------举例----------------------------

public class ee {
    public static void main(String[] args) {
        //调用1
        B b1 = new B();
        b1.methon();
        //举例一：多态（提供接口实现类匿名对象）
        A a1 = new A() {
            @Override
            public void methon() {
                System.out.println("匿名实现类重写的方法methon()1");
            }
        };
        a1.methon();
        //举例二：直接匿名建立(提供接口匿名实现类匿名对象)
        new A(){
            public void methon() {
                System.out.println("匿名实现类重写的方法methon()2");
            }
        }.methon();
    }
}
interface A{
    void methon();
}
class B implements A{
    public void methon(){
        System.out.println("BB");
    }
}