设计模式——HeadFirst

《Head First》设计模式

策略模式

封装可以互换的行为，并使用委托来决定要使用哪一个。

public interface FlyBehavior{
	void fly();
}
public FlyWithWings implements FlyBehavior{
	public void fly(){
		System.out.println("用翅膀飞");
	}
}
public FlyNoWay implements FlyBehavior{
	public void fly(){
		System.out.println("不会飞");
	}
}

public class Duck{
	FlyBehavior flyBehavior;
	public void performFly(){
		flyBehavior.fly();
	}
}
public class DuckA extends Duck{
	public DuckA(FlyBehavior flyBehavior){
		this.flyBehavior = flyBehavior;  
	}
}

观察者模式

让对象能够在状态改变时被通知。
出版者+订阅者=观察者模式

//出版者
public interface Subject{
	void registerObserver(Observer o);
    void removeObserver(Observer o);
	void notifyObserver();
}
//订阅者
public interface Observer{
	void notify();
}

public A implements Subject{
	private ArrayList<Observer> observers;
	public void registerObserver(Observer o){
		observers.add(o);
	}
	public void removeObserver(Observer o){
		int i = observers.indexOf(o);
		if(i>=0){
			observers.remove(i);
		}
	}
	public void notifyObserver(){
		observers.forEach(each->each.notify())
	}
}

装饰模式

包装一个对象，以提供新的行为。

public interface A{
	String getDescription();
	double cost();
}
public class B implements A{
	A a;
	public B(A a){
		this.a = a;
	}
	public String getDescription(){
		return a.getDescription() + "b的描述";
	}
	public double cost(){
	 	return a.cost() + 5;
	}
}

个人理解：装饰模式中被装饰对象和装饰对象都实现一样的接口或继承一样的抽象类，在装饰类中引用被装饰对象，实现装饰类方法时需要依靠被装饰对象的参与。

单件模式

确保有且只有一个对象被创建。构造方法声明为private，无法通过new实例化对象，只能通过类提供的静态方法获取实例变量。

public class Singleton{
	private static Singleton instance;
	private Singleton(){}
	public static Singleton getInstance(){
		if(instance==null){
			instance = new Singleton();
		}
		return instance;
	}
}

处理多线程时，把getInstance变成同步方法：

public class Singleton{
	private static Singleton instance;
	private Singleton(){}
	public static synchronized Singleton getInstance(){
		if(instance==null){
			instance = new Singleton();
		}
		return instance;
	}
}

或者，用另一种方式，“急切”创建实例，而不用延迟实例化的做法。

public class Singleton{
	private static Singleton instance = new Singleton();
	private Singleton(){}
	public static Singleton getInstance(){
		return instance;
	}
}

同步方法虽然可以确保只有一个实例，但是会增加时间损耗，用“双重检查加锁”，在getInstance中减少使用同步。

public class Singleton{
	private static Singleton instance;
	private Singleton(){}
	public static Singleton getInstance(){
	    if(instance==null){
			synchronized(Singleton.class){
				if(instance==null)
					instance=new Singleton();
			}
		}
		return instance;
	}
}

代理模式

包装对象，以控制对此对象的访问。

模板模式

由子类决定如何实现一个算法中的步骤。

外观模式

简化一群类的接口。

适配器模式

封装对象，并提供不同的接口。

命令模式

封装请求成为对象。

迭代器模式

在对象的集合中游走，而不暴露集合的实现。

组合模式

客户用一致的方式处理对象集合和单个对象。

状态模式

封装了基于状态的行为，并使用委托来决定要使用哪一个。

工厂方法

由子类决定要创建的具体类是哪一个。

抽象工厂

允许客户创建对象的家族，而无需指定他们的具体类。

时间问题，暂时分享上述设计模式，后续补全。