设计模式笔记（java版）

àì夳堔傛蜴生んèń 2022-06-18 09:50 154阅读 0赞

### 欢迎关注“**程序杂货铺**”公众号，里面有精彩内容，欢迎大家收看^\_^ ###

# 设计模式笔记 #

## 1、单例模式 ##

定义：

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

类图：

![Center][]

源代码：

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

## 2、工厂模式 ##

定义：

工厂模式定义了一个创建对象的接口，由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

### (1). 简单工厂模式 ###

类图：

![Center 1][]

源代码：

public abstract class Product {
    	public void method1() {
    	}
    	public void method2() {
    	}
    }
    public class Product_A extends Product{
    	public Product_A() {
    	}
    	public void method1() {
    		System.out.println("this is method1 in Product_A");
    	}
    	public void method2() {
    		System.out.println("this is method2 in Product_A");
    	}
    }
    public class Product_B extends Product{
    	public Product_B() {
    	}
    	public void method1() {
    		System.out.println("this is method1 in Product_B");
    	}
    	public void method2() {
    		System.out.println("this is method2 in Product_B");
    	}
    }
    public class SimpleFactory {
    	public Product createProduct(String type) {
    		Product product = null;
    		if(type.equals("Product_A")){
    			product = new Product_A();
    		}else if (type.equals("Product_B")) {
    			product = new Product_B();
    		}
    		return product;
    	}
    }

### (2). 抽象工厂模式 ###

类图：

![Center 2][]

源代码：

public interface Product {
    	public void method1();
    	public void method2();
    }
    public class Product_A implements Product {
    	@Override
    	public void method1() {
    		System.out.println("this is method1 in Product_A");
    	}
    	@Override
    	public void method2() {
    		System.out.println("this is method2 in Product_A");
    	}
    }
    public class Product_B implements Product {
    	@Override
    	public void method1() {
    		System.out.println("this is method1 in Product_B");
    	}
    	@Override
    	public void method2() {
    		System.out.println("this is method2 in Product_B");
    	}
    }
    public interface AbstractFactory {
    	public Product getProduct();
    }
    public class Product_A_Factoty implements AbstractFactory {
    	@Override
    	public Product getProduct() {
    		return new Product_A();
    	}
    }
    public class Product_B_Factory implements AbstractFactory {
    	@Override
    	public Product getProduct() {
    		return new Product_B();
    	}
    }

## 3、策略模式 ##

定义：

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

类图：

![Center 3][]

源代码：

public abstract class Processor {
    	public Object process(Object obj){
    		return obj;
    	} 
    }
    /**
     * ConcreteProcessor
     * */
    public class Upcase extends Processor{
    	public String process(Object obj){
    		return ((String)obj).toUpperCase();
    	} 
    }
    /**
     * ConcreteProcessor
     * */
    public class Downcase extends Processor{
    	public String process(Object obj){
    		return ((String)obj).toLowerCase();
    	} 
    }
    public class Strategy {
    	public void process(Processor p,Object obj) {
    		System.out.println(p.process(obj));
    	}
    }

## 4、观察者模式 ##

定义：

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

类图：

![Center 4][]

源代码：

public interface Subject {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObserver(); //当主题状态改变时，该方法会被调用，以通知所有的观察者
    }
    public class ConcreteSubject implements Subject {
    	private List<Observer> observers;
    	private String parameter;
    	public ConcreteSubject() {
    		this.observers = new ArrayList<>();
    	}
    	@Override
    	public void registerObserver(Observer o) {
    		this.observers.add(o);
    	}
    @Override
    	public void removeObserver(Observer o) {
    		this.observers.remove(o);
    	}
    @Override
    	public void notifyObserver() {
    		int i,n;
    		n = this.observers.size();
    		for(i = 0;i < n;i++){
    			Observer observer = this.observers.get(i);
    			observer.update(parameter);
    		}
    	}
    public void setParameter(String parameter) {
    		this.parameter = parameter;
    		notifyObserver();
    	}
    }
    public interface Observer {
    	public void update(String parameter);
    }
    public class ConcreteObserver implements Observer {
    	private String parameter;
    	private Subject subject;
    	public ConcreteObserver(Subject subject) {
    		this.subject = subject;
    		this.subject.registerObserver(this);
    	}
    	@Override
    	public void update(String parameter) {
    		this.parameter = parameter;
    		display();
    	}
    	public void display() {
    		System.out.println("Current state : " + parameter);
    	}
    }

## 5、装饰者模式 ##

定义：

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

类图：

![Center 5][]

源代码：

