设计模式（记录用）

在看网课的时候看到的，上面只是很简单的介绍，后续一直补充

静态代理设计模式

静态代理模式要有一个真实角色，一个代理角色，他们两个都要实现同一个接口。
作用：记录日志，监控。。。

package ThreadClass;
/**
 * 静态代理
 * 1，真实角色
 * 2，代理角色
 * 1，2要实现同一个接口
 * TODO
 * @version 1.0
 * @author 王星宇
 */
public class testDesign {
	public static void main(String[] args) {
		new WeddingCompany(new You()).happyMarry();
	}
}
//接口
interface Marry{
	void happyMarry();
}
//真实角色
class You implements Marry{
	public void happyMarry() {
		System.out.println("你说：我愿意");
	}
}
//代理角色
class WeddingCompany implements Marry{
	private Marry y;
	public WeddingCompany(Marry y) {
		this.y = y;
	}
	public void happyMarry(){
		System.out.println("公司布置婚礼");
		y.happyMarry();
		System.out.println("婚后一条龙服务");
	}
}

装饰器设计模式

装饰器设计模式要用一个接口，叫做抽象组件，具体组件和抽象装饰类实现抽象组件，具体装饰类实现抽象组件。

• 测试装饰器设计模式
• 1,抽象组件：需要装饰的抽象对象（接口或抽象父类）
• 2,具体组件：需要装饰的类（人）
• 3,抽象装饰类： 包含了对抽象组件的引用以及修饰共有的方法
• 4，具体装饰类：被装饰的对象

作用：用另一个类给这个类加上某些“效果”，例如装饰流让节点流效率更高，处理的数据更多样等。

package javaClass;
/**
 * 测试装饰器设计模式
 * 1,抽象组件：需要装饰的抽象对象（接口或抽象父类）
 * 2,具体组件：需要装饰的类（人）
 * 3,抽象装饰类： 包含了对抽象组件的引用以及修饰共有的方法
 * 4，具体装饰类：被装饰的对象
 * TODO
 * @version 1.0
 * @author 王星宇
 */
public class testDecotate {
	public static void main(String[] args) {
		Drink coffee = new Coffee();
		Drink suger = new Suger(coffee);
		System.out.println(suger.info() + "-->" + suger.cost());
		Drink milk = new Malk(suger);
		System.out.println(milk.info() + "-->" + milk.cost());
	}
}
//抽象组件
interface Drink{
	double cost();
	String info();
}
//具体组件
class Coffee implements Drink{
	
	private String name = "瑞星咖啡";
	@Override
	public double cost() {
		return 10;
	}

	@Override
	public String info() {
		return name;
	}
	
}
//抽象装饰类
abstract class Decorate implements Drink{

	private   Drink drink;
	public Decorate(Drink drink) {
		this.drink = drink;
	}
	@Override
	public double cost() {
		return drink.cost();
	}

	@Override
	public String info() {
		return drink.info();
	}
	
}
//具体装饰类
class Malk extends Decorate{
	
	public Malk(Drink drink) {
		super(drink);
	}
	@Override
	public double cost() {
		return super.cost() * 4;
	}

	@Override
	public String info() {
		return super.info() + "加入了牛奶";
	}
	
}
//具体装饰类
class Suger extends Decorate{
	
	public Suger(Drink drink) {
		super(drink);
	}
	@Override
	public double cost() {
		return super.cost() * 2;
	}

	@Override
	public String info() {
		return super.info() + "加入了糖";
	}
	
}

单例模式

多线程情况下，对内不管，对外只有一个对象。

dcl(double checking locking)

package ThreadClass;
/**
 * 单例模式（dcl）
 * 懒汉式（声明的时候实例化时饿汉式）
 * 1,构造器私有化-->避免外部new构造器
 * 2,提供私有的静态属性-->存储对象地址
 * 3,提供公有的静态方法-->获取属性
 * @author 王星宇
 * @date 2020年2月18日
 */
public class DoubleCheckedLock {
//	2,提供私有的静态属性
	private static volatile DoubleCheckedLock instance;//加volatile是为了防止指令重排，在新建对象的时候把没有初始化的对象返回。
//	1,构造器私有化
	private DoubleCheckedLock() {
	}
//	3,提供公有的静态方法
	public DoubleCheckedLock getInstance() {
		//double checking
		if(null != instance) {//避免不必要的同步，已经存在了对象
			return instance;
		}
		synchronized(DoubleCheckedLock.class) {
			if(null == instance) {
				instance = new DoubleCheckedLock();
			}
		}
		return instance;
	}
	public static void main(String[] args) {
	}
}