package com.lili.innerClass;
/**
 * 内部类：
 * 1.成员内部类：直接定义在方法内部的类
 * 2.方法内部类：在一个类的方法中定义一个类
 * （1）方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化
 * （2）方法内部类对象不能使用该内部类所在方法的非final局部变量
 * 3.静态内部类：在一个类内部定义一个静态内部类
 * （1）静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它，静态嵌套类仅能访问外部类的静态成员方法
 * 4.匿名内部类就是没有名字的内部类
 * 匿名内部类的三种情况：
 * （1） 继承式的匿名内部类
 * （2） 接口式的匿名内部类
 * （3） 参数式的匿名内部列
 *
 * @author: QiJingJing
 * @create: 2021/7/4
 */
public class Test1 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        // Outer.Inner inner = outer.new Inner();
        // inner.show(); 影响美观，不建议使用
        outer.innerShow();
        outer.showClass();
        Outer.Inner2 inner2 = new Outer.Inner2();
        inner2.show();
        // 抽象类式
        outer.print1();
        // 接口式
        outer.print2();
        // 参数式
        outer.print3(() -> System.out.println("我是参数式匿名内部类"));
    }
}
class Outer {
    private String name;
    // 建议在外部类中定义一个方法，对外提供访问内部类的接口
    public void innerShow() {
        Inner inner = new Inner();
        inner.show();
    }
    // 成员内部类
    private class Inner {
        public void show() {
            System.out.println("我是成员内部类");
        }
    }
    // -------------方法内部类---------
    // show方法的参数或局部变量，实际必须是常量final
    public void showClass() {
        int x = 10;
        // 在一个方法中定义一个类
        class Inner1 {
            public void show() {
                // x++; 从内部类引用的本地变量必须是最终变量或实际上的最终变量
                System.out.println("我是方法内部类" + x);
            }
        }
        Inner1 inner1 = new Inner1();
        inner1.show();
    }
    // -----------静态内部类---------
    static class Inner2 {
        public void show() {
            System.out.println("我是静态内部类");
        }
    }
    // ------------匿名内部类-------
    // 抽象式匿名内部类
    public void print1() {
        new Dog() {
            @Override
            void run() {
                System.out.println("小狗会跑");
            }
        }.run();
    }
    // 接口式匿名内部类
    public void print2() {
        new Person() {
            @Override
            public void eat() {
                System.out.println("人会吃");
            }
        }.eat();
    }
    // 参数式匿名内部类
    public void print3(Person person) {
        person.eat();
    }
}
/**
 * 定义一个抽象类
 */
abstract class Dog {
    abstract void run();
}
/**
 * 定义一个接口
 */
interface Person {
    void eat();
}