Java内部类

内部类三种，1：普通成员内部类（成员内部类）；2：方法内部类（局部内部类）；3：静态内部类（成员内部类）；4：匿名内部类（继承式、接口式、参数式）（局部内部类）

匿名类有以下几个原则：

1：不能有构造方法，只能有一个实例；

2：不能定义任何静态成员、静态方法；

3：不能是 public，protected，private，static；

4：一定是在new的后面。用其隐含实现一个接口或实现一个类；

5：匿名内部类为局部的，所以局部内部类的所有限制都对其生效。

@Test
 void testBaseData(){
        Outer outer = new Outer();
        outer.print3(new Eat() {
            @Override
            public void eat() {
                System.out.println("参数式匿名内部类");
            }
        });
    }
}


class Outer{
    private String name = "name";

    //普通成员内部类
    class Inner{
        public void print(){
            System.out.println("成员内部类，可以访问到外部类的属性" + name);
        }
    }

    public void innerPrint(){
        Inner inner = new Inner();
        inner.print();
    }


    public void show(){
        int x = 10;//实际是被final修饰
        //方法内部类
        class Inner2{
            public void print(){
                System.out.println("方法内部类，可以访问到外部类的属性" + name + "但是不可以修改x");
            }
        }
        Inner2 inner2 = new Inner2();
        inner2.print();
    }

    //静态内部类
    static  class Inner3{
        public void print(){
            System.out.println("静态内部类，无法访问到外部类的属性name,但是可以访问静态属性");
        }
    }

    //匿名内部类
    //继承式
    public void  print1(){
        Cat cat = new Cat() {
            @Override
            public void eat() {
                System.out.println("继承式匿名内部类");
            }
        };
        cat.eat();
    }
    //接口式
    public void print2(){
        Eat eat = new Eat() {
            @Override
            public void eat() {
                System.out.println("接口式匿名内部类");
            }
        };
        eat.eat();
    }

    //参数式
    public void print3(Eat eat){
        eat.eat();
    }
}

abstract class Cat{
    abstract void eat();
}

interface Eat{
    public void eat();
}