关于设计模式的个人小解

一 单例模式： 一个类只能实例化一个具体对象

 

 

二.抽象工厂模式：

-----------------------------------copy other's blog :

 你的比萨店经营有成，击败了竞争者，现在大家都希望比萨店能在自家附近有加盟店。身为加盟公司经营者，你希望确保加盟店营运的质量，因为砸牌子砸的是你的牌子，所以你希望这些店都使用你那些经过时间考验的代码 ，好让比萨的流程一成不变。但是区域的差异呢？每家加盟店都可能想要提供不同风味的比萨，这受到了开店地点及该地区比萨美食家口味的影响。

我们利用SimplePizzaFactory，写出三种不同的工厂，分别是NYPizzaFactory、ChicagoPizzaFactory、CaliforniaPizzaFactory，那么各地的加盟店都有合适的工厂可以用，这是一种办法，让我们看看会变成什么样子：

 

NYPizzaFactory nyFactory = new NYPizzaFactory();
PizzaStore nyStore = new PizzaStore(nyFactory);
nyStore.orderPizza("Veggie");

ChicagoPizzaFactory chicagoFactory = new ChicagoPizzaFactory();
PizzaStore chicagoStore = new PizzaStore(chicagoFactory);
nyStore.orderPizza("Veggie");

	NYPizzaFactory nyFactory = new NYPizzaFactory();
	PizzaStore nyStore = new PizzaStore(nyFactory);
	nyStore.orderPizza("Veggie");
	
	ChicagoPizzaFactory chicagoFactory = new ChicagoPizzaFactory();
	PizzaStore chicagoStore = new PizzaStore(chicagoFactory);
	nyStore.orderPizza("Veggie");

 

 

在推广SimpleFactory时，你发现加盟店的确是采用你的工厂创建比萨，但是其他部分呢，却开始采用他们自创的流程：烘烤的做法有些差异、不要切片、使用其他厂商的盒子。我们只需要管加盟店是卖比萨的，我们不需要了解他卖的是什么样比萨，是怎么样做的这种比萨。在我们稍早的SimplePizzaFactory代码之前，制作比萨的代码绑在PizzaStore里，但这么做却没有弹性。有个做法可以让比萨制作活动局限于PizzaStore类，而同时又能让这些加盟店依然可以自由地制作该区域的风味。所要做的事就是把createPizza()方法放回到PizzaStore中，不过要把它设置成抽象方法，然后为每个区域风味创建一个PizzaStore的子类，让子类做决定

首先看看PizzaStore所做的改变：

 

public abstract class PizzaStore {
    public Pizza orderPizza(String type){
        Pizza pizza;

        //现在createPizza()方法从工厂对象中移回PizzaStore
        pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }

    abstract Pizza createPizza(String type);
}

public abstract class PizzaStore {
	public Pizza orderPizza(String type){
		Pizza pizza;
		
		//现在createPizza()方法从工厂对象中移回PizzaStore
		pizza = createPizza(type);
		
		pizza.prepare();
		pizza.bake();
		pizza.cut();
		pizza.box();
		return pizza;
	}
	
	abstract Pizza createPizza(String type);
}

 

 

现在已经有一个PizzaStore作为超类；让每个域类型（NYPizzaFactory、ChicagoPizzaFactory、CaliforniaPizzaFactory）都继承这个PizzaStore，每个子类各自决定如何制作比萨。别忘了，PizzaStore已经有一个不错的订单系统，由OrderPizza()方法负责处理订单，而你希望所有加盟店对于订单的处理都能一致。各个区域比萨店之间的差异在于他们制作比萨的风味，做法如下：

让我们来开加盟店吧，这是纽约风味的：

 

public class NYPizzaStore extends PizzaStore {
    @Override
    Pizza createPizza(String type) {
        if(type.equals("cheese")) {
            return new NYStyleCheesePizza();
        } else if(type.equals("veggie")) {
            return new NYStyleVeggiePizza();
        } else if(type.equals("pepperoni")) {
            return new NYStylePepperoniPizza();
        } else {
            return null;
        }
    }
}

public class NYPizzaStore extends PizzaStore {
	@Override
	Pizza createPizza(String type) {
		if(type.equals("cheese")) {
			return new NYStyleCheesePizza();
		} else if(type.equals("veggie")) {
			return new NYStyleVeggiePizza();
		} else if(type.equals("pepperoni")) {
			return new NYStylePepperoniPizza();
		} else {
			return null;
		}
	}
}

 

 

上面的代码是对工厂方法的实现，工厂方法即抽象的PizzaStore类，让我们靠近一点观察工厂方法，

 

abstract Product factoryMethod(String type);

abstract Product factoryMethod(String type);

 

 

根据上面可以看出，工厂方法是抽象的，所以依赖子类来处理对象的创建。工厂方法必须返回一个产品。超类中定义的方法，通常使用到工厂方法的返回值。工厂方法将客户（也就是超类中的代码，例如orderPizza()）和实际创建具体产品的代码分隔开来。刚刚忽略了一件事：比萨本身！如果没有比萨可出售，我们的比萨店开得再多也不行，现在让我们来实现比萨：

 

import java.util.ArrayList;
public abstract class Pizza {
    String name;
    String dough;
    String sauce;
    ArrayList toppings = new ArrayList();

