• Day26-龟兔赛跑案例、Callable接口、静态代理、Lambda表达式

    Day26

    案列：赛跑

    需求：

    • 首先来个赛道距离，然后要离终点越来越近
    • 判断比赛是否结束
    • 打印出胜利者
    • 龟兔赛跑开始
    • 故事乌龟赢得了比赛，兔子需要睡觉，所以我们要模拟兔子睡觉
    • 最后乌龟赢得比赛
    package com.ghy.demo01;
//模拟龟兔赛跑
public class Race implements Runnable{
    //唯一的胜者
    private static String winner;

    @Override
    public void run() {
        for (int i = 0; i <=100; i++) {
            //模拟小赵要跑到终点的时候睡觉
            if(Thread.currentThread().getName().equals("小赵")&& i%80==0){
                try {
                    Thread.sleep(1);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            //判断比赛是否结束
            boolean flag =gameover(i);
            //如果flag为真，就比赛结束，停止程序
            if(flag){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");

        }
    }
    //判断是否完成比赛
    private boolean gameover(int steps){
        //判断是否有胜利者
        if(winner!=null){//存在胜利者
            return true;
        }{
            if(steps>=100){//步数有一百步了
                winner = Thread.currentThread().getName();//获取当前线程名字
                System.out.println("赢的是"+winner);
                return true;
            }
        }
        return false;//如果没有则比赛继续
    }

    public static void main(String[] args) {
        //定义一条赛道
        Race race =new Race();

        new Thread(race,"小赵").start();
        new Thread(race,"小龚").start();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50

    输出

    第80步的时候发生休息

    在这里插入图片描述

    最后赢得是小龚

    在这里插入图片描述

    实现Callable借口（了解即可）

    在这里插入图片描述

    package com.ghy.demo02;

import com.ghy.demo01.TestThread3;
import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;

//线程创建方式3：实现Callable接口
public class TestCallable implements Callable<Boolean>{
    private String url;//网络图片地址
    private String name;//保存的文件名

    public TestCallable(String url,String name){
        this.url =url;
        this.name =name;
    }
    @Override
    public Boolean call() {
        WebDownloader webDownloader =new WebDownloader();
        webDownloader.downloader(url,name);//调用下载方法,需要传入url和name
        System.out.println("下载的图片名为:"+name);
        return true;
    }

    //main方法
    public static void main(String[] args) throws ExecutionException,InterruptedException {
        //创建线程对象
        TestCallable t1 =new TestCallable("https://img.zcool.cn/community/01029d5a4d960da801206ed375eaa8.jpg@1280w_1l_2o_100sh.jpg","可爱的小赵1.jpg");
        TestCallable t2 =new TestCallable("https://img.zcool.cn/community/01029d5a4d960da801206ed375eaa8.jpg@1280w_1l_2o_100sh.jpg","可爱的小赵2.jpg");
        TestCallable t3 =new TestCallable("https://img.zcool.cn/community/01029d5a4d960da801206ed375eaa8.jpg@1280w_1l_2o_100sh.jpg","可爱的小赵3.jpg");

        //创建执行服务
        ExecutorService ser = Executors.newFixedThreadPool(3);//线程池
        //提交执行
        Future<Boolean> r1 =ser.submit(t1);
        Future<Boolean> r2 =ser.submit(t2);
        Future<Boolean> r3 =ser.submit(t3);
        //获取结果
        boolean rs1 = r1.get();//需要抛出异常，throws ExecutionException,InterruptedException
        boolean rs2 = r2.get();
        boolean rs3 = r3.get();
        //打印返回值
        System.out.println(rs1);
        System.out.println(rs2);
        System.out.println(rs3);
        //关闭服务
        ser.shutdown();
    }
}
//下载器
class WebDownloader{
    //下载方法
    public  void downloader(String url, String file){
        try {
            FileUtils.copyURLToFile(new URL(url), new File(file));//记得Alt+Enter导包
        }//捕获异常
        catch (IOException e) {
            e.printStackTrace();
            System.out.println("IO异常，download方法出现问题，需要小赵帮助");
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65

    输出

    下载的图片名为:可爱的小赵3.jpg
下载的图片名为:可爱的小赵1.jpg
下载的图片名为:可爱的小赵2.jpg
true
true
true

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    Callable的好处：

    • 可以定义返回值
    • 可以抛出异常

    静态代理模式

    package com.ghy.demo03;

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("婚礼现场，你结婚了！");
    }
}
//代理角色，帮助你结婚
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 before(){
        System.out.println("发请柬，布置婚礼现场");
    }
    private void after(){
        System.out.println("结账，收尾款");
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    输出

    发请柬，布置婚礼现场
婚礼现场，你结婚了！
结账，收尾款

    • 1
    • 2
    • 3

    总结

    1. 真实对象和代理对象都要实现同一个借口（这里“你”和“婚庆公司”都是实现的Marry这个接口）

    2. 代理对象要代理真实角色

    好处：

    1. 代理对象可以做真实对象做不了的事情
    2. 真实对象专注做自己的事情

    Lambda表达式

    在这里插入图片描述

    在这里插入图片描述

    • 理解函数式接口的定义

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

      在这里插入图片描述

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

    • 推导

    package com.ghy.demo04;
/*
推导Lambda表达式
 */
public class TestLambda1 {
    //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 Like1();
        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.实现类
class Like1 implements Ilike{
    @Override
    public void lambda() {
        System.out.println("I Like Lambda");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    输出

    I Like Lambda
I Like Lambda2
I Like Lambda3
I Like Lambda4
I Like Lambda5

    • 1
    • 2
    • 3
    • 4
    • 5
    • 代参数
    package com.ghy.demo04;

public class TestLambda2 {
    //3.静态内部类
    static class Love2 implements Ilove{
        @Override
        public void love(String a) {
            System.out.println("I Love "+a);
        }
    }
    public static void main(String[] args) {
        Ilove ilove =new Love1();
        ilove.love("金小赵");

        ilove = new Love2();
        ilove.love("木小赵");
        //4.局部内部类
        class Love3 implements Ilove{
            @Override
            public void love(String a) {
                System.out.println("I Love "+a);
            }
        }
        ilove = new Love3();
        ilove.love("水小赵");
        //5.匿名内部类
        ilove = new Ilove(){
            @Override
            public void love(String a) {
                System.out.println("I Love "+a);
            }
        };
        ilove.love("火小赵");
        //6.lambda
        ilove = (String a)->{System.out.println("I Love "+a);};
        ilove.love("土小赵");
    }
}
//1.定义一个函数式接口
interface Ilove{
    void love(String a);
}
//2.实现类
class Love1 implements Ilove{
    @Override
    public void love(String a) {
        System.out.println("I Love "+a);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    输出

    I Love 金小赵
I Love 木小赵
I Love 水小赵
I Love 火小赵
I Love 土小赵

    • 1
    • 2
    • 3
    • 4
    • 5
    • 简化lambda
    package com.ghy.demo04;

public class TestLambda3 {
    public static void main(String[] args) {
        //2.lambda
        Ieat eat = (String a)->{
            System.out.println("我喜欢吃"+a);
        };
        eat.eat("红烧排骨");

        //3.lambda简化参数类型
        eat =(a)->{
            System.out.println("我喜欢吃"+a);
        };
        eat.eat("红烧肉");
        //4.lambda简化括号
        eat =a -> {
            System.out.println("我喜欢吃"+a);
        };
        eat.eat("红烧猪蹄");
        //5.简化大括号
        eat =a -> System.out.println("我喜欢吃"+a);
        eat.eat("红烧排骨");
    }
}
//1.定义函数式接口
interface Ieat{
    void eat(String a);
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    输出

    我喜欢吃红烧排骨
我喜欢吃红烧肉
我喜欢吃红烧猪蹄
我喜欢吃红烧排骨

    • 1
    • 2
    • 3
    • 4

    总结

    • lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行，那么就用代码块包裹。
    • 前提是接口是函数式接口
    • 多个参数都可以去掉参数类型（要去掉都去掉，必须加上括号）
  • 相关阅读:
    从乘法求导法则到BPTT算法
    网络问题排障专题-AF网络问题排障
    IMAGEBIND: One Embedding Space To Bind Them All论文笔记
    JSP 购物商城系统eclipse定制开发mysql数据库BS模式java编程servlet
    动力环境监控是什么?动力环境监控系统包括哪些设备
    HTTP/2和HTTP/3特性介绍
    thinkphp中区块block和模板继承extend用法举例,和公共头部
    【vue3/高德地图】实现地图打点/自定义点位图标/地理围栏实现
    【C++】搜索二叉树面试oj题
    OCR技术：解决图片转excel表格的方案与技巧
  • 原文地址：https://blog.csdn.net/GHY0911/article/details/126238676