内部类下-------Lambda

成员内部类也属于成员，既然是成员那么就可以被一些修饰符所修饰

private:
  私有成员内部类的访问：在自己所在的外部类中创建对象访问

  public class Test2Innerclass {
    /*
        私有成员内部类演示
     */
    public static void main(String[] args) {
        // Outer.Inner oi = new Outer().new Inner();

        Outer o = new Outer();
        o.method();
    }
}

class Outer {
      //私有成员的内部类
    private class Inner {
        public void show(){
            System.out.println("inner..show");
        }
    }

    public void method(){
        Inner i = new Inner();
        i.show();
    }
}

static:
  静态成员内部类的访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名（）；
  静态成员内部类其中的静态方法：外部类名.内部类名.方法名（）；
  public class Test3Innerclass {
    /*
        静态成员内部类演示
     */
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        //外部类名.内部类名.方法名
        Outer.Inner.method();
    }
}

class Outer {
    static class Inner {
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

局部内部类：

局部内部类实在方法中定义的类，因此外界是无法直接使用的，需要在方法内部创建对象
并使用，该类可以直接访问外部类的成员，也可以访问方法内部的局部变量

public class Test4Innerclass {
    /*
        局部内部类:

            编写位置: 方法中
            访问方式: 只能在方法中, 创建对象并访问
     */
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

class Outer {

    int a = 10;

    public void method(){

        int b = 20;

        class Inner {
            public void show(){
                System.out.println("show...");
                System.out.println(a);
                System.out.println(b);
            }
        }

        Inner i = new Inner();
        i.show();

    }

}

匿名内部类：

匿名内部类本质上是一个特殊的局部内部类（定义在方法的内部）
前提：需要存在一个接口或类
格式：new 类名/接口名（）{
       重写方法
}

范例：new Inter(){
   public void show(){
   }
}

package com.itheima.test5;

public class Test5Innerclass {
    /*
        1. 创建实现类, 通过implements关键字去实现接口
        2. 重写方法
        3. 创建实现类对象
        4. 调用重写后的方法.

        匿名内部类:

            前提: 需要存在类\接口
            格式:
                    new 类名 \ 接口名 (){
                        重写方法
                    }
     */
    public static void main(String[] args) {
        InterImpl ii = new InterImpl();
        ii.show();

        // 匿名内部类的理解: 将继承\实现, 方法重写, 创建对象, 放在了一步进行.
        // 解释: 实现了Inter接口的, 一个实现类对象.
        new Inter() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类中的show方法");
            }
        }.show();

        // 情况: 接口中存在多个方法
        Inter2 i = new Inter2() {
            @Override
            public void show1() {
                System.out.println("show1...");
            }

            @Override
            public void show2() {
                System.out.println("show2...");
            }
        };

        i.show1();
        i.show2();
    }
}

interface Inter {
    void show();
}

interface Inter2 {
    void show1();
    void show2();
}

class InterImpl implements Inter {

    @Override
    public void show() {
        System.out.println("InterImpl  重写的show方法");
    }
}

理解就是：匿名内部类是将（继承/实现）（方法重写）（创建对象）三个步骤放在了一步进行

匿名内部类的应用场景：
   当方法的形式参数是接口或者是抽象类的时候，可以将匿名内部类作为实际参数进行传参。

Lambda表达示：

函数式编程思想概述：在数学当中，函数就是有输入量、输出量的一套计算方案，也就是拿数据进行操作
面向对象强调：“必须通过对象的形式做事情”
函数式思想则尽量忽略面向对象的复杂语句“强调做什么，而不是怎么去做？”
而学习Lambda表达式就是函数思想的一种体现

组成Lambda表达式的三要素（形式参数、箭头、代码块）

格式：（形式参数）----> {代码块}
形式参数：如果有多个参数则使用逗号进行分割开来，如果没有参数留空即可
--->：由英文画线和大于符号组成，固定写法，代表指向
代码块：是我们要具体做的事情，也就是我们之前所写的方法体内容

使用前提：
有一个接口（只能对接口进行操作，类也不行）
接口中有且有一个抽象方法（多一个少一个都不行）

Lambda的省略规则：

参数类型可以省略，但有多个参数的情况下，不能只省略一个
如果参数有且仅有一个，那么小括号也可以省略
如果代码块的语句只有一条可以省略大括号和分号，甚至return语句

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));

        /*
            理解: 对于Lambda表达式, 对匿名内部类进行了优化
         */
        goSwimming(() -> System.out.println("铁汁, 我们去游泳吧"));
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

/*
    游泳接口
 */
interface Swimming {
    void swim();

Lambda表达式和匿名表达式的区别：

所需要的类型不同：
  匿名内部类：可以是接口，也可以是抽象类，还可以是具体的类
  Lambda：只能够是接口
使用限制不同：
  如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
  如果接口当中多于一个抽象方法，只能够使用匿名内部类，而不能够使用Lambda表达式
实现原理不同：
  匿名内部类：编译之后会产生一个单独的.class字符串文件
  Lambda：编译之后，没有一个单独的.class字节码文件，对应的字节码会在运行的时候动态生成

Java萌新小白原创，如有不足之处，还请各位前辈多多指教，将不胜感激🙏🙏🙏