匿名内部类&Lambda表达式&函数式接口

一. 匿名内部类

匿名内部类作用:简化代码
把子类继承父类/实现接口,重写父类/接口中的方法,创建子类对象合一步完成

匿名内部类的最终产物:
子类/实现类对象

格式:
在匿名内部类中，接口也是可以new出对象的
new 父类/接口(){
从写重复父类/接口中的方法
};

例如1：

/*
线程的父类是Thread，原来的写法：
    1.先创建MyThread类继承自Thread
    2.使用的时候再new MyThread，然后再调用start方法
 */
new MyThread().start();
--------------------------------------------------------------------
/*
使用匿名内部类的写法：
 */
new Thread(){
    //重写run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+"黑马");
        }
    }
}.start();

例如2：

/*
不使用用匿名内部类写法：
    1.先创建RunnableImpl类，并实现Runnable接口
    2.再new RunnableImpl
    3.将任务交给Thread，再调用start()
 */
Runnable r = new RunnableImpl();
new Thread(r).start();
--------------------------------------------------------------------
/*
使用匿名内部类写法：
 */
new Thread(new Runnable(){
    //重写run方法,设置线程任务
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            System.out.println("朱上林"+i);
        }
    }
}).start();

二. Lambda表达式

Lambda表达式，用来简化匿名内部类的书写，不再有“不得不创建接口对象”的束缚，不再有“抽象方法重写”的负担，就是这么简单！

用法
定义方法：
定义方法invokeCook(Cook cook)中有接口参数，并且方法体中调用了该接口参数的抽象方法cook.makeFood()

调用方法：
invokeCook(()->{}); 此时Lambda表达式表示的就是cook.makeFood()抽象方法的实现（相当于回调函数，调用的时候实现抽象方法）

案例1：无参数的Lambda

//创建Cook接口，并定义抽象方法
public interface Cook {
    //定义无参数无返回值的方法makeFood
    public abstract void makeFood();
}

//测试类
public class Demo01Cook {
    public static void main(String[] args) {
        //使用匿名内部类写法
        invokeCook(new Cook() {
            @Override
            public void makeFood() { 
                System.out.println("吃饭了");
            }
        });

        //使用Lambda表达式,简化匿名内部类的书写
        invokeCook(()->{ //Lambda表达式来表示实现接口中的抽象方法
            System.out.println("吃饭了");
        });

        //优化Lambda，如果写在一行{} return ; 三个同时省略
        invokeCook(()-> System.out.println("吃饭了"));
    }

    
    public static void invokeCook(Cook cook){
        cook.makeFood();
    }
}

案例2：有参数的Lambda

//对数组中的Person对象使用Arrays的sort方法通过年龄进行升序(前边-后边)排序，匿名内部类方式实现
Arrays.sort(arr, new Comparator<Person>() {
    @Override
    public int compare(Person o1, Person o2) {
        return o1.getAge()-o2.getAge();
    }
});

//使用Lambda表达式,简化匿名内部类
Arrays.sort(arr,(Person o1, Person o2)->{
    return o1.getAge()-o2.getAge();
});

//简化Lambda，省略{}  return ;
Arrays.sort(arr,(Person o1, Person o2)->o1.getAge()-o2.getAge()
);

案例3

public interface Calculator {
    //定义一个计算两个int整数和的方法并返回结果
    public abstract int calc(int a,int b);
}

public class Demo01Calculator {
    public static void main(String[] args) {
        //调用invokeCalc方法,方法的参数是一个接口,使用匿名内部类
        invokeCalc(10, 20, new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a+b;
            }
        });

        //使用Lambda表达式简化匿名内部类的书写
        invokeCalc(120,130,(int a,int b)->{
            return a + b;
        });

        //优化省略Lambda
        invokeCalc(120,130,(a,b)-> a + b);
    }

    public static void invokeCalc(int a,int b,Calculator c){
        int sum = c.calc(a,b);
        System.out.println(sum);
    }
}

Lambda使用前提
1.使用Lambda必须具有接口，且要求接口中有且仅有一个抽象方法。 无论是JDK内置的Runnable、Comparator接口还是自定义的接口，只有当接口中的抽象方法存在且唯一时，才可以使用Lambda。
2.使用Lambda必须具有上下文推断。 也就是方法的参数或局部变量类型必须为Lambda对应的接口类型，才能使用Lambda作为该接口的实例。
备注：有且仅有一个抽象方法的接口，称为“函数式接口”。

三、函数式接口

