Lambda表达式

• 避免匿名内部类过多
• 代码更简洁
• 函数式接口：有且只有一个函数式接口，即只有一个方法。

 测试1

package com.fh.lambda;

public class LambdaTest {
    public static void main(String[] args) {

        IUserService service = () -> System.out.println("【只有一句话可以去掉{花括号}】");;
        service.add();

        IUserService_Argument service_argument = (int id,String type)->{
            int salary = 1;
            int bonus = 2;
            System.out.println(id+"====="+type+"=====" + (salary + bonus));
        };
        service_argument.add(1,"电脑补助");

        service_argument = (id,type)->{
            int salary = 1;
            int bonus = 2;
            System.out.println("【可以去掉参数类型】" + id+"====="+type+"=====" + (salary + bonus));
        };
        service_argument.add(1,"电脑补助");
    }
}

interface IUserService {
    void add();
}

interface IUserService_Argument {
    public void add(int id,String type);
}

测试2

模拟new Thread(()-> System.out.println("模拟Thread")).start();

/**
 * 模拟中介租房
 */
public class StaticProxy_RentHourse {
    public static void main(String[] args) {
        //new LianJiaProxy(new ZukeTarget()).rent();
        
        new LianJiaProxy(()->{
            System.out.println("我租到一个性价比比较高的房子");
        }).rent();
    }
}

/**
 * 租房
 */
interface Rent{
    public void rent();
}

/**
 * 目标：租客
 */
class ZukeTarget implements Rent{

    @Override
    public void rent() {
        System.out.println("我租到一个性价比比较高的房子");
    }
}

/**
 * 代理：链家
 */
class LianJiaProxy implements Rent{

    private Rent rent;//真实目标角色

    public LianJiaProxy(Rent rent) {
        this.rent = rent;
    }

    @Override
    public void rent() {
        nofityLook();
        this.rent.rent();
        pay();
    }

    private void pay() {
        System.out.println("付款了");
    }

    private void nofityLook() {
        System.out.println("链家通知看房");
    }
}

 

System.out::print 与 System.out.print的区别

 

 

四大函数式接口

函数式接口：有且只有一个方法。

函数型接口

import java.util.function.Function;

/**
 * 函数型接口
 * @FunctionalInterface
 * public interface Function<T, R>
 *      R apply(T t);
 * }
 */
public class FunctionTest {
    public static void main(String[] args) {
      /*  Function<String, String> function = new Function<String, String>() {
            @Override
            public String apply(String s) {
                System.out.println("参数=》"+s);
                return "返回值=》123";
            }
        };
        System.out.println(function.apply("ddd"));*/


        Function<String, String> function =(s)->{
            System.out.println("参数=》"+s);
            return "返回值=》123";
        };
        System.out.println( function.apply("ddd"));
    }
}

断定型接口

import java.util.function.Predicate;

/**
 * 断定型接口
 * @FunctionalInterface
 * public interface Predicate<T> {
 *      boolean test(T t);
 * }
 */
public class PredicateTest {
    public static void main(String[] args) {
        /*Predicate<String> predicate = new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.isEmpty();
            }
        };
        System.out.println(predicate.test("a"));*/

        Predicate<String> predicate = (s)->{
           return s.isEmpty();
        };
        System.out.println(predicate.test("a"));
    }
}

消费型接口

/**
 * 消费型接口
 * public interface Consumer<T> {
 * void accept(T t);
 * }
 */
public class ConsumerTest {
    public static void main(String[] args) {
       /* Consumer<String> consumer = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer.accept("abc");*/

        Consumer<String> consumer = (s) -> {
            System.out.println(s);
        };
        consumer.accept("a");
    }
}

供给型接口

/**
 * 供给型接口
 * @FunctionalInterface
 * public interface Supplier<T> {
 *      T get();
 * }
 */
public class SupplierTest {
    public static void main(String[] args) {
        /*Supplier<String>  supplier = new Supplier<String>() {
            @Override
            public String get() {
                return "abc";
            }
        };
        System.out.println(supplier.get());*/
        Supplier<String>  supplier = ()->{
            return "a";
        };
        System.out.println(supplier.get());
    }
}