设计模式——工厂模式

工厂模式下，需要关注两个要素，工厂+产品 ，即打造的工厂将生产怎样的产品，如生产单种类型的还是多种类型的，以及产品特征的组合， 在此核心要点下，根据生产的产品的不同。工厂模式又可以划分为简单工厂，工厂，抽象工厂。
其中简单工厂，工厂生产单类产品，抽象工厂至少生产两种类型以上的产品

1 简单工厂

步骤一：定义抽象产品

/**
 * 抽象产品
 */
public interface ICar {
}

步骤二：定义具体产品

//高等小汽车
public class UpCar implements ICar {
}

//中等小汽车
public class MidCar implements ICar{
}

//低等小汽车
public class DnCar implements ICar {
}

步骤三：简单工厂生产产品

public class SimpleFactory {

    private static final String UPTYPE="uptype";

    private static final String MIDYPE="midtype";

    private static final String DNTYPE="dntype";

    /**
     * 通过标识符，简单工厂创建具体的产品类
     * @param str
     * @return
     */
    private static  ICar create(String str){
        ICar car=null;
        if(str.equals(UPTYPE)){
            car=new UpCar();
        }else if(str.equals(MIDYPE)){
            car=new MidCar();
        }else if(str.equals(DNTYPE)){
            car=new DnCar();
        }
        return car;
    }

}

步骤四：测试

public class Main {

    public static void main(String[] args) {
        //简单工厂生产高等系列的小汽车
        SimpleFactory.create("uptype");
    }
}

简单工厂的UML类图关系如下：

简单工厂是一个具体的类，根据create(String str)中的str标识符，使用if-else,switch此类型的开关语句进行具体产品的生产。在实际项目中，若是想用到一个类的实例，想做到解耦的情况下，可以使用简单工厂模式。但是在简单工厂模式下，在生产的产品的发生变动时，如简单工厂将会新生产一款超高档的小汽车时，将要新建一个SuperCar类，并需要改动简单工厂类中的create(String str)方法，增加开关语句，来判断究竟生产何种类型的汽车。此种情形下的弊端，可以选用工厂模式来解决，更易于软件的二次开发

2 工厂

工厂模式是简单工厂模式的进一步解耦合，工厂模式把简单工厂中的工厂类划分成两层，抽象工厂层（Factory）与具体工厂子类层(UpCarFactory)。当需求发生变化时，只需要增加，删除相应的类，而不用修改已有的类

步骤一：定义抽象产品

/**
 * 抽象产品
 */
public interface ICar {
}

步骤二：定义具体产品

//高等小汽车
public class UpCar implements ICar {
}

//中等小汽车
public class MidCar implements ICar{
}

//低等小汽车
public class DnCar implements ICar {
}

步骤三：定义抽象工厂

/**
 * 抽象工厂，根据具体的工厂子类型生产具体的产品
 */
public interface Factory {

    /**
     * 抽象工厂生产抽象产品，管理小汽车的类型是不确定的
     * @return
     */
    ICar create();
}

步骤四：定义具体工厂

/**
 * 高等小汽车工厂——仅仅生产高等小汽车
 */
public class UpCarFactory implements Factory {
    @Override
    public ICar create() {
        return new UpCar();
    }
}


/**
 * 高等小汽车工厂——仅仅生产高等小汽车
 */
public class MidCarFactory implements Factory {
    @Override
    public ICar create() {
        return new MidCar();
    }
}
/**
 * 低等小汽车工厂——仅仅生产低等小汽车
         */
public class DnCarFactoty implements  Factory {
    @Override
    public ICar create() {
        return new DnCar();
    }
}

步骤五：测试

public class Main {

    public static void main(String[] args) {
         //工厂生产高等系列的小汽车
        Factory factory=new  UpCarFactory();
        ICar iCar = factory.create();
    }
}

3 抽象工厂

抽象工厂是多产品系的，从本质上来说，抽象工厂与工厂模式是统一的。但是抽象工厂能管理多产品间的不同特征【共享特征与区分特征】。

现有高档工厂生产高档汽车，高档公交车
中档工厂生产中档小汽车和中档公交车
低档工厂仅仅只能生产小汽车

步骤一：定义抽象产品

/**
 * 抽象产品
 */
public interface ICar {
}
public interface IBus {
}

步骤二：定义具体产品

//高等小汽车
public class UpCar implements ICar {
}

//中等小汽车
public class MidCar implements ICar{
}

//低等小汽车
public class DnBus implements ICar {
}
//高等小公交车
public class UpBus implements ICar {
}

//中等小公交车
public class MidBus implements ICar{
}

//低等小公交车
public class DnBus implements IBus {
}

步骤三：定义多产品间的共性特征抽象工厂类

public abstract class OriginAbstractFactory {
}


//抽象工厂1 管理公共汽车和小汽车的生产
public abstract class AbstractFactory1 extends OriginAbstractFactory {

    abstract IBus createBus();
    abstract ICar createCar();
}

//抽象工厂2 管理小汽车的生产
public abstract class AbstractFactory2 {

    //管理小气车的生产
    abstract ICar createCar();
}

步骤四：定义具体工厂

//高档工厂生产高档公交车与高档小汽车
public class UpAbstractFactory extends AbstractFactory1 {

    @Override
    IBus createBus() {
        return new UpBus();
    }

    @Override
    ICar createCar() {
        return new UpCar();
    }
}

//中档工厂生产中档公交车与中档小汽车
public class MidAbstactFactory extends AbstractFactory1 {
    @Override
    IBus createBus() {
        return new MidBus();
    }

    @Override
    ICar createCar() {
        return new MidCar();
    }
}

//低档工厂生产低档小汽车
public class DnAbstractFactory extends AbstractFactory2 {
    @Override
    ICar createCar() {
        return new DnCar();
    }
}

OriginAbstractFactory 为抽象类，无方法。表明了在不同的子类中，方法是不同的，仅仅是对不同的子类进行统一的管理
AbstractFactory1 和 AbstractFactory2 两个抽象类将共同的特征抽离放在一起，具体工厂实现特征管理的抽象工厂

---

该笔记参考金百东和刘德山的《Java设计模式与应用案例》，加深了我对设计模式编程思想的理解。我觉得写得很浅显易懂，有需要的各位可以购买该书。