设计模式之工厂模式

工厂模式中有三种：简单工厂模式、工厂方法模式、抽象工厂模式。

简单工厂模式

简单工厂模式其实不是一个设计模式，应该说是一个编程的习惯。

UML图：

这个是一个做披萨的例子，是Head First书中的例子。简单工厂模式就是将new 的方法放入一个工厂的类中，下面我们给出代码：

package com.jd.factory.staticFactory;


public class Pizza {

    public void prepare(){
        System.out.println("1");
    }

    public void bake(){
        System.out.println("2");
    }

    public void cut(){
        System.out.println("3");
    }
    public void box(){
        System.out.println("4");
    }
}

class Main{

    public Pizza orderPizza(String type){
        //我现在需要多种类型的对象
//        Pizza pizza = new Pizza();

        //这个时候如果我们新增pizza的种类会很麻烦，所以我们将变得代码拿出来，使用一个factory来创建对象
//        Pizza pizza = null;
//        if (type.equals("cheese")){
//             pizza = new CheesePizza();
//        }else if (type.equals("qreek")){
//             pizza = new QreekPizza();
//        }

        //这样的话PizzaFactory就是一个简单工厂
        PizzaFactory pizzaFactory = null;
        Pizza pizza = pizzaFactory.createPizza(type);


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

        return pizza;
    }

}

class PizzaFactory{
    public  Pizza createPizza(String type){
        Pizza pizza = null;
        if (type.equals("cheese")){
             pizza = new CheesePizza();
        }else if (type.equals("qreek")){
             pizza = new QreekPizza();
        }
        return pizza;
    }
}

class CheesePizza extends Pizza
{
    public void prepare(){
        System.out.println("1");
    }

    public void bake(){
        System.out.println("2");
    }

    public void cut(){
        System.out.println("3");
    }
    public void box(){
        System.out.println("4");
    }
}

class QreekPizza extends Pizza{


    public void prepare(){
        System.out.println("1");
    }

    public void bake(){
        System.out.println("2");
    }

    public void cut(){
        System.out.println("3");
    }
    public void box(){
        System.out.println("4");
    }
}

简单工厂就不多说了，上面的UML图挺清楚的。

工厂方法模式

 1、意图

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

2、动机

框架使用抽象类定义和维护对象之间的关系，这些对象的创建通常也有框架负责。

3、适用性

• 当一个类不知道他所必须创建的对象的类的时候
• 当一个类希望由它的子类来指定它所创建的对象的时候。
• 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理这一信息局部化的时候。

4、结构

5、参与者

• Product

定义工厂方法所创建的对象的接口。

• ConcreteProduct

实现Product接口。

• Creator

声明工厂方法，该方法返回一个Product类型的对象。Creator也可以定义一个工厂方法的省缺实现，它返回一个省缺的ConcreteProduct对象。

可以调用工厂方法以创建一个Product对象。

• ConcreteCreator 

重定义工厂方法已返回一个ConcreteProduct实例。

6、实现

package com.jd.factory;

//当简单的工厂不能满足我们的需求，我们将pizza分为两大模块，一个是NY的，一个是Chicago的，这两大类之下又有各种pizza，相当于我们的对象有两个维度的分类
//这个时候我们就不能通过一个工厂来创建。

public class Mian{
    public static void main(String[] args)  {
        FactoryMethod factory = new NYFactory();
        Pizza pizza = factory.orderPizza("cheese");
    }
}

abstract class FactoryMethod {
    public Pizza orderPizza(String type){
        Pizza pizza = createPizza(type);
        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(String type);
}

class Pizza{

    public void prepare(){
        System.out.println("1");
    }

    public void bake(){
        System.out.println("2");
    }

    public void cut(){
        System.out.println("3");
    }
    public void box(){
        System.out.println("4");
    }
    public void addSHI(){
        System.out.println("shijiahaole");
    }
}


class NYFactory extends FactoryMethod{
    public Pizza createPizza(String type){
        Pizza pizza;
        if (type.equals("cheese")){
            pizza = new NYCheesePizza();
        }else if (type.equals("qreek")){
            pizza = new NYQreekPizza();
        }else{

            pizza = null;
        }
        return pizza;
    }
}

class ChicagoFactory extends FactoryMethod{
    public Pizza createPizza(String type){
        Pizza pizza = null;
        if (type.equals("cheese")){
            pizza = new ChicagoCheesePizza();
        }else if (type.equals("qreek")){
            pizza = new ChicagoQreekPizza();
        }
        return pizza;
    }
}




class NYCheesePizza extends Pizza{

}

class ChicagoCheesePizza extends Pizza{

}

class NYQreekPizza extends Pizza{

}

class ChicagoQreekPizza extends Pizza{

}

抽象工厂模式

1、意图

提供一个接口以创建一系列 相关或相互依赖 的对象，而无须指定它们具体的类。

2、适用性

• 一个系统要独立与它的产品创建、组合和表示。
• 一个系统要由多个产品系列中的一个来配置。
• 要强调一系列相关的产品对象的设计以便进行联合使用。
• 提供一个产品类库，但只想显示它们的接口而不是实现。 

3、结构 

4、参与者

• AbstractFactory

声明一个创建抽象产品对象的操作接口。

• ConcreteFactory

实现创建具体产品对象的操作

• AbstractProduct

为一类产品对象声明一个接口

• ConcreteProduct

定义一个将被相应的具体工厂创建的产品对象

实现AbstactProduct接口

• Client

仅使用由AbstractFactory和AbstractProduct类声明的接口。

5、实现

package com.jd.factory;

public class AbstractFactory {


}

abstract class Factory{

    abstract Button createButton();

    abstract Text createText();

}

class MacFactory extends Factory {

    @Override
    Button createButton() {
        return new MacButton();
    }

    @Override
    Text createText() {
        return new MacText();
    }
}

class LinuxFactory extends Factory {

    @Override
    Button createButton() {
        return new LinuxButton();
    }

    @Override
    Text createText() {
        return new LinuxText();
    }
}

class WinFactory extends Factory {

    @Override
    Button createButton() {
        return new WinButton();
    }

    @Override
    Text createText() {
        return new WinText();
    }
}

class Text{

}

class MacText extends Text {

}

class LinuxText extends Text {

}

class WinText extends Text {

}

class Button{

}

class MacButton extends Button{

}

class LinuxButton extends Button{

}

class WinButton extends Button{

}

工厂模式我们就讲到这里，接着我们来学习四个十分相近的设计模式：

适配器模式、桥接模式、装饰者模式、代理模式。