Lambda表达式与静态代理详解

希腊字母表中排序第十一位的字母，英语名称为Lambda

避免匿名内部类定义过多

其实质属于函数式编程的概念

（params)->expression[表达式]

（params)->statement[语句]

（params)->{statements}

为什么要使用Lambda表达式?

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

2.可以让你的代码看起来很简洁

3.去掉了一堆没有意义的代码，只留下核心的逻辑

ctrl+shift+/为多行注释

理解Functional Interface(函数式接口）是学习Java8 lambda表达式的关键所在

函数式接口的定义：

任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口

如下所示：

public interface Runnable{
  public abstract void run();
}

对于函数式接口，我们可以通过lambda表达式来创建该接口的对象。

实例一的代码如下所示：

package com.Lambda;
/*
推导lambda表达式，
 */
public class Demo1 {

    //3.静态内部类
    static class Like2 implements ILike {
        @Override
        public void lambda() {
            System.out.println("I LIKE lambda2");
        }
    }


    public static void main(String[] args) {
        //用接口创建对象，父类引用子类对象，方法重载里面有提到这个
        ILike like = new Like();
        like.lambda();

        like = new Like2();
        like.lambda();

        //4.局部内部类
        class Like3 implements ILike {
            @Override
            public void lambda() {
                System.out.println("I LIKE lambda3");
            }
        }
        like = new Like3();
        like.lambda();


        //5.匿名内部类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I LIKE lambda4");
            }

        };
        like.lambda();

        //6.用lambda简化
        like = () -> {
            System.out.println("I LIKE lambda5");
        };
        like.lambda();
    }


    //1.定义一个函数式接口，只有一个抽象类方法
    interface ILike {
        //隐式声明，自动就是抽象。
        void lambda();
    }

    //2.实现类
    static class Like implements ILike {
        @Override
        public void lambda() {
            System.out.println("I LIKE lambda");
        }
    }
}

运行界面如下请所示：

我们通过更加详细的步骤去了解lambda表达式。

代码示例如下所示：

package com.Lambda;

import com.rgf.structure.O;

public class Demo2 {
    public static void main(String[] args) {
        Ilove love = new Love();
        love.love(3);
    }


    //1.定义一个函数式接口，只有一个抽象类方法
    interface  Ilove{
        //隐式声明，自动就是抽象
        void love(int a);
    }
    //2.实现类
    static class Love implements Ilove {
        @Override
        public void love(int a) {
            System.out.println("I Love you,ypl-->"+a);
        }
    }









}

之后我们进行修改代码，将外部的类改到内部。

package com.Lambda;

import com.rgf.structure.O;

public class Demo2 {

    //2.实现类
    static class Love implements Ilove {
        @Override
        public void love(int a) {
            System.out.println("I Love you,ypl-->"+a);
        }
    }
    
    
    public static void main(String[] args) {
        Ilove love = new Love();
        love.love(3);
    }


    //1.定义一个函数式接口，只有一个抽象类方法
    interface  Ilove{
        //隐式声明，自动就是抽象
        void love(int a);
    }
    









}

之后我们将内部类改为局部内部类

package com.Lambda;

import com.rgf.structure.O;

public class Demo2 {

    


    public static void main(String[] args) {

        //2.实现类
        class Love implements Ilove {
            @Override
            public void love(int a) {
                System.out.println("I Love you,ypl-->"+a);
            }
        }



        Ilove love = new Love();
        love.love(3);
    }


    //1.定义一个函数式接口，只有一个抽象类方法
    interface  Ilove{
        //隐式声明，自动就是抽象
        void love(int a);
    }










}

之后将局部内部类改为匿名内部类

package com.Lambda;

import com.rgf.structure.O;

public class Demo2 {

    


    public static void main(String[] args) {

        //匿名内部类 new一个接口。
        Ilove love = new Ilove() {
            @Override
            public void love(int a) {
                System.out.println("I Love you ,ypl"+a);
            }
        };
        love.love(3);
    }


    //1.定义一个函数式接口，只有一个抽象类方法
    interface  Ilove{
        //隐式声明，自动就是抽象
        void love(int a);
    }

}

之后将匿名内部类改为lambda表达式。

package com.Lambda;

import com.rgf.structure.O;

public class Demo2 {




    public static void main(String[] args) {

        //匿名内部类 new一个接口。
        Ilove love =(int a)-> {
            System.out.println("I Love you ,ypl"+a);
        };
        love.love(520);
    }


    //1.定义一个函数式接口，只有一个抽象类方法
    interface  Ilove{
        //隐式声明，自动就是抽象
        void love(int a);
    }

}

lambda简化：

package com.Lambda;

import com.rgf.structure.O;

public class Demo2 {




    public static void main(String[] args) {
          Ilove love=null;
       /* //lambda表达式简化
        Ilove love =(int a)-> {
            System.out.println("I Love you ,ypl"+a);
        };

        //简化1.参数类型
        love =(a)-> {
            System.out.println("I Love you ,ypl"+a);
        };
*/
        /*//简化2.简化括号
        love =a-> {
            System.out.println("I Love you ,ypl"+a);
        };*/
       //简化3.去掉花括号
        love =a-> System.out.println("I Love you ,ypl"+a);

        //总结
        //lambda表达式只能在有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
        //前提是接口必须为函数式接口，即接口里面只能有一个抽象类方法
        //多个参数也可以去掉参数类型，要去掉就都去掉，必须加上括号
        love.love(521);
    }


    //1.定义一个函数式接口，只有一个抽象类方法
    interface  Ilove{
        //隐式声明，自动就是抽象
        void love(int a);
    }

//Runnable接口只有一个抽象类方法run方法，如果代码简单，可以用lambda表达式。








}

其中注释的代码可以去掉注释，看它们的运行效果从而可以更好的理解。

运行界面如下所示：

静态代理详解：

你：真实角色

婚庆公司：代理你，帮你处理结婚的事

结婚：实现都实现结婚接口即可

代码实现如下所示：

package com.Lambda;

import com.rgf.structure.W;
//静态代理模式总结：
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色

//好处：
//代理对象可以做很多真实对象做不了的事情
//真实对象就专注做自己的事情
public class StaticProxy {
    public static void main(String[] args) {
        You you = new You();//你要结婚
        //lambda表达式
        //多线程开始。
        new Thread(() -> System.out.println("我爱你，蕾蕾")).start();
        /*new Thread(new Runnable(){
        @Override
        public void run () {
        }
    })可以简化为上述写法。
         */
      //原来的调法  you.HappyMarry();
        new WeddingCompany(new You()).HappyMarry();
       /* WeddingCompany weddingCompany=new WeddingCompany(you);//现在的调法
        weddingCompany.HappyMarry();与上面一行代码相同*/
    }
}
//1.写功能接口
interface Marry{
    //人间四大喜事
       //久旱逢甘露
       //他乡遇故知
       //洞房花烛夜
       //金榜提名时
    void HappyMarry();
}
//2.写实现类
//真实角色，你去结婚
class You implements Marry{
    //实现接口方法，进行重写方法
    @Override
    public void HappyMarry() {
        System.out.println("峰峰和蕾蕾要结婚了，超开心");
    }
}
//代理角色，帮助你结婚
class WeddingCompany implements Marry{
    //代理谁-->真实目标角色
    private Marry target;//目标对象
    //设置构造方法，传递参数
    public WeddingCompany(Marry target) {
        this.target = target;
    }
//实现接口方法，进行重写方法
    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry(); //这就是真实对象，
        after();
    }
//创建一个方法，alt+enter。
    private void after() {
        System.out.println("结婚之后，收尾款");
    }

    private void before() {
        System.out.println("结婚之前，布置现场");
    }
}

运行界面如下所示：