概念
有且只有一个抽象方法的接口,称之为函数式接口
当然接口中可以包含其他的方法(默认,静态,私有)

@FunctionalInterface注解
作用:可以检测接口是否是一个函数式接口，类似@Override检查一个重写方法
是:编译成功
否:编译失败(接口中没有抽象方法，或者抽象方法的个数多余1个)

例：
定义函数式接口

@FunctionalInterface
public interface MyFunctionalInterface {
    //定义一个抽象方法
    public abstract void method();
}

使用函数式接口

public class Demo {
    //定义一个方法,参数使用函数式接口MyFunctionalInterface
    public static void show(MyFunctionalInterface myInter){
        myInter.method();
    }

    public static void main(String[] args) {
        //调用show方法,方法的参数是一个接口,所以可以传递接口的实现类对象
        show(new MyFunctionalInterfaceImpl());

        //调用show方法,方法的参数是一个接口,所以我们可以传递接口的匿名内部类
        show(new MyFunctionalInterface() {
            @Override
            public void method() {
                System.out.println("使用匿名内部类重写接口中的抽象方法");
            }
        });

        //调用show方法,方法的参数是一个函数式接口,所以我们可以Lambda表达式
        show(()->{
            System.out.println("使用Lambda表达式重写接口中的抽象方法");
        });

        //简化Lambda表达式
        show(()-> System.out.println("使用Lambda表达式重写接口中的抽象方法"));
    }
}

四、函数式编程

Lambda的特点: 延迟加载，提升性能
Lambda的使用前提,必须存在函数式接口，函数式接口作为形参的方法，在被调用时，实参Lambda表达式就表示该函数式接口中的那个抽象方法的实现。
例1
发现以下代码存在的一些性能浪费的问题
调用showLog方法,传递的第二个参数是一个拼接后的字符串
先把字符串拼接好,然后在调用showLog方法，showLog方法中如果传递的日志等级不是1级
那么就不会是如此拼接后的字符串，所以感觉字符串就白拼接了,存在了浪费

public class Demo01Logger {
    public static void showLog(int level, String message){
        if(level==1){
            System.out.println(message);
        }
    }
    public static void main(String[] args) {
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";
        showLog(2,msg1+msg2+msg3);
    }
}

使用Lambda延迟加载，提升性能：
1.将新能浪费的代码定义为一个函数式接口中的一个抽象方法

@FunctionalInterface
public interface MessageBuilder {
    //定义一个拼接消息的抽象方法,返回被拼接的消息
    public abstract String builderMessage();
}

2.方法中将接口作为参数，调用该方法时，lambda表达式会根据判断是否成立，决定是否执行，所以可以把Lambda表达式看作，函数式接口中的那个抽象方法的实现

public class Demo02Lambda {
    public static void showLog(int level, MessageBuilder mb){
        //对日志的等级进行判断,如果是1级,则调用MessageBuilder接口中的builderMessage方法
        if(level==1){
            System.out.println(mb.builderMessage());
        }
    }
    public static void main(String[] args) {
        String msg1 = "Hello";
        String msg2 = "World";
        String msg3 = "Java";
        showLog(1,()->{
            return  msg1+msg2+msg3;
        });
    }
}

例2：参数为函数式接口

public class Demo01Runnable {
    //函数式接口作为形参的方法，再被调用时，实参lambda表达式就表示该函数式接口中的那个抽象方法的实现。
    public static void startThread(Runnable run){
          new Thread(run).start();
    }

    public static void main(String[] args) {
        startThread(()->{
            System.out.println("线程启动了");
        });
    }
}

例3：方法的返回值类型是函数式接口

public class Demo02Comparator {
    //定义一个方法,方法的返回值类型使用函数式接口Comparator
    public static Comparator<String> getComparator(){
        //方法的返回值类型是一个接口,那么我们可以返回这个接口的匿名内部类
        /*return new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                //按照字符串的降序排序
                return o2.length()-o1.length();
            }
        };*/

        //使用Lambda表达式
        return (o1, o2)->o2.length()-o1.length();
    }

    public static void main(String[] args) {
        //创建一个字符串数组
        String[] arr = {"aaa","b","cccccc","dddddddddddd"};
        //调用Arrays中的sort方法,对字符串数组进行排序
        Arrays.sort(arr,getComparator());
        //输出排序后的数组	
        System.out.println(Arrays.toString(arr)); 
	//[dddddddddddd, cccccc, aaa, b]  
	 }
}