Java——多线程：Lamda表达式

多线程理解

继承Thread类

• 子类继承Thread类具备多线程能力
  
• 启动线程：子类对象.start()
  
• 不建议使用：避免oop单继承局限性
  

实现Runnable接口

• 实现接口Runnable具有多线程能力
  
• 启动线程：传入目标对象+Thread对象.start()
  
• 推荐使用：避免单继承局限性，可能一个对象被多个线程使用
  

多个线程同时操作同一个对象
问题：多个线程操作同一个资源，可能会出现资源冲突问题
实现Callable接口

• 实现Callable接口，需要返回值类型
  
• 重写call方法，需要抛出异常
  
• 创建目标对象
  
• 创建执行服务
  
• 提交执行
  
• 获取结果
  
• 关闭服务
  

静态代理
　　抽象角色：声明真实对象和代理对象的共同接口。
　　代理角色：代理对象角色内部含有对真实对象的引用，从而可以操作真实对象，同时代理对象提供与真实对象相同的接口以便在任何时刻都能够代替真实对象。
　　同时，代理对象可以在执行真实对象操作时，附加其他的操作，相当于对真实对象进行封装。
　　真实角色：代理角色所代表的真实对象，是我们最终要引用的对象。
Lamda表达式

学习前提：

为什么使用

• 避免匿名内部类定义过多
  
• 可以使代码更简洁
  
• 去掉无意义代码，留下核心逻辑
  

理解函数式接口
定义：只包含唯一一个抽象方法的接口，如：

1. public interface Runnable{
2.    public abstract void run();
3. }

复制代码

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

推导逻辑：

1. package JavaText.Text;
2. ​
3. public class LamdaTest {
4.    //3.静态内部类
5.    static class like2 implements ILike{
6.        public void lamda(){
7.            System.out.println("I like lamda2");
8.        }
9.    }
10. ​
11. ​
12.    public static void main(String[] args) {
13.        ILike like = new like();
14.        like.lamda();
15. ​
16.        like2 like2=new like2();
17.        like2.lamda();
18. ​
19.        //4.局部内部类
20.        class like3 implements ILike{
21.            public void lamda(){
22.                System.out.println("I like lamda3");
23.            }
24.        }
25.        like = new like3();
26.        like.lamda();
27. ​
28.        //5.匿名内部类，没有类的名称，必须借助接口或父类
29.        like =new ILike(){
30.            @Override
31.            public void lamda(){
32.                System.out.println("I like lamda4");
33.            }
34.        };
35.        like.lamda();
36. ​
37.        //6.lamda表达式
38.        like=()->{
39.            System.out.println("I like lamda5");
40.        };
41.        like.lamda();
42. ​
43. ​
44. ​
45.    }
46. }
47. //1.定义一个函数式接口
48. interface ILike{
49.    void lamda();
50. }
51. ​
52. //2.常用类
53. class like implements ILike{
54.    public void lamda(){
55.        System.out.println("I like lamda1");
56.    }
57. }

复制代码

1. Lamda表达式其实就是省略掉那些唯一不可变的东西，如在这一段代码当中：
2. //5.匿名内部类，没有类的名称，必须借助接口或父类
3.        like =new ILike(){
4.            @Override
5.            public void lamda(){
6.                System.out.println("I like lamda4");
7.            }
8.        };
9.        like.lamda();
10. ​
11.        //6.lamda表达式
12.        like=()->{
13.            System.out.println("I like lamda5");
14.        };
15.        like.lamda();
16. ----
17.    new ILike(){
18.            @Override
19.            public void lamda(),括号之前的代码都是唯一不可变的，因此可以省略，而括号之后的代码是自己定义的因此保留括号以后的代码在加上->即可。
20. ​

复制代码