多线程2

静态代理模式;
真实对象和代理对象都要实现一个接口
代理对象要代理真实角色
好处：

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

```java
//静态代理模式
//真实对象和代理对象都要实现一个接口
//代理对象要代理真实角色
//好处：代理对象可以做很多真实对象做不了的事情
//真实对象专注做自己的事情

public class StaticProxy {
	public static void main(String[] args) {
		You you=new You();//你要结婚
		//Runnable
		new Thread(()->	System.out.println("爱你")).start();
		
		//you.HappyMarry();
		new WeddingCompany(new You()).HappyMarry();
		
		
//		WeddingCompany wc=new WeddingCompany(you);
//		wc.HappyMarry();
//				
	}
}

interface Marry{
	//人间四大喜事：久干遇甘露，他乡遇故知，洞房花烛夜，金榜题名时
	void HappyMarry();
}

//真实角色
class You implements Marry{
	
	@Override
	public void HappyMarry() {
		// TODO Auto-generated method stub
		System.out.println("你要结婚了");
	}
}
//代理角色，帮助你结婚
class WeddingCompany implements Marry{
	//真实目标角色
	private Marry target;
	
	
	public WeddingCompany(Marry target) {
		// TODO Auto-generated constructor stub
		this.target = target;
	}
	
	@Override
	public void HappyMarry() {
		// TODO Auto-generated method stub
		
		before();
		
		this.target.HappyMarry();
		after();
		
	}
	private void after() {
		// TODO Auto-generated method stub
		System.out.println("结婚之前，布置现场");
	}
	private void before() {
		// TODO Auto-generated method stub
		System.out.println("结婚之后，收尾款");
	}
	
	
}

Lamda表达式：

1. 避免匿名内部类定义过多
2. 可以使你的代码看起来简洁
3. 去掉了一堆没有意义的代码，只留下核心的逻辑

new Thread(()-> System.out.println(“爱你”)).start();

函数式接口的定义：

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

public interface Runnable{
	public  abstract run();
}

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

//推导lamda表达式
public class TestLamda1 {
	
	
	//3.静态内部类
	
	static class Like1 implements ILike{

		@Override
		public void lamda() {
			// TODO Auto-generated method stub
			System.out.println("I Like Lamda1");
		}
		
	}
	
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ILike i=new Like();
		i.lamda();
		i=new Like1();
		i.lamda();
		
		
		//4.局部内部类
		class Like2 implements ILike{

			@Override
			public void lamda() {
				// TODO Auto-generated method stub
				System.out.println("I Like Lamda2");
			}
			
		}
		
		i=new Like2();
		i.lamda();
		
		//5.匿名内部类:没有类的名称，必须接口或者父类
		i=new ILike() {

			@Override
			public void lamda() {
				// TODO Auto-generated method stub
				System.out.println("I Like Lamda3");
			}
			
		};
		i.lamda();
		
		//6.用Lamda简化
		i=() ->{
			// TODO Auto-generated method stub
			System.out.println("I Like Lamda4");
		};
		i.lamda();
	}

}


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

//2.实现类：
class Like implements ILike{

	@Override
	public void lamda() {
		// TODO Auto-generated method stub
		System.out.println("I Like Lamda");
	}
	
}

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

public class TestLamda2 {
	
	
	
	
	
	public static void main(String[] args) {
		
		
			
			
			
		//Lamda表达式简化
		// TODO Auto-generated method stub
		ILove ilove=(int a) ->{
				// TODO Auto-generated method stub
				System.out.println("I love you -->"+a);
			};
		//简化1：去掉参数类型
		ilove=(a)->{
			// TODO Auto-generated method stub
			System.out.println("I love you -->"+a);};
		//简化2：简化括号
		ilove=a->{
			// TODO Auto-generated method stub
			System.out.println("I love you -->"+a);};
			
		//简化3：去掉花括号
		ilove=a->System.out.println("I love you -->"+a);	
			
		ilove.love(521);
		
		
	}

}

interface ILove{
	void love(int a);
}