03.lambda

1.lambda简介

1.8引入的新机制。

它可以

1.避免匿名内部类定义多

2.代码简洁，只保留逻辑

2.lambda用法

package com.lambda;

/**
 * Created by yj on 2020/8/18 20:07
 */
public class TestLambda {
    public static void main(String[] args){
        Person person = new Tom();
        person.lambda();
        person = new Tom2();
        person.lambda();
        //4.局部内部类
        class Tom3 implements Person{
            public void lambda(){
                System.out.println("Tom3干了某事");
            };
        }
        person = new Tom3();
        person.lambda();
        //5.匿名内部类
        person=new Person() {
            public void lambda() {
                System.out.println("Tom4干了某事");
            }
        };
        person.lambda();
        //6.lambda,其实这个接口就一个方法，为函数式接口，根本就不要那么复杂
        //这个lambda就替代了写匿名内部类，但是他仅仅是针对函数式接口才能用
        //当然他也替代了2，3，4，5所有的写法
        person=()->{
            System.out.println("Tom4干了某事");
        };
        person.lambda();
        //7.带参数的lambda
        Person2 person2=(int a)->{
            System.out.println("带参数--->Tom5干了某事"+a);
        };
        person2.lamnda2(2);//把参数添加进去
        //8.只有一行代码的时候可以这么写
        Person2 person3=a-> System.out.println("带参数--->Tom6干了某事"+a);
        person3.lamnda2(3);
    }

    //3.静态内部类
    static class Tom2 implements Person{
        public void lambda(){
            System.out.println("Tom2干了某事");
        };
    }
}

//1.定义一个函数式接口,所谓函数式接口就是里面只有一条语句
interface Person{
    void lambda();
}

//2.实现类
class Tom implements Person{
    public void lambda(){
        System.out.println("Tom干了某事");
    }
}

interface Person2{
    void  lamnda2(int a);
}

3.lambda与多线程

new Tread(()->{},“A”).start()为什么可以执行线程。

关于Runnable的多线程写法，为什么可以这样写，这个等价于new Tread里面扔进去一个匿名内部类。首先可以看到new Tread()接收参数的默认就是Runable，所以，这儿里面其实等价于

new Tread(（Runable r = ()->{},“A”））

然后注意到Runable就定义了一个接口方法，就是函数式接口，所以可以像上述那么写。

其次注意到Tread实现了Runable接口，而这儿的里面写的lambda表达式又相当于是一个实现了Runable接口的类，也就是Tread和lambda表达式都实现了同一个接口，且把这个lambda表达式扔进去了，这就类似于静态代理中的，真实对象和代理对象都实现了同一个接口，然后把真实对象扔给代理对象。而这儿的lambda表达式就是被代理的真实对象，new Tread（）就是代理对象，这样他就做到了很多lambda表达式没有实现的功能，可以使用Thread这个代理对象的方法，比如start方法。

@FunctionalInterface
public interface Runnable {
    /**
     * When an object implementing interface <code>Runnable</code> is used
     * to create a thread, starting the thread causes the object's
     * <code>run</code> method to be called in that separately executing
     * thread.
     * <p>
     * The general contract of the method <code>run</code> is that it may
     * take any action whatsoever.
     *
     * @see     java.lang.Thread#run()
     */
    public abstract void run();
}

4.配合双冒号使用

使用lambda表达式会创建匿名方法， 但有时候需要使用一个lambda表达式只调用一个已经存在的方法（不做其它）， 所以有了双冒号（::）的使用
以下是Java 8中方法引用的一些语法：

• 静态方法引用（static method）语法：classname::methodname 例如：Person::getAge
• 对象的实例方法引用语法：instancename::methodname 例如：System.out::println
• 对象的超类方法引用语法： super::methodname
• 类构造器引用语法： classname::new 例如：ArrayList::new
• 数组构造器引用语法： typename[]::new 例如： String[]:new