public abstract class Component {
    	protected String description = "Component";
    	public String getDescription() {
    		return description;
    	}
    }
    public class ConcreteComponent_A extends Component{
    	public ConcreteComponent_A() {
    		description = "ConcreteComponent_A";
    	}
    	public String getDescription() {
    		return description;
    	}
    }
    public class ConcreteComponent_B extends Component{
    	public ConcreteComponent_B() {
    		description = "ConcreteComponent_B";
    	}
    	public String getDescription() {
    		return description;
    	}
    }
    public abstract class Decorator extends Component{
    	public abstract String getDescription();
    }
    
    public class ConcreteDecorator_A extends Decorator{
    	Component component;
    	public ConcreteDecorator_A(Component component) {
    		this.component = component;
    	}
    	@Override
    	public String getDescription() {
    		return component.getDescription() + ", ConcreteDecorator_A";
    	}
    }
    public class ConcreteDecorator_B extends Decorator{
    	Component component;
    	public ConcreteDecorator_B(Component component) {
    		this.component = component;
    	}
    	@Override
    	public String getDescription() {
    		return component.getDescription() + ", ConcreteDecorator_B";
    	}
    }

## 6、命令模式 ##

定义：

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

类图：

![Center 6][]

源代码：

public interface Command {
    	public void execute();
    }
    /** 
    * 起到ConcreteCommand的作用
     * */
    public class LightOnCommand implements Command {
    	private Light light;
    	public LightOnCommand(Light light) {
    		this.light = light;
    	}
    	@Override
    	public void execute() {
    		light.on();
    	}
    }
    /** 
    * 起到ConcreteCommand的作用
     * */
    public class LightOffCommand implements Command {
    	private Light light;
    	public LightOffCommand(Light light) {
    		this.light = light;
    	}
    	@Override
    	public void execute() {
    		light.off();
    	}
    }
    /** 
    * 起到Receiver的作用
     * */
    public class Light {
    	private boolean light;
    	private String name;
    	public Light(String name) {
    		this.name = name;
    	}
    	public void on() {
    		light = true;
    	}
    	public void off() {
    		light = false;
    	}
    	@Override
    	public String toString() {
    		return "Light [name = " + name + ", is = " + light + "]";
    	}
    }
    public class Invoker {
    	private Command[] onCommands;
    	private Command[] offCommands;
    	public Invoker() {
    		onCommands = new Command[2];
    		offCommands = new Command[2];
    		for(int i = 0;i < 2;i++){
    			onCommands[i] = null;
    			offCommands[i] = null;
    		}
    	}
    	public void setCommand(int index,Command on,Command off) {
    		onCommands[index] = on;
    		offCommands[index] = off;
    	}
    	public void onButtonWasPushed(int index) {
    		onCommands[index].execute();
    	}
    	public void offButtonWasPushed(int index) {
    		offCommands[index].execute();
    	}
    	@Override
    	public String toString() {
    		String str = "";
    		for(int i = 0;i < onCommands.length;i++){
    str += "index "+i+" : "+onCommands[i].getClass().getName()+" "+offCommands[i].getClass().getName()+"\n";
    		}
    		return str;
    	}
    	
    }

## 7、适配器模式 ##

定义：

将一个类的接口，转换成客户期望的另一个接口。适配器让原本接口不兼容的类可以合作无间。

类图：

![Center 7][]

源代码:

public interface Target {
    	public void request();
    }
    public class RealTarget implements Target {
    	@Override
    	public void request() {
    		System.out.println("this is real do.");
    	}
    }
    public class Adaptee {
    	public void doing() {
    		System.out.println("this is Adaptee_do.");
    	}
    }
    public class Adapter implements Target {
    	private Adaptee adaptee;
    	public Adapter(Adaptee adaptee) {
    		this.adaptee = adaptee;
    	}
    	@Override
    	public void request() {
    		adaptee.doing();
    	}
    }

## 8、外观模式 ##

定义：

提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。

类图：

![Center 8][]

## 9、模板方法模式 ##

定义：

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

类图：

![Center 9][]

源代码：

public abstract class AbstractClass {
    	final void templateMethod(){
    		primitiveOperation1();
    		primitiveOperation2();
    	}
    	abstract void primitiveOperation1();
    	abstract void primitiveOperation2();
    }
    public class ConcreteClass_A extends AbstractClass{
    	@Override
    	void primitiveOperation1() {
    		System.out.println("this is primitiveOperation1 in ConcreteClass_A");
    	}
    	@Override
    	void primitiveOperation2() {
    		System.out.println("this is primitiveOperation2 in ConcreteClass_A");
    	}
    }
    public class ConcreteClass_B extends AbstractClass{
    	@Override
    	void primitiveOperation1() {
    		System.out.println("this is primitiveOperation1 in ConcreteClass_B");
    	}
    	@Override
    	void primitiveOperation2() {
    		System.out.println("this is primitiveOperation2 in ConcreteClass_B");
    	}
    }

## 10、迭代器模式 ##

定义：

提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。

作用：

迭代器模式让我们能游走于聚合内的每一个元素，而又不暴露其内部的表示。将游走的任务放在迭代器上，而不是聚合上，这样简化了聚合的接口和实现，也让责任各得其所。

类图：

![Center 10][]

源代码：

public interface Aggregate {
    	public Iterator createIterator(); //我们使用java.util.Iterator作为Iterator类
    }
    public class ConcreteAggregate implements Aggregate {
    	List list;
    	public ConcreteAggregate() {
    		this.list = new ArrayList();
    		init();
    	}
    	public void init() {
    		addItem("first");
    		addItem("second");
    		addItem("third");
    	}
    	public void addItem(String parameter) {
    		list.add(parameter);
    	}
    	@Override
    	public Iterator createIterator() {
    		return list.iterator();
    	}
    }

## 11、组合模式 ##

定义：

允许将对象组合成树形结构来表现“整体/部分”层次结构。

作用：

组合能让客户以一致的方式处理个别对象以及对象组合。组合模式让我们能用树形方式创建对象的结构，树中包含了组合以及个别的对象。使用组合结构，我们能把相同的操作应用在组合和个别对象上。换句话说，在大多数情况下，我们可以忽略对象组合和个别对象之间的差异。

类图：

![Center 11][]

源代码：

public abstract class Component {
    	public void add(Component component) {
    		throw new UnsupportedOperationException();
    	}
    	public void remove(Component component) {
    		throw new UnsupportedOperationException();
    	}
    	public Component getChild(int i) {
    		throw new UnsupportedOperationException();
    	}
    	public void operation() {
    	}
    }
    public class Leaf extends Component {
    	String description;
    	public Leaf(String description) {
    		this.description = description;
    	}
    	public void operation() {
    		System.out.println("this is Leaf " + description + " operation.");
    	}
    }
    public class Composite extends Component{
    	List<Component> components;
    	String description;
    	public Composite(String description) {
    		components = new ArrayList<>();
    		this.description = description;
    	}
    	public void add(Component component) {
    		components.add(component);
    	}
    	public void remove(Component component) {
    		components.remove(component);
    	}
    	public Component getChild(int i) {
    		return components.get(i);
    	}
    	public void operation() {
    		System.out.println("this is Composite " + description + " operation.");
    	}
    }

## 12、状态模式 ##

定义：

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

类图：

![Center 12][]

源代码：

public interface State {
    	public void handle();
    }
    public class OpenState implements State {
    	@Override
    	public void handle() {
    		System.out.println("It's opening!");
    	}
    }
    public class CloseState implements State {
    	@Override
    	public void handle() {
    		System.out.println("It's closed!");
    	}
    }
    public class Context {
    	private State openState;
    	private State closeState;
    	public Context() {
    		openState = new OpenState();
    		closeState = new CloseState();
    	}
    	public void open() {
    		openState.handle();
    	}
    	public void close() {
    		closeState.handle();
    	}
    }

## 13、代理模式 ##

定义：

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

作用：

使用代理模式创建代表(representative)对象，让代表对象控制某对象的访问，被代理的对象可以是远程的对象、创建开销大的对象或需要安全控制的对象。

类图：

![Center 13][]

源代码：

public interface Subject {
    	public void request();
    }
    class RealSubject implements Subject {
    	@Override
    	public void request() {
    		System.out.println("this is request in RealSubject.");
    	}
    }
    public class Proxy implements Subject {
    	Subject subject;
    	public Proxy() {
    		subject = new RealSubject();
    	}
    	@Override
    	public void request() {
    		subject.request();
    	}
    }

具体源码及类图详见http://download.csdn.net/detail/u013473512/9803167

欢迎关注“**程序杂货铺**”公众号，里面有精彩内容，欢迎大家收看^\_^

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM0NzM1MTI_size_16_color_FFFFFF_t_70][]

[Center]: /images/20220618/f5b4a4976709428da1d48f944fac7ceb.png
[Center 1]: /images/20220618/bbb448f6accb4689b798b86b603c580d.png
[Center 2]: /images/20220618/f06f88a587684f92898625a2eb4f256d.png
[Center 3]: /images/20220618/a96754e2a71b48a39c3f9ec6fc6e2812.png
[Center 4]: /images/20220618/718a016a4c164bcfbf1193d9ac82d717.png
[Center 5]: /images/20220618/294878c22d554effbdac290a9aa503e9.png
[Center 6]: /images/20220618/c38b7bbe71f34ed9b2c6284fc6ed302d.png
[Center 7]: /images/20220618/d1b771cd683c48939f9de2a6708bae89.png
[Center 8]: /images/20220618/20676e942fee492783f7922d75099417.png
[Center 9]: /images/20220618/e73c5791c8d84ef79fe510839366df36.png
[Center 10]: /images/20220618/a5a47b55f3a74487b9b39f233b58fece.png
[Center 11]: /images/20220618/2bb5c63d77324961bd20e4e617a1f031.png
[Center 12]: /images/20220618/d72c4af516694ff3afd286bd25e7cf17.png
[Center 13]: /images/20220618/840e7e544c244c44ba38e36e9edf3683.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTM0NzM1MTI_size_16_color_FFFFFF_t_70]: /images/20220618/4945e450b2c74d4fa38843ee80f2aa38.png