设计模式

设计模式

---

变更履历

日期	版本	内容	作者	备注
2020/02/20	v1.00	初版做成	author	《Head first设计模式》总结

---

设计模式的目的：设计出弹性的，可复用的，可维护的系统

策略模式

定义了算法族，分别封装起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

• 设计原则
  1.找出应用中需要变化的，把它们独立出来
  2.针对接口编程，而不是针对实现编程
  3.多用组合，少用继承

观察者模式

定义了对象间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新

• 设计原则
  4. 为了交互对象之间的松耦合设计而努力

装饰者模式

动态地将责任附加到对象上。若要扩展功能，装饰者提供了比继承更有弹性的替代方案

• 设计原则
  5. 类应该对扩展开放，对修改关闭

工厂模式

工厂模式:定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让子类把实例化推迟到子类
抽象工厂模式:提供一个接口，用于创建相关或依赖对象的家族，而不是要明确指定具体类。

• 设计原则
  6. 要依赖抽象，不要依赖具体类

单件模式

确保一个类只有一个实例，并提供一个全局访问点

命令模式

将“请求”封装成对象，以便使用不同的请求，队列或者日志来参数化其他对象。命令模式也可支持撤销的操作。

适配器与外观模式

适配器模式：将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间
外观模式：提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统梗容易使用

• 设计原则
  7.最少只是原则：只和你的密友谈话

模板方法模式

在一个方法中定义一个算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以在不改变算法结构的情况下，重新定义算法中的某些步骤

• 好莱坞原则
  8.别调用我们，我们会调用你

迭代器与组合模式

迭代器模式：提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示
组合模式：允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理对象以及对象组合

• 设计原则
  8.一个类应该只有一个引起变化的原因

状态模式

允许对象在内部状态改变时改变它的行为。对象看起来好像修改了它的类

代理模式

为另一个对象提供一个替身或者占位符以控制对这个对象的访问

复合模式

几种模式在一起使用的模式
MVC(Model-View-Controller)模型，视图，控制器

/*呱呱叫 接口
**/
public interface Quackable extends QuackObservable(
	 public void quack();
)
/*
*鹅的适配器
*/
public class GooseAdater implements Quackable{
	Goose goose;
	public GooseAdater(Goose goose){
		this.goose=goose;
		}
	public void quack(){
	goose.honk();
	}
}
/*
*加入计数器 装饰者
*/
public class QuackCounter implements Quackable{
	Quackable duck;
	static int numberOfQuacks;
	public QuackCounter(Quackable duck){
		this.duck=duck;
	}
	public void quack(){
		duck.quack();
		numberOfQuacks++;
	}
	public static int getQuacks(){
		return numberOfQuacks;
	}

}
/*
*鹅的类
*/
public class Goose{
	public void honk(){
		System.out.println("honk");
	}
}
/*
*绿头鸭类
*加入观察者后
*/
public class MallardDuck implements Quackable{
	Observable observable;
	public MallardDuck(){
		observable=new Observable(this);	
	}
	public void quack(){
		System.out.println("Quack");
		notifyObservers();
	}
	public void registerObserver(Observer observer){
		observable.registerObserver(observer);
	}
	public void notifyObservers(){
		observable.notifyObservers();
	}
}
/*
*红头鸭类
*/
public class redheadDuck implements Quackable{
	public void quack(){
	System.out.println("Quack");
	}
}
/*
*鸭子生产工厂 抽象工厂
*/
public abstract class AbstractDuckFactory{
	public abstract Quackable createMallardDuck();
	public abstract Quackable createRedheadDuck();
}
public class CountingDuckFactory extends AbstractDuckFactory{
	public Quackable createMallardDuck(){
		return new QuackCounter(new MallardDuck());
	}
	public Quackable createRedheadDuck(){
		return new QuackCounter(new RedheadDuck());
	}
}
/*
*一群鸭子的
*/
public class Flock implements Quackable{
	ArrayList quackers=new ArrayList ();
	public void add(Quackable quacker){
		quackers.add(quacker);
	}
	public void quack(){
		Iterator iterator=quackers.iterator();//迭代器模式
		while(iterator.hasNext()){
			Quackerable quacker= (Qauckable)iterator.next();
			quacker.quack();
		}
	}
/*
*鸭子叫模拟器 主方法
*/
public class DuckSimulator{
	public static void main(stringp[] args){
		Ducksimulator simulator=new DuckSimulator();
		AbstractDuckFactory duckfactory=new CountingDuckFactory();
		simulator.simulate(duckfactory);
	}
	void simulate(AbstractDuckFactory duckfactory){//加入工厂参数
		//Quackable mallardDuck=new QuackCounter(new MallardDuck());
		Quackable mallardDuck=duckfactory.createMallardDuck();
		Quackable gooseDuck=new GooseAdater(new Goose());//适配器
		Flock flockOfDucks=new Flock();
		flockOfDucks.add(mallardDuck);
		flockOfDucks.add(gooseDuck);
		
		Flock flockOfRed=new Flock();
		Quackable red1=duckfactory.createRedheadDuck();
		Quackable red2=duckfactory.createRedheadDuck();
		Quackable red3=duckfactory.createRedheadDuck();
		flockOfRed.add(red1);
		flockOfRed.add(red2);
		flockOfRed.add(red3);
		//观察者
		Quackologist quackologist=new Quackologist();
		flockOfDucks.registerObserver(quackologist);
		simulate(flockOfDucks);
		
		simulate(flockOfRed);
		System.out.println(QuackCounter.getquacks());
	}
	void simulate(Quackable duck){
		duck.quack();
	}




}
/*
*加入观察者模式
*/
public interface QuackObservable{
	public void registerObserver(Observer observer);
	public void notifyObservers();
}
public class Observable implements QuackObservable{
	ArrayList observers=new ArrayList();
	QuackObservable duck;
	public Observable(QuackObservable duck){
		this.duck=duck;
	}
	public void registerObserver (Observer observer){
		observers.add(observer);
	}
	public void notifyObservers(){
		Iterator iterator=observers.iterator();
		while(iterator.haxNest()){
			Observer observer=(Observer)iterator.next();
			observer,update(duck);
		}
	}
}
/*
*观察者接口
*/
public interface Observer{
	public void update(QuackObservable duck){	
	}
}
/*
*观察者类
*/
public class Quackologist implements Observer{
	public void update(QuackObservable duck){
		System.out.println(duck+"just quacked.");
	}
}
}