设计模式--工厂模式

工厂模式：实例化对象，用工厂方法代替new操作。

简单工厂模式

简单工厂模式又称静态工厂方法模式。重命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的接口。
1) 工厂类角色：这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品。
2) 抽象产品角色：它一般是具体产品继承的父类或者实现的接口。
3) 具体产品角色：工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

产品类

abstract class BMW{
    public BMW(){
    }
}
class BMW320 extends BMW{
    public BMW320(){
        System.out.println("create BMW320");
    }
}
class BMW520 extends BMW{
    public BMW520(){
        System.out.println("create BMW520");
    }
}

工厂类

class BMWFactory{
    public BMW createBMW(int type){
        switch (type){
            case 320: return new BMW320();
            case 520: return new BMW520();
            default:
                break;
        }
        return null;
    }
}

调用者

public class FactoryPattern {
    public static void main(String[] args){
        BMWFactory factory = new BMWFactory();
        factory.createBMW(520);
        factory.createBMW(320);
    }
}

工厂方式模式

工厂方法模式组成：
1)抽象工厂角色：这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。
2)具体工厂角色：它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。
3)抽象产品角色：它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。
4)具体产品角色：具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

产品类

abstract class Audi{
    public Audi(){
        
    }
}
class AudiA4 extends Audi{
    public AudiA4(){
        System.out.println("create AudiA4");
    }
}
class AudiA6 extends Audi{
    public AudiA6(){
        System.out.println("create AudiA6");
    }
}

工厂类

interface AudiFactory{
    public Audi createAudi();
}
class AudiA4Factory implements AudiFactory{
    @Override
    public AudiA4 createAudi(){
        return new AudiA4();
    }
}
class AudiA6Factory implements AudiFactory{
    @Override
    public AudiA6 createAudi(){
        return new AudiA6();
    }
}

调用者

public class FactoryPattern {
    public static void main(String[] args){
        AudiA4Factory audiA4Factory = new AudiA4Factory();
        AudiA4 audiA4 = audiA4Factory.createAudi();
        
        AudiA6Factory audiA6Factory = new AudiA6Factory();
        AudiA6 audiA6 = audiA6Factory.createAudi();
    }
}

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。

抽象工厂模式

为什么引入抽象工厂模式：
抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。比如奔驰C200使用发动机A和铁A，而奔驰C300使用发动机型号B和铁B，那么使用抽象工厂模式，在为C200系列生产相关配件时，就无需制定配件的型号，它会自动根据车型生产对应的配件。

产品类

//发动机类型
interface Engine{
}
class EngineA implements Engine{
    public EngineA(){
        System.out.println("with EngineA");
    }
}
class EngineB implements Engine{
    public EngineB(){
        System.out.println("with EngineB");
    }
}
//钢铁的类型
interface Iron{
}
class IronA implements Iron{
    public IronA(){
        System.out.println("is IronA");
    }
}
class IronB implements Iron{
    public IronB(){
        System.out.println("is IronB");
    }
}

工厂类

//工厂接口
interface BenzFactory{
    public Engine withEngine();
    public Iron ironType();
}
//奔驰C200装配工厂
class BenzC200Factory implements BenzFactory{
    @Override
    public EngineA withEngine(){
        return new EngineA();
    }
    @Override
    public IronA ironType(){
        return new IronA();
    }
}
//奔驰C300装配工厂
class BenzC300Factory implements BenzFactory{
    @Override
    public EngineB withEngine(){
        return new EngineB();
    }
    @Override
    public IronB ironType(){
        return new IronB();
    }
}

调用者

public class FactoryPattern {
    public static void main(String[] args){
        BenzC200Factory benzC200Factory = new BenzC200Factory();
        benzC200Factory.ironType();
        benzC200Factory.withEngine();
        BenzC300Factory benzC300Factory = new BenzC300Factory();
        benzC300Factory.ironType();
        benzC300Factory.withEngine();
    }
}

总结

无论是简单工厂模式，工厂方法模式，还是抽象工厂模式，他们都属于工厂模式，在形式和特点上也是极为相似的，他们的最终目的都是为了解耦。在使用时，我们不必去在意这个模式到底工厂方法模式还是抽象工厂模式，因为他们之间的演变常常是令人琢磨不透的。经常你会发现，明明使用的工厂方法模式，当新需求来临，稍加修改，加入了一个新方法后，由于类中的产品构成了不同等级结构中的产品族，它就变成抽象工厂模式了；而对于抽象工厂模式，当减少一个方法使的提供的产品不再构成产品族之后，它就演变成了工厂方法模式。
所以，在使用工厂模式时，只需要关心降低耦合度的目的是否达到了。

关于抽象工厂模式的起源：
贴一个连接：抽象工厂的起源