内部类——类中定义类

内部类的分类

        成员内部类

内部类定义在外部类的成员位置

当一个类的成员也是另外一种事物，这个成员可以定义为内部类

成员内部类也是类具有类的特点，能够继承父类，能够实现接口，也有成员的特点，可以被成员修饰符修饰

注意：

只有静态内部类能够定义静态内容，其他内部类不能定义静态内容除了静态常量

成员内部类中可以直接使用外部类中的成员，包括私有的

外部类中需要通过创建成员内部类的对象方法调用成员内部类的成员

其它类中使用成员内部类的成员需要通过外部类对象构建内部类对象，通过内部类对象调用内部类成员    class001_Outer.Inner in = new Class001_Outer().new Inner()

        静态内部类-----静态内部类中可以直接定义静态内容

在静态内部类中使用外部类的成员变量需要通过外部类对象使用，因为内部类是静态的，使用外部类中的静态内容可以直接使用

外部类中需要通过静态内部类的对象调用静态内部类的成员，可以通过静态内部类的类名调用静态内部类的的静态内容

其它类中使用静态内部类的静态内容，可以通过外部类的类名，静态内部类的类名，调用静态内容

其它类中使用静态内部类的成员内容，通过new外部类的类名，静态内部类类名的对象，调用成员内容

        私有内部类-----通过private修饰的成员内部类

私有内部类中可以直接使用外部类中的私有成员

外部类中可以通过私有内部类的对象调用私有内部类的成员，包括私有的

私有内部类只能在外部类中使用，其它类中无法使用

        局部内部类----定义在局部位置的内部类

局部内部类不能被private,public,protected,static等成员修饰符修饰（可以被final修饰）

如果在局部内部类中使用所在方法的局部变量，默认被final修饰

局部内部类只能在所在方法中通过对象访问成员

        匿名内部类

作用：简化没有自己本身作用的实现类|子类（实现了接口，继承了父类——>重写方法），需要在实现类中重写方法，使用次数少——>可以通过匿名内部类简化

匿名内部类对象

1.直接调用——>匿名对象：只能在当前使用一次

new Smaok(){//匿名内部类的类体

    @Override
    public void smoking() {
        System.out.println("写什么都行")
    }
}.smoking();

2.多次调用——>地址赋值给引用，通过引用多次调用

  接口多态：接口类型的引用执行一个实现类对象

Smoke s = new Smoke(){

            @Override
            public void smoking() {
                System.out.println("一边吸烟一边看风景");
            }
        };
        s.smoking();
        s.smoking();
        s.smoking();

3.方法的参数列表

{ 
testSmoke(new Smoke(){

            @Override
            public void smoking() {
                System.out.println("一边吸烟一边看风景");
            }
        });

}
public static void testSmoke(Smoke smoke){
        smoke.smoking();

        lanbda表达式——简化匿名内部类对象

语法:
        ()->{}
        ()->重写方法的参数列表
        -> : 箭头函数 lambda符号
        {}->重写方法的方法体

前提：

        函数式接口为前提：只要一个必须被重写的抽象方法的接口

        强制检测是否为函数式接口：FunctionalInterface

匿名内部类对象
        Swim swim = new Swim(){

            @Override
            public void swimming() {
                System.out.println("一边游泳一边喝水!!!!");
            }
        };

lambda表达式1：

Swim swim = ()->{

        System.out.println("一边游泳一边吐泡泡");

}

lambda表达式2：

如果{}中方法体育局只有一句，前后的{}可以省略

Swim swim = ()-> System.out.println("一边游泳吐泡泡!!!!");

lambda表达式3：

如果存在参数，参数的数据类型可以省略

Swim swim = (name)-> System.out.println(name+"一边游泳吐泡泡!!!!");

lambda表达式4：

如果存在参数，参数只有一个，参数列表前后（）可以省略

Swim swim = s -> System.out.println(s+"一边游泳吐泡泡!!!!");

lambda表达式5：

如果方法存在返回值，并且方法体语句只有一句，就是return语句，前后的{}与return关键字可以一起省略

Swim swim = i——>i>18