    void prepare() {
        System.out.println("Preparing " + name);
        System.out.println("Tossing dough...");
        System.out.println("Adding sauce...");
        System.out.println("Adding toppings: ");
        for(int i=0;i<toppings.size();i++) {
            System.out.println("  " + toppings.get(i));
        }
    }

    void bake() {
        System.out.println("Bake for 25 minutes at 350");
    }

    void cut() {
        System.out.println("Cutting the pizza into diagonal slices");
    }

    void box() {
        System.out.println("Place pizza in official PizzaStore box");
    }
    public String getName() {
        return name;
    }
}

import java.util.ArrayList;
public abstract class Pizza {
	String name;
	String dough;
	String sauce;
	ArrayList toppings = new ArrayList();
	
	void prepare() {
		System.out.println("Preparing " + name);
		System.out.println("Tossing dough...");
		System.out.println("Adding sauce...");
		System.out.println("Adding toppings: ");
		for(int i=0;i<toppings.size();i++) {
			System.out.println("  " + toppings.get(i));
		}
	}
	
	void bake() {
		System.out.println("Bake for 25 minutes at 350");
	}
	
	void cut() {
		System.out.println("Cutting the pizza into diagonal slices");
	}
	
	void box() {
		System.out.println("Place pizza in official PizzaStore box");
	}
	public String getName() {
		return name;
	}
}

 

 

现在我们需要一些具体子类.......来定义纽约和芝加哥风味的芝士比萨，怎么样？

 

public class NYStyleCheesePizza extends Pizza {
    public NYStyleCheesePizza() {
        name = "NY Style Sauce and Cheese Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";

        toppings.add("Grated Reggiano Cheese");
    }
}

public class NYStyleCheesePizza extends Pizza {
	public NYStyleCheesePizza() {
		name = "NY Style Sauce and Cheese Pizza";
		dough = "Thin Crust Dough";
		sauce = "Marinara Sauce";
		
		toppings.add("Grated Reggiano Cheese");
	}
}

 

 

 

public class ChicagoStyleCheesePizza extends Pizza {
    public ChicagoStyleCheesePizza() {
        name = "Chicago Style Deep Dish Cheese Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";

        toppings.add("Shredded Mozzarella Cheese");
    }

    void cut() {
        System.out.println("Cutting the pizza into square slices");
    }
}

public class ChicagoStyleCheesePizza extends Pizza {
	public ChicagoStyleCheesePizza() {
		name = "Chicago Style Deep Dish Cheese Pizza";
		dough = "Extra Thick Crust Dough";
		sauce = "Plum Tomato Sauce";
		
		toppings.add("Shredded Mozzarella Cheese");
	}
	
	void cut() {
		System.out.println("Cutting the pizza into square slices");
	}
}

 

 

你已经等的够久了，来吃些比萨吧！

 

public class PizzaTestDrive {
    public static void main(String[] args) {
        PizzaStore nyStore = new NYPizzaStore();
        Pizza pizza = nyStore.orderPizza("cheese");
        System.out.println("Order a " + pizza.getName() + "/n");
    }
}

public class PizzaTestDrive {
	public static void main(String[] args) {
		PizzaStore nyStore = new NYPizzaStore();
		Pizza pizza = nyStore.orderPizza("cheese");
		System.out.println("Order a " + pizza.getName() + "/n");
	}
}

 

 

或许你如果想吃上比萨，需要补充部分代码，或者注释掉部分代码才能使比萨顺利的生产出来，但这对你一定不困难。辛苦了那么久，认识工厂方法模式的时刻终于到了。所有工厂模式都用来封装对象的创建。工厂方法模式通过让子类决定该创建的对象是什么，来达到将对对象创建的过程封装的目的。工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类中。需要注意的是所谓的“决定”，并不是指模式允许子类本身在运行时决定，而是指在编写创建者类时，不需要知道实际创建的产品是哪一个。选择了使用哪个子类，自然就决定了实际创建的产品是什么。类图如下：

工厂方法的子类看起来很像简单工厂，但他们却不一样。简单工厂把全部的事情，在一个地方都处理完了，然而工厂方法却是创建一个框架，让子类决定要如何实现。比方说，在工厂方法中，orderPizza()方法提供了一半的框架，以便创建比萨，orderPizza()方法依赖工厂方法创建具体类，并制造出实际的比萨。课通过继承PizzaStore类，决定实际制造出的比萨是什么。简单工厂的做法，可以将对象的创建封装起来，但是简单工厂不具备工厂方法的弹性，因为简单工厂不能变更正在创建的产品。

-------------------------------------------------

以上写的很烂。我也没有细看。总结如下：

1。定义pizzaStore抽象类，定义订单系统OrderPizza()，所有子类均需使用该方法。定义抽象的pizza制作方法createPizza，每个子类可以有自己的制作方法

2.定义Pizza  抽象类。定义一些方法

3.定义工厂方法

4. 各自子类集成pizzaStore

5. 定义PizzaTestDrive方法，在该方法里面，具体化子类商店，各自不同的子类产生订单

 

--------比较乱！！！！

 

 

 

三. 观察者模式：

GoF说道：Observer模式的意图是“定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新”。从这段话里我们可以得到两个信息，如下：

1， 观察者（具体执行操作的对象，有多个）
2， 被观察者（顾名思义是被观察的对象，如果该对象发生某些变化则通知观察者执行对应的操）

参照http://www.iteye.com/topic/102068/。