设计模式之工厂模式

工厂模式，简单来说就是用于生产对象的模式，是一种创建型模式。根据创建对象的不同分为简单工厂模式(直接创建具体产品对象)和工厂方法模式(创建工厂对象)，然后抽象程度较高的模式又被称为抽象工厂模式。

工厂模式的作用是为了使对象的创建与使用解耦，即一个类要使用另一个类的对象，它无需关注另一个的对象是如何创建的，只需要获得这个对象即可。而对象的创建呢，则交由工厂进行。这跟Spring的ioc有些相似，都是把对象的创建托管给容器或者类，只不过Spring使用了反射使得创建对象更加灵活些。

工厂模式还能降低代码重复度。只要在工厂类中写好创建逻辑，一次编写，到处使用，哪里要创建对象，直接就可获取，无需再写创建逻辑。

简单工厂模式

简单工厂模式，顾名思义，最为简单，仅仅是用工厂类对对象的创建进行了简单封装。缺点是系统扩展困难，需要修改工厂类，违反了开闭原则。假如创建的对象过多，代码就会过于复杂。适用于创建对象较少的场景。

/**
 * 声明产品接口
 */
interface Car{
    public void make();
}

/**
 * 具体产品宝马
 */
class BaoMa implements Car{

    @Override
    public void make() {
        System.out.println("制造宝马");
    }
}
/**
 * 具体产品奔驰
 */
class BenChi implements Car{

    @Override
    public void make() {
        System.out.println("制造奔驰");
    }
}

/**
 * 创建工厂
 */
class Factory{
    public static Car makeCar(String carName){
        if (carName.equals("BenChi"))
            return new BenChi();
        else if (carName.equals("BaoMa"))
            return new BaoMa();
        else
            return null;
    }
}
public class Main {
    public static void main(String[] args) {
        Car benChi=Factory.makeCar("BenChi");
        Car baoMa=Factory.makeCar("BaoMa");
        baoMa.make();
        benChi.make();
    }
}

工厂方法模式

工厂方法模式不再提供一个通用工厂类去创建所有对象，而是通过一个子类工厂去实现抽象的工厂接口，再利用子类工厂去创建具体对象。弥补了简单工厂模式的缺点，假使我们要新增一个具体产品类，只需要该产品工厂类去实现抽象接口即可，不用再去修改工厂类，符合开闭原则。

/**
 * 声明产品接口
 */
interface Car{
    public void make();
}

/**
 * 具体产品宝马
 */
class BaoMa implements Car{

    @Override
    public void make() {
        System.out.println("制造宝马");
    }
}
/**
 * 具体产品奔驰
 */
class BenChi implements Car{

    @Override
    public void make() {
        System.out.println("制造奔驰");
    }
}
/**
 * 工厂接口
 */
interface AbstractFactory{
    public Car makeCar();
}
/**
 * 创建宝马工厂
 */
class BaoMaFactory implements AbstractFactory{
    @Override
    public  Car makeCar(){
        return new BaoMa();
    }
}

/**
 * 创建奔驰工厂
 */
class BenChiFactory implements AbstractFactory{
    @Override
    public  Car makeCar(){
        return new BenChi();
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractFactory benChiFactory=new BenChiFactory();
        AbstractFactory baoMaFactory=new BaoMaFactory();
        Car benChi=benChiFactory.makeCar();
        Car baoMa=baoMaFactory.makeCar();
        baoMa.make();
        benChi.make();
    }
}

抽象工厂模式

我感觉抽象工厂模式跟工厂方法模式极为的类似，只不过工厂方法模式生产出的产品对象类型是单一的，而抽象工厂模式可以生产多种产品类型的对象。

我从网上找到了一张对比表格可以很好的阐明关系：

工厂方法模式	抽象工厂模式
针对的是一个产品等级结构	针对的是面向多个产品等级结构
一个抽象产品类	多个抽象产品类
可以派生出多个具体产品类	每个抽象产品类可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类	一个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类只能创建一个具体产品类的实例	每个具体工厂类可以创建多个具体产品类的实例

对比表格出处：https://blog.csdn.net/wyxhd2008/article/details/5597975

/**
 * 声明产品接口1
 */
interface Car{
    public void make();
}

/**
 * 具体产品宝马车
 */
class BaoMa implements Car{

    @Override
    public void make() {
        System.out.println("制造宝马车");
    }
}
/**
 * 具体产品奔驰车
 */
class BenChi implements Car{

    @Override
    public void make() {
        System.out.println("制造奔驰车");
    }
}
/**
 * 声明产品接口2
 */
interface Bike{
    public void make();
}
/**
 * 具体产品宝马自行车
 */
class BaoMaBike implements Bike{

    @Override
    public void make() {
        System.out.println("制造宝马自行车");
    }
}
/**
 * 具体产品奔驰自行车
 */
class BenChiBike implements Bike{

    @Override
    public void make() {
        System.out.println("制造奔驰自行车");
    }
}
/**
 * 工厂接口
 */
interface AbstractFactory{
    public Car makeCar();
    public Bike makeBike();
}
/**
 * 创建宝马工厂
 */
class BaoMaFactory implements AbstractFactory{
    @Override
    public  Car makeCar(){
        return new BaoMa();
    }

    @Override
    public Bike makeBike() {
        return new BaoMaBike();
    }
}
/**
 * 创建奔驰工厂
 */
class BenChiFactory implements AbstractFactory{
    @Override
    public  Car makeCar(){
        return new BenChi();
    }

    @Override
    public Bike makeBike() {
        return new BenChiBike();
    }
}

public class Main {
    public static void main(String[] args) {
        AbstractFactory benChiFactory=new BenChiFactory();
        AbstractFactory baoMaFactory=new BaoMaFactory();
        Car benChi=benChiFactory.makeCar();
        Car baoMa=baoMaFactory.makeCar();
        Bike bcBike=benChiFactory.makeBike();
        Bike bmBike=baoMaFactory.makeBike();
        baoMa.make();
        benChi.make();
        bcBike.make();
        bmBike.make();
    }
}

代码中有两种产品，车与自行车。通过抽象工厂模式可以很方便的创建出多种，多级的产品对象。