工厂模式

　　 工厂模式的主要作用是创建对象，调用者只需要知道对象名字，通过接口调用对象，不必知道对象是怎么创建的，是典型的解耦模式， 有三种不同类型：简单工厂模式，工厂方法模式和抽象工厂模式。

　　简单工厂模式：又叫静态工厂方法模式，有三种角色：工厂类角色，抽象产品角色，具体产品角色；下面将引用《head first 设计模式》中的例子去认识简单工厂模式;

　　首先创建一个抽象产品类，不同的pizza有不同的制作方法，准备的材料，烘烤时间，切片方式，以及装盒都不同，所以首先先创建一个pizza的抽象类

package org.yl;

/**
 * Created by yelei on 17-4-8.
 */
public abstract class Pizza {
//pizza的制作过程
    public abstract void prepare();
    public abstract void bake();
    public abstract void cut();
    public abstract void box();
}

创建两个具体产品类继承Pizza类

VeggiePizza类和CheesePizza类

package org.yl;

/**
 * Created by yelei on 17-4-8.
 */
public class VeggiePizza extends Pizza {
    public void prepare(){
        System.out.println("准备VeggiePizza");
    }
    public void bake(){
        System.out.println("烘烤VeggiePizza");
    }
    public  void cut(){
        System.out.println("切片VeggiePizza");
    }
    public void box(){
        System.out.println("打包VeggiePizza");
    }
}

package org.yl;

/**
 * Created by yelei on 17-4-8.
 */
public class CheesePizza extends Pizza {
    public void prepare(){
        System.out.println("准备CheesePizza");
    }
    public void bake(){
        System.out.println("烘烤CheesePizza");
    }
    public  void cut(){
        System.out.println("切片CheesePizza");
    }
    public void box(){
        System.out.println("打包CheesePizza");
    }
}

然后开始创建工厂类：

package org.yl;

/**
 * Created by yelei on 17-4-8.
 */
//这个工厂类专门用来创建实例
public class PizzaFactory {
    //定义一个方法，通过这个方法来实例对象，只需要传入相应的参数
    public static Pizza createPizza(String type){
        Pizza pizza=null;
        if (type.equals("cheese")){
              pizza=new CheesePizza();
        }else if (type.equals("veggiePizza")){
              pizza=new VeggiePizza();
        }
        return pizza;
    }
}

使用时只需要调用

Pizza pizza=PizzaFactory.createPizza("cheese");

这个静态方法。不用去关心这个对象是如何创建的。但简单工厂模式违背了开闭原则。每增加一种类型的批萨都要在工厂里面去添加。

工厂方法模式：工厂方法模式相对于简单工厂模式，是符合开闭原则，何为开闭原则，就是在新增需求的时候不必修改原有的代码，而是随意增加需要的类。

　　　　工厂方法模式通过让子类决定创建对象是什么，有四种角色：抽象工厂角色，具体工厂角色，抽象产品角色，具体产品角色，这里以汽车为例。

首先先定义一个抽象产品类Car 

package org.yl;

/**
 * Created by yelei on 17-4-9.
 */
abstract class Car {
    private String name;
    public abstract void drive();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

两个具体产品类：

package org.yl;

/**
 * Created by yelei on 17-4-9.
 */
public class Benz extends Car{
    public void drive(){
        System.out.println(this.getName()+"........");
    }
}

package org.yl;

/**
 * Created by yelei on 17-4-9.
 */
public class BMW extends Car {
    public void drive(){
        System.out.println(this.getName()+".........");
    }
}

然后是抽象工厂类：

package org.yl;

/**
 * Created by yelei on 17-4-9.
 */
abstract class Drive {
    public abstract Car createCar(String car);
}

具体工厂类：

package org.yl;

/**
 * Created by yelei on 17-4-9.
 */
public class BenDrive extends Drive {
    public Car createCar(String car){
        return new Benz();
    }
}

package org.yl;

/**
 * Created by yelei on 17-4-9.
 */
public class BMWDrive extends Drive {
    public Car createCar(String car){
        return new BMW();
    }
}

使用：

package org.yl;

/**
 * Created by yelei on 17-4-8.
 */
public class Main {

    public static void main(String[] args) {
       Drive drive=new BenDrive();
        Car car=drive.createCar("Benz");
        car.setName("Benz");
        car.drive();

    }


}

运行结果：   Benz........

Process finished with exit code 0

  在框架中会经常用到，比如在springmvc中的业务逻辑层。虽然工厂设计模式符合开闭原则，新增需求的时候，不用去改变原有的代码，直接创建新类继承相应的抽象类，抽象工厂，但是每个工厂只负责生产一种产品，大量的类会给系统添加负担，抽象工厂模式为创建一组对象就提供了相应的解决方案，具体工厂就不只创建一种产品，而是产品族，具体的抽象工厂方法模式就自己去了解。