线程学习

4.27近几天总结

1.静态代理模式总结

真是对象（目标对象）都要实现同一个接口
代理对象要代理真实角色

好处：代理对象 可以做很多真实对象做不了的事情
真实对象可以做专注自己需要去做的事情
（重要）底部的实现原理

主函数
You you = new You();//你要结婚
        //Thread实现了Runnable接口 所以中间的是真实的Runnable接口
        //下两行的共同方法是run方法
        new Thread( ()-> System.out.println("下次一定")).start();
        new WeddingCompany(new You()).HappyMarry();
        /*//精简一下
        WeddingCompany weddingCompany = new WeddingCompany(you);
        //WeddingCompany weddingCompany = new WeddingCompany(new You());//或者直接写成这个样子
        weddingCompany.HappyMarry();
        */

比如结婚这件事情：结婚这是一个有整体步骤的事情（接口），

主角（真实角色）每个人都有自己结婚的事情要干（继承这个接口重写方法）

但是有个婚庆公司（代理角色）帮助你解决婚前布置，婚后收拾的工作（同样继承接口）

代理角色要针对这个人（里面要指明代理真实对象）设置一些方法（重写一个方法）办一些固定的事情【after(),before()】。

//实现一个接口（结婚这件事 ）
interface Marry {
    //人生四大喜事
    //久旱逢甘露
    //他乡遇故知
    //洞房花烛夜
    //金榜题名时

    void HappyMarry();
}

//真实角色，你去结婚
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();
    }
    private void after() {
        System.out.println("结婚之后，收尾款。");
    }
    public void before() {
        System.out.println("结婚之前布置现场。");
    }
}

2.Lambda表达式

直接看代码

//简化1：实现静态内部类
    static class Love2 implements ILove {
        @Override
        public void love(int a) {
            System.out.println("i love you2--》" + a);
        }
    }

    public static void main(String[] args) {
        //简化2：实现局部内部类
        class Love3 implements ILove {
            @Override
            public void love(int a) {
                System.out.println("i love you3--》" + a);
            }
        }

        ILove love = new Love();
        love.love(2);

        love = new Love2();
        love.love(2);

        love = new Love3();
        love.love(2);

        //简化3：匿名内部类
        love = new ILove() {
            @Override
            public void love(int a) {
                System.out.println("i love you4-->" + a);
            }
        };
        love.love(2);
        //简化4：使用Lambda,可以将类的实现一起省去（因为保留了核心的代码）
        love = (int a) -> {
            System.out.println("i love you5-->" + a);
        };
        love.love(520);

        //简化5：省去参数类型
                love = (a) -> {
                    System.out.println("i love you6-->" + a);
                };
                love.love(250);
        //简化6：省去括号
        love = a -> {
            System.out.println("i love you7-->" + a);
        };
        love.love(213);

        //简化6：省去花括号
        love = a -> System.out.println("i love you8-->" + a);
        love.love(521);
        /*总结：
        Lambda表达式表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。
        前提是接口为函数式接口
        多个参数也可以去掉参数类型，必须有括号包裹
        */
    }

//创建一个接口 中间包含一个参数
interface ILove {
    void love(int a);
}

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

每日一题

给定一个 n 个元素有序的（升序）整型数组 nums 和一个目标值 target ，写一个函数搜索 nums 中的 target，如果目标值存在返回下标，否则返回 -1。

示例 1:

输入: nums = [-1,0,3,5,9,12], target = 9
输出: 4
解释: 9 出现在 nums 中并且下标为 4

示例 2:

输入: nums = [-1,0,3,5,9,12], target = 2
输出: -1
解释: 2 不存在 nums 中因此返回 -1

class Solution {
    public int search(int[] nums, int target) {
        int left = 0, right = nums.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] > target) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
        
    }
}

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。