sheng的学习笔记-设计模式-工厂模式

转发，原文：Java设计模式（工厂模式） - IT_longlong - 博客园

简单工厂示意图

 工厂方法示意图：

抽象工厂示意图

一．简单工厂模式

　　简单工厂模式就是把对类的创建初始化全都交给一个工厂来执行，而用户不需要去关心创建的过程是什么样的，只用告诉工厂我想要什么就行了。而这种方法的缺点也很明显，违背了设计模式的开闭原则，因为如果你要增加工厂可以初始化的类的时候，你必须对工厂进行改建

代码如下：

package design.factory;

public interface Car {
    public void getCar();
}

package design.factory;

public class BMW implements Car {
    @Override
    public void getCar() {
        System.out.println("来一辆BMW！");
    }
}

package design.factory;

public class BYD implements Car {
    @Override
    public void getCar() {
        System.out.println("来一辆BYD！");
    }

}

package design.factory;

/**
 * 简单工厂模式就是把对类的创建初始化全都交给一个工厂来执行，而用户不需要去关心创建的过程是什么样的，只用告诉工厂我想要什么就行了。
 * 而这种方法的缺点也很明显，违背了设计模式的开闭原则，因为如果你要增加工厂可以初始化的类的时候，你必须对工厂进行改建
 */
public class SimpleFactory {
    public static Car carFactor(Class<?> tClass) {
        if (tClass.getName().equals(BMW.class.getName())) {
            return new BMW();
        }
        if (tClass.getName().equals(BYD.class.getName())) {
            return new BYD();
        }
        return null;
    }

    public static void main(String[] args) {
        Car car = SimpleFactory.carFactor(BYD.class);
        car.getCar();
    }
}

结果如图：

二. 工厂方法模式

 　　设计一个工厂的接口，你想要什么东西，就写个类继承于这个工厂，这样就不用修改什么，直接添加就行了。就相当于，我这个工厂是用来生汽车的，而要什么品牌的汽车具体分到了每个车间，如果新多了一种品牌的汽车，直接新增一个车间就行了。那么问题又来了，如果想要生产大炮怎么办？

 代码如下：

package design.factory;

public interface Car {
    public void getCar();
}

package design.factory;

public class BMW implements Car {
    @Override
    public void getCar() {
        System.out.println("来一辆BMW！");
    }
}

package design.factory;

public class BYD implements Car {
    @Override
    public void getCar() {
        System.out.println("来一辆BYD！");
    }
}

package design.factory;

/**
 * 设计一个工厂的接口，你想要什么东西，就写个类继承于这个工厂，这样就不用修改什么，直接添加就行了。
 * 就相当于，我这个工厂是用来生汽车的，而要什么品牌的汽车具体分到了每个车间，如果新多了一种品牌的汽车，直接新增一个车间就行了。
 * 那么问题又来了，如果想要生产大炮怎么办？
 */
public class FactoryMethod {

    public static void main(String[] args) {
        Car car = new BMWfactory().getCarByFactory();
        car.getCar();

        car = new BYDfactory().getCarByFactory();
        car.getCar();
    }
}

//抽象工厂
interface CarFactory {
    public Car getCarByFactory();
}

// BMW 具体工厂类
class BMWfactory implements CarFactory {

    @Override
    public Car getCarByFactory() {
        return new BMW();
    }
}

// BYD 具体工厂类
class BYDfactory implements CarFactory {

    @Override
    public Car getCarByFactory() {
        return new BYD();
    }
}

结果：

三. 抽象工厂模式　

　　定义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。

　　抽象工厂与工厂方法的区别，就在于产品簇的问题，多了一种产品，这时候怎么办呢，就是在接口类里面加上创建大炮的方法，然后每个车间就可以有两个子车间分别来生产汽车和大炮。这样的话缺点也很显然的冒了出来，如果我又想生产飞机，那么我要需要更改所有的工厂车间以及工厂接口。

　　抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

 代码如下：

package design.factory;

public interface Car {
    public void getCar();
}

package design.factory;

public class BMW implements Car {
    @Override
    public void getCar() {
        System.out.println("来一辆BMW！");
    }
}

package design.factory;

public class BYD implements Car {
    @Override
    public void getCar() {
        System.out.println("来一辆BYD！");
    }
}

package design.factory;

/**
 * 抽象工厂模式
 * 定义：为创建一组相关或相互依赖的对象提供一个接口，而且无需指定他们的具体类。
 * 抽象工厂与工厂方法的区别，就在于产品簇的问题，多了一种产品，这时候怎么办呢，就是在接口类里面加上创建大炮的方法，
 * 然后每个车间就可以有两个子车间分别来生产汽车和大炮。这样的话缺点也很显然的冒了出来，如果我又想生产飞机，
 * 那么我要需要更改所有的工厂车间以及工厂接口。
 * 抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。
 * 他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。
 * 在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，
 * 而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。
 */
public class AbstactFactory {

    public static void main(String[] args) {
        Car byd = new FactoryTwo().getCarByFactory();
        byd.getCar();
        Plane airPlane = new FactoryOne().getPlaneByFactory();
        airPlane.getPlane();
    }
}

interface Plane {
    public void getPlane();
}

class AirPlane implements Plane {

    @Override
    public void getPlane() {
        System.out.printf("来一架客机！");
    }
}

class BattlePlane implements Plane {
    @Override
    public void getPlane() {
        System.out.printf("来一架战斗机！");
    }
}

//抽象工厂
interface Factory {
    public Car getCarByFactory();

    public Plane getPlaneByFactory();
}

// 具体工厂类
class FactoryOne implements Factory {

    @Override
    public Car getCarByFactory() {
        return new BMW();
    }

    @Override
    public Plane getPlaneByFactory() {
        return new AirPlane();
    }
}

// 具体工厂类
class FactoryTwo implements Factory {

    @Override
    public Car getCarByFactory() {
        return new BYD();
    }

    @Override
    public Plane getPlaneByFactory() {
        return new BattlePlane();
    }
}

使用场景

　　当我们直接new一个对象比较麻烦时，比如构造方法传参数量太多；

　　再比如创建一个类A要先创建类B，这种使用new比较麻烦时就可以交给工厂去做，还减少了代码的重复。

参考文章：Java设计模式（工厂模式） - IT_longlong - 博客园

示意图来自书：二十三中设计模式