静态代理模式&Lambda表达式

目录

一、静态代理模式

二、Lambda表达式 

2.1 为什么要使用lambda表达式

2.2 函数式接口

2.3 函数式编程概念

2.4 推导Lambda表达式

2.5 含参Lambda表达式推导过程

2.6 简化Lambda表达式

2.7 总结

一、静态代理模式

要求：真实对象和代理对象都要实现同一个接口

           代理对象要代理真实角色

好处：代理角色可以做好多真实角色做不了的事

           真实角色可专注于自己的事情

引入案例：结婚

你：真实角色

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

结婚：通过接口实现

//静态代理模式
public class StaticProxy {
    public static void main(String[] args) {
        //需要一个代理角色，服务于真实角色
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
    }
}

//共同接口
interface Marry{
    void HappyMarry();
}

//真实角色
class You implements Marry{
    @Override
    public void HappyMarry() {
        System.out.println("happy");
    }
}

//代理角色
class WeddingCompany implements Marry{
    //目标对象
    private Marry target;

    public  WeddingCompany(Marry target){
        this.target=target;
    }

    @Override
    public void HappyMarry() {
        before();
        this.target.HappyMarry();
        after();
    }

    private void after() {
        System.out.println("结婚后");
    }

    private void before() {
        System.out.println("结婚前");
    }
}

运行结果：

二、Lambda表达式 

2.1 为什么要使用lambda表达式

        1）避免匿名内部类过多

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

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

2.2 函数式接口

        理解Functional Interfa（函数式接口）是学习Java8 Lambda表达式的关键所在

        函数式接口定义：

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

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

2.3 函数式编程概念

        (params) -> expression[表达式]

        (params) -> statement[语句]

        (params) -> {statement}

2.4 推导Lambda表达式

最初写法：

public class TestLambda01 {
    public static void main(String[] args) {
        //用接口创建对象 接口new实现类
        ILike like = new Like();
        like.Lambda();
    }
}

//定义一个函数式接口
interface ILike{
    void Lambda();
}

//实现类
class Like implements ILike{
    @Override
    public void Lambda() {
        System.out.println("i like lambda");
    }
}

使用静态内部类进行第一次优化：

public class TestLambda01 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void Lambda() {
            System.out.println("i like lambda02");
        }
    }

    public static void main(String[] args) {
        //用接口创建对象 接口new实现类
        ILike like = new Like();
        like.Lambda();
        ILike like2 = new Like2();
        like2.Lambda();
    }
}

//1.定义一个函数式接口
interface ILike{
    void Lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void Lambda() {
        System.out.println("i like lambda01");
    }
}

使用局部内部类进行第二次优化：

public class TestLambda01 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void Lambda() {
            System.out.println("i like lambda02");
        }
    }

    public static void main(String[] args) {
        //用接口创建对象 接口new实现类
        ILike like = new Like();
        like.Lambda();

        ILike like2 = new Like2();
        like2.Lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void Lambda() {
                System.out.println("i like lambda03");
            }
        }

        ILike like3 = new Like3();
        like3.Lambda();
    }
}

//1.定义一个函数式接口
interface ILike{
    void Lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void Lambda() {
        System.out.println("i like lambda01");
    }
}

使用匿名内部类进行第三次优化：

public class TestLambda01 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void Lambda() {
            System.out.println("i like lambda02");
        }
    }

    public static void main(String[] args) {
        //用接口创建对象 接口new实现类
        ILike like = new Like();
        like.Lambda();

        ILike like2 = new Like2();
        like2.Lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void Lambda() {
                System.out.println("i like lambda03");
            }
        }

        ILike like3 = new Like3();
        like3.Lambda();

        //5.匿名内部类   没有类的名字，必须借助父类或者接口
        like=new ILike(){
            @Override
            public void Lambda() {
                System.out.println("i like lambda04");
            }
        };

        like.Lambda();
    }
}

//1.定义一个函数式接口
interface ILike{
    void Lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void Lambda() {
        System.out.println("i like lambda01");
    }
}

最后使用Lambda简化，完成Lambda表达式的整个推导过程：

//推导Lanbda表达式
public class TestLambda01 {
    //3.静态内部类
    static class Like2 implements ILike{
        @Override
        public void Lambda() {
            System.out.println("i like lambda02");
        }
    }

    public static void main(String[] args) {
        //用接口创建对象 接口new实现类
        ILike like = new Like();
        like.Lambda();

        ILike like2 = new Like2();
        like2.Lambda();

        //4.局部内部类
        class Like3 implements ILike{
            @Override
            public void Lambda() {
                System.out.println("i like lambda03");
            }
        }

        ILike like3 = new Like3();
        like3.Lambda();

        //5.匿名内部类   没有类的名字，必须借助父类或者接口
        like=new ILike(){
            @Override
            public void Lambda() {
                System.out.println("i like lambda04");
            }
        };

        like.Lambda();

        //6.使用Lambda简化
        like=() -> {
            System.out.println("i like lambda05");
        };

        like.Lambda();
    }
}

//1.定义一个函数式接口
interface ILike{
    void Lambda();
}

//2.实现类
class Like implements ILike{
    @Override
    public void Lambda() {
        System.out.println("i like lambda01");
    }
}

2.5 含参Lambda表达式推导过程

第一步：写接口、实现类，并通过接口new一个实现类，调用对应的方法

public class TestLambda02 {
    public static void main(String[] args) {
        ILove love = new Love();
        love.love(2);
    }
}

//接口
interface ILove{
    void love(int a);
}

//实现类
class Love implements ILove{
    @Override
    public void love(int a) {
        System.out.println("i love you --> "+a+" times");
    }
}

第二步：改写为静态内部类

public class TestLambda02 {
    //静态内部类
    static class Love implements ILove{
        @Override
        public void love(int a) {
            System.out.println("i love you --> "+a+" times");
        }
    }
    public static void main(String[] args) {
        ILove love=new Love();
        love.love(3);
    }
}

//接口
interface ILove{
    void love(int a);
}

第三步：改写为局部内部类

public class TestLambda02 {
    public static void main(String[] args) {
        //局部内部类
        class Love implements ILove{
            @Override
            public void love(int a) {
                System.out.println("i love you --> "+a+" times");
            }
        }

        ILove love=new Love();
        love.love(4);
    }
}

//接口
interface ILove{
    void love(int a);
}

第四步：改写为匿名内部类

public class TestLambda02 {
    public static void main(String[] args) {
        //匿名内部类
        new ILove(){
            @Override
            public void love(int a) {
                System.out.println("i love you --> "+a+" times");
            }
        } .love(5);
    }
}

//接口
interface ILove{
    void love(int a);
}

最后一步：Lambda表达式

public class TestLambda02 {
    public static void main(String[] args) {
        //Lambda表达式
        ILove love=(int a)->{
                System.out.println("i love you --> "+a+" times");
        } ;
        love.love(6);
    }
}

//接口
interface ILove{
    void love(int a);
}

2.6 简化Lambda表达式

1）去掉参数类型

public class TestLambda02 {
    public static void main(String[] args) {
        //Lambda表达式
        //简化一：去掉参数类型
                ILove love=(a)->{
                System.out.println("i love you --> "+a+" times");
        } ;
        love.love(7);
    }
}

//接口
interface ILove{
    void love(int a);
}

2）去掉括号（）

public class TestLambda02 {
    public static void main(String[] args) {
        //Lambda表达式
        //简化二：去掉括号
        ILove love=a->{
            System.out.println("i love you --> "+a+" times");
        } ;
        love.love(8);
    }
}

//接口
interface ILove{
    void love(int a);
}

3）去掉 { }

public class TestLambda02 {
    public static void main(String[] args) {
        //Lambda表达式
        //简化三：去掉{ }
        ILove love=a->
            System.out.println("i love you --> "+a+" times");
        love.love(9);
    }
}

//接口
interface ILove{
    void love(int a);
}

2.7 总结

1.Lambda表达式当只有一行代码的情况下，才能简化成一行，即去{}， 如果有多行，则必须用代码块包裹

2.前提是接口为函数式接口（只有一个方法的接口）

3.多个参数也可以去掉参数类型，要去掉就都去掉，但必须加上括号