接着写06(第二部分)

 

接着写06

线程创建方式3：实现Callable接口(了解即可)@扩充

1. 实现Callable接口，需要返回值类型

2. 重写call方法，需要抛出异常

3. 创建目标对象

4. 创建执行服务:ExecutorService ser = Executors.newFixedThredPool(1);

5. 提交执行:Future<Boolean> result1 = ser.submit(t1);

6. 获取结果:boolean r1 = result1.get()

7. 关闭服务: ser.shutdownNow();

 package com.wsk.demo02;
 ​
 import org.apache.commons.io.FileUtils;
 ​
 import java.io.File;
 import java.net.URL;
 import java.util.concurrent.*;
 ​
 //线程创建方式三：实现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);
         System.out.println("线程下载了，文件名为："+name);
         return true;
     }
 ​
     public static void main(String[] args) throws ExecutionException, InterruptedException {
         TestCallable Y1 = new TestCallable("https://ttpcstatic.dftoutiao.com/ecms/image/20220619/660x448_62ae77c3c0547.jpeg_.webp","1好看.jpg");
         TestCallable Y2 = new TestCallable("https://ttpcstatic.dftoutiao.com/ecms/image/20220619/660x448_62ae77c3c0547.jpeg_.webp","2好看.jpg");
         TestCallable Y3 = new TestCallable("https://ttpcstatic.dftoutiao.com/ecms/image/20220619/660x448_62ae77c3c0547.jpeg_.webp","3好看.jpg");
 ​
           //创建执行服务:
           ExecutorService ser = Executors.newFixedThreadPool(3);
 ​
           //提交执行:
           Future<Boolean> r1 = ser.submit(Y1);
           Future<Boolean> r2 = ser.submit(Y2);
           Future<Boolean> r3 = ser.submit(Y3);
 ​
           //获取结果:
           boolean rs1 = r1.get();
           boolean rs2 = r2.get();
           boolean rs3 = r3.get();
 ​
         System.out.println(rs1);
         System.out.println(rs2);
         System.out.println(rs3);
 ​
           //关闭服务:
           ser.shutdownNow();
     }
 }
 ​
 //下载器
 class WebDownloader{
     //下载方法
     public void downloader(String url,String name){
         try {
             FileUtils.copyURLToFile(new URL(url),new File(name));
         }catch (Exception e){
             e.printStackTrace();
             System.out.println("IO异常，downloader方法出现问题");
         }
     }
 }

 

Lamda表达式***

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

• 避免匿名内部类定义过多

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

 (params)->expression[表达式]
     (params)->statement[语句]
     (params)->{statements}

a-> System.out.println("i like lambda" + a);

 new Thread (()->System.out.printIn(“多线程学习。。。。")) .start();

 

• 为什么要使用Lambda表达式

  • 避免匿名内部类定义过多

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

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

• 也许你会说，我看了Lambda表达式，不但不觉得简洁，反而觉得更乱，看不懂了。那是因为我们还没有习惯，用的多了，看习惯了，就好了。

 

Lambda表达式

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

• 函数式接口的定义：

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

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

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

 

lambda简化代码流程

 package com.wsk.lambda;
 ​
 public class TestLambda1 {
     //2静态内部类
     static class love2 implements ILove{
         @Override
         public void lambda(int a) {
             System.out.println("i love you-->"+a);
         }
     }
 ​
     public static void main(String[] args) {
         //打印实体类
         ILove love = new love();
         love.lambda(1);
         //打印静态内部类
         ILove iLove = new love2();
         iLove.lambda(2);
 ​
 ​
         //3.局部内部类
         class love3 implements ILove{
             @Override
             public void lambda(int a) {
                 System.out.println("i love you-->"+a);
             }
         }
         love = new love3();
         love.lambda(3);
 ​
         //4.匿名内部类,没有类的名称，必须借助接口或者父类
         love = new ILove() {
             @Override
             public void lambda(int a) {
                 System.out.println("i love you-->"+a);
             }
         };
         love.lambda(4);
 ​
         //5.1用lambda简化
         love = (int a)->{
             System.out.println("i love you-->"+a);
         };
         love.lambda(520);
 ​
         //5.2基础上用lambda再简化
         love = (a)->{
             System.out.println("i love you-->"+a);
         };
         love.lambda(521);
 ​
         //5.3基础上用lambda再简化
         love = a->{
             System.out.println("i love you-->"+a);
             System.out.println("i love you-->too");
         };
         love.lambda(522);
 ​
         //5.3基础上用lambda再简化,去掉花括号
         love = a-> System.out.println("i love you-->"+a);
         love.lambda(523);
 ​
         /*
         总结：
           1.lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。代码块{}
           2.前提是接口必须是函数式接口（接口里只有一个方法）
           3.多个参数也可以去掉参数类型，要去掉就都去掉,必须加上括号，
         */
 ​
     }
 ​
 }
 //函数式接口
 interface ILove{
     void lambda(int a);
 }
 ​
 //1实体类
 class love implements ILove{
     @Override
     public void lambda(int a) {
         System.out.println("i love you-->"+a);
     }
 }

运用

 package com.wsk.lambda;
 ​
 /*
 推导lambda表达式
  */
 public class TestLambda3 {
 ​
     public static void main(String[] args) {
 ​
         //单行数据
         /*ILike like = null;
         //最简化，也可以多行，但是多行必须有{}代码块，类型统一，去的话都去掉
         Like = a-> System.out.println("i like you-->"+a);
         Like.lambda(521);*/
 ​
         //多行数据
         ILike like = null;//可以是null ，也可以是new like
         like = (a,b)->{
             System.out.println("i like you-->"+a);
             System.out.println("i like you-->"+b);
         };
         like.lambda(520,250);
     }
 }
 ​
 ​
 //1.定义一个函数式接口
 interface ILike{
     void lambda(int a,int b);
 }
 ​
 //2.实现类
 class like implements ILike{
 ​
     @Override
     public void lambda(int a ,int b) {
         System.out.println("i like lambda"+a);
         System.out.println("i like lambda"+b);
     }
 }

总结：

 1.lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹。代码块{}
 2.前提是接口必须是函数式接口（接口里只有一个方法）
 3.多个参数也可以去掉参数类型，要去掉就都去掉,必须加上括号，

 

 

07静态代理

• 你:真实角色

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

• 结婚:实现都实现结婚接口即可

  • 演示:实现静态代理对比Thread

 package com.wsk.proxystatic;
 ​
 public class StaticProxy {
     public static void main(String[] args) {
         You you = new You();//你要结婚
         
         new Thread( ()-> System.out.println("线程开启：我爱你") ).start();
 ​
         new Hunqing(you).HappyJiehun();
 ​
 ​
 //        Hunqing hunqing = new Hunqing(you);
 //        hunqing.HappyJiehun();
     }
 }
 ​
 interface Jiehun{
     //人间四大喜事
         //久旱逢甘霖
         //他乡遇故知
         //润房花烛夜
         //金榜题名时
     void HappyJiehun();
 }
 ​
 //真实角色，你去结婚
 class You implements Jiehun{
 ​
     @Override
     public void HappyJiehun() {
         System.out.println("你要结婚了，超开心");
     }
 }
 ​
 //代理角色，帮助你结婚
 class Hunqing implements Jiehun{
     //ni 目标  代理谁--> 真实目标角色
     private Jiehun ni;
 ​
     public Hunqing(Jiehun ni) {
         this.ni = ni;
     }
 ​
     @Override
     public void HappyJiehun() {
         before();
         this.ni.HappyJiehun();//这就是真实对象
         after();
     }
 ​
     private void before() {
         System.out.println("结婚前：布置场景，置办用品");
     }
     private void after() {
         System.out.println("结婚后：送入洞房，回家睡觉");
     }
 }

 //静态代理模式总结：
 /*
     1.真实对象与代理对象都要实现同一个接口
     2.代理对象要代理真实角色
 好处：
     代理对象可以做很多真实对象做不了的事情
     真实对象专注做自己的事情
  */