lambda，final

lambda

@FunctionInterface

jdk1.8+ 可以使用@FunctionInterface修饰接口。“函数式接口” （接口里面有且只有1个抽象方法）在这种情况下可以使用lambda替换接口的匿名内部类，做到简化代码编写

匿名内部类：
任意一个类都可以创建匿名内部类====> 创建了一个类的子类
任意一个接口都可以创建匿名内部类====> 创建了一个接口的实现类

接口的匿名内部类语法:
new 接口名(){
//实现接口里面定义的所有抽象方法
};

//lambda语法表达式
//面向函数式编程----> 面向方法编程---->方法引用
//语法:
1.基本语法
([数据类型 变量1,…,数据类型 变量n])->{
//逻辑功能代码
}
2.简洁语法
类名::方法名; 对象/引用::方法名;

使用lambda的目的只有1个: 简化代码编写。替换接口的匿名内部类。
前提要求:
1.要么接口上使用@FunctionInterface标记
2.不使用@FunctionInterface注解，要保证接口里面有且只有1个抽象方法。
如果不满足以上2点的其中一点的话，是无法使用lambda语法的

无参无返回值

先写一个简单的接口

package com.zsw.test;

/**
 * @className:InterfaceTest
 * @description:
 * @author:Zhang Shaowen
 * @date:2023/4/419:01
 * @version:0.1
 * @since:jdk11
 */
public interface InterfaceTest {

    public static String s="InterfaceTest";

    public abstract void demo();

    public default  void  a(){
        System.out.println("接口的默认方法");
    }
}

然后去new该接口的匿名实现类,并用lambd简化

public class Lambda {
    public static void main(String[] args) {
        InterfaceTest interfaceTest = new InterfaceTest() {
            @Override
            public void demo() {
                System.out.println("重写的方法");
            }
        };

        InterfaceTest interfaceTest1 = ()->{
            System.out.println("重写的方法，lambda");
        };

        interfaceTest.demo();
        interfaceTest1.demo();
    }
}

运行结果:

这里可以对比一下if…else {}可以省略
lambda语法: {} 方法体代码有且仅有一行 {}也可以省略

那么化简一下:

public class Lambda {
    public static void main(String[] args) {
        InterfaceTest interfaceTest = new InterfaceTest() {
            @Override
            public void demo() {
                System.out.println("重写的方法");
            }
        };

        InterfaceTest interfaceTest1 = ()-> System.out.println("重写的方法，lambda");

        interfaceTest.demo();
        interfaceTest1.demo();
    }
}

有参无返回值

ok,接着来一个含有有参无返回值抽象类的接口

public interface InterfaceTest {

    public static String s="InterfaceTest";

    public abstract void demo(int num1,int num2);

    public default  void  a(){
        System.out.println("接口的默认方法");
    }
}

然后lambda表达式简化为

public class Lambda {
    public static void main(String[] args) {
        InterfaceTest interfaceTest = new InterfaceTest() {
            @Override
            public void demo(int num1, int num2) {
                System.out.println("重写的方法");
            }
        };

        InterfaceTest interfaceTest1 = (int num1,int num2)->{
            System.out.println("重写的方法，lambda");
        };
        
        interfaceTest.demo(1,1);
        interfaceTest1.demo(1,1);
    }
}

输出为:

和无参无返回值的情况一样,在只有一行代码的情况下{}可以省略
然而还可以接着化简:
前提:一个形参 参数数据类型 以及() 都可以省略
如果方法形参>1 只能省略参数类型

两个参数情况,化简一下

public class Lambda {
    public static void main(String[] args) {
        InterfaceTest interfaceTest = new InterfaceTest() {
            @Override
            public void demo(int num1, int num2) {
                System.out.println("重写的方法");
            }
        };

        InterfaceTest interfaceTest1 = (num1,num2)->System.out.println("重写的方法，lambda");
        
        
        interfaceTest.demo(1,1);
        interfaceTest1.demo(1,1);
    }
}

按照上面的说法,接着化简(变成只有num1一个形参)

public class Lambda {
    public static void main(String[] args) {
        InterfaceTest interfaceTest = new InterfaceTest() {
            @Override
            public void demo(int num1) {
                System.out.println("重写的方法");
            }
        };

        InterfaceTest interfaceTest1 =  num1-> System.out.println("重写的方法，lambda");
        

        interfaceTest.demo(1);
        interfaceTest1.demo(1);
    }
}

有参有返回值

再来个有参有返回值的

public interface InterfaceTest {

    public static String s="InterfaceTest";

    public abstract int demo(int num1,int num2);

    public default  void  a(){
        System.out.println("接口的默认方法");
    }
}

lambda化简一下

public class Lambda {
    public static void main(String[] args) {
        InterfaceTest interfaceTest = new InterfaceTest() {
            @Override
            public int demo(int num1, int num2) {
                return Math.max(num1,num2);
            }
        };

        InterfaceTest interfaceTest1 =(int num1, int num2)->{
            return Math.max(num1,num2);
        };
        System.out.println(interfaceTest.demo(9, 1));
        System.out.println(interfaceTest1.demo(10, 2));
    }
}

输出为:

有返回值的方法,方法体只有一行 {}可以省略,同时return也必须要省

那化简一下

public class Lambda {
    public static void main(String[] args) {
        InterfaceTest interfaceTest = new InterfaceTest() {
            @Override
            public int demo(int num1, int num2) {
                return Math.max(num1,num2);
            }
        };

        InterfaceTest interfaceTest1 =(num1,num2)->Math.max(num1,num2);
        
        System.out.println(interfaceTest.demo(9, 1));
        System.out.println(interfaceTest1.demo(10, 2));
    }
}

有一种情况:重写的方法的形参与返回值类型兼容调用方法的形参与返回值类型
其他情况:调用的方法返回值类型与重写方法的返回值类型兼容
可以化简为: 类名::方法名 引用::方法名

那么,再化简一下

public class Lambda {
    public static void main(String[] args) {
        InterfaceTest interfaceTest = new InterfaceTest() {
            @Override
            public int demo(int num1, int num2) {
                return Math.max(num1,num2);
            }
        };

        InterfaceTest interfaceTest1 = Math::max;

        System.out.println(interfaceTest.demo(9, 1));
        System.out.println(interfaceTest1.demo(10, 2));
    }
}

final

修饰符/关键字
1.修饰变量----> 常量(使用最多)
全局变量:
常量名称全部大写 必须赋值 且值不能更改。
局部变量:
常量名称参照局部变量名称定义 小写驼峰。 值不能更改

2.修饰类—> String
final修饰类: 这个类不能作为父类使用，没有子类。

3.修饰方法
在继承关系下，子类不能重写父类里面使用final修饰的方法