设计模式——创建型模式之工厂模式

简介
工厂模式主要是为创建对象提供了接口。
分为三类：
1. 简单工厂模式(Simple Factory)
2. 工厂方法模式(Factory Method)
3. 抽象工厂模式(Abstract Factory)
这三种模式从上到下逐步抽象，并且更具一般性。还有一种分类法，就是将简单工厂模式看为工厂方法模式的一种特例，两个归为一类。下面是使用工厂模式的两种情况：
1.在编码时不能预见需要创建哪种类的实例。
2.系统不应依赖于产品类实例如何被创建、组合和表达的细节

简单工厂模式又叫做静态工厂方法模式。通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。
1.工厂（Creator）角色简单工厂模式的核心，它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用，创建所需的产品对象。

public class CarFactory {
    public static Car createCar(String type){
        if("奥迪".equals(type)){
            return new Audi();
        }else if("比亚迪".equals(type)){
            return new BYD();
        }else{
            return null;
        }
    }   
}

2.抽象（Product）角色简单工厂模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

public interface Car {
    void run();
}

3.具体产品（Concrete Product）角色简单工厂模式所创建的具体实例对象

public class Audi implements Car {

    @Override
    public void run() {
        System.out.println("Audi is running!");

    }

}

public class BYD implements Car{

    @Override
    public void run() {
        System.out.println("BYD is running!");

    }

}

创建调用者

public class Client2 {  //调用者

    public static void main(String[] args) {
        Car c1 = CarFactory.createCar("奥迪");
        Car c2 = CarFactory.createCar("比亚迪");

        c1.run();
        c2.run();
    }
}

运行结果

Audi is running!
BYD is running!

工厂方法模式又被称为多态工厂模式 。工厂方法模式的意义是定义一个创建产品对象的工厂接口，将实际创建工作推迟到子类当中。核心工厂类不再负责产品的创建，这样核心类成为一个抽象工厂角色，仅负责具体工厂子类必须实现的接口，这样进一步抽象化的好处是使得工厂方法模式可以使系统在不修改具体工厂角色的情况下引进新的产品。
1.抽象工厂（Creator）角色工厂方法模式的核心，任何工厂类都必须实现这个接口。

public interface CarFactory {
    Car creatCar();
}

2.具体工厂（ Concrete Creator）角色具体工厂类是抽象工厂的一个实现，负责实例化产品对象。

public class AudiFactory implements CarFactory{

    @Override
    public Car creatCar() {
        return new Audi();
    }
}

public class BYDFactory implements CarFactory{

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

3.抽象（Product）角色工厂方法模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

public interface Car {
    void run();
}

4.具体产品（Concrete Product）角色工厂方法模式所创建的具体实例对象

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("Audi is running!");
    }
}

public class BYD implements Car{
    @Override
    public void run() {
        System.out.println("BYD is running!");      
    }
}

创建调用者

public class Client {
    public static void main(String[] args) {
        Car c1 = new AudiFactory().creatCar();
        Car c2 = new BYDFactory().creatCar();       
        c1.run();
        c2.run();       
    }
}

运行结果

Audi is running!
BYD is running!

简单工厂和工厂方法模式的比较
工厂方法模式和简单工厂模式在定义上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类,而不像简单工厂模式, 把核心放在一个实类上。工厂方法模式可以允许很多实的工厂类从抽象工厂类继承下来, 从而可以在实际上成为多个简单工厂模式的综合,从而推广了简单工厂模式。
反过来讲,简单工厂模式是由工厂方法模式退化而来。设想如果我们非常确定一个系统只需要一个实的工厂类, 那么就不妨把抽象工厂类合并到实的工厂类中去。而这样一来,我们就退化到简单工厂模式了。

抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。
1.抽象工厂（Creator）角色抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。

public interface CarFactory {
    Engine createEngine();//生产发动机
    Seat createSeat();//生产座椅
    Tyre createTyre();//生产轮胎    
}

2.具体工厂（ Concrete Creator）角色具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。

public class LowCarFactory implements CarFactory{//低端汽车生产工厂

    @Override
    public Engine createEngine() {//低端座椅生产
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {  //低端座椅生产
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {  //低端轮胎生产
        return new LowTyre();
    }
}

public class LuxuryCarFactory implements CarFactory{//高端汽车生产工厂

    @Override
    public Engine createEngine() {//高端发动机生产
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {//高端座椅生产
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {//高端轮胎生产
        // TODO Auto-generated method stub
        return new LuxuryTyre();
    }
}

3.抽象（Product）角色抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

public interface Engine {//发动机接口
    void run();
    void start();
}

public interface Seat {//座椅接口
    void massage();
}

public interface Tyre {//轮胎接口
    void revolve();
}

4.具体产品（Concrete Product）角色抽象模式所创建的具体实例对象

class LuxuryEngine implements Engine{//高端发动机

    @Override
    public void run() {
        System.out.println("转的快");  //发动机运行

    }

    @Override
    public void start() {
        System.out.println("启动快，自动启停");//发动机启动

    }

}

class LowEngine implements Engine{//低端发动机

    @Override
    public void run() {
        System.out.println("转的慢");  //发动机运行
    }

    @Override
    public void start() {
        System.out.println("启动慢");  //发动机启动
    }   
}

class LuxurySeat implements Seat{//高端座椅

    @Override
    public void massage() {
        System.out.println("座椅很软，可按摩"); 
    }

}

class LowSeat implements Seat{//低端座椅

    @Override
    public void massage() {
        System.out.println("不可按摩"); 
    }

}

class LuxuryTyre implements Tyre{//高端轮胎

    @Override
    public void revolve() {
        System.out.println("转的快，磨损小");  
    }   
}

class LowTyre implements Tyre{//低端轮胎

    @Override
    public void revolve() {
        System.out.println("转的慢，磨损大");  
    }   
}

创建调用者

public class Client {
    public static void main(String[] args) {

        CarFactory factory = new LuxuryCarFactory();
        System.out.println("高端汽车特性：");
        Engine e = new LuxuryEngine();
        e.run();
        e.start();
        Seat s = new LuxurySeat();
        s.massage();
        Tyre t = new LuxuryTyre();
        t.revolve();
        System.out.println("--------------------------------------------------------------------");
        CarFactory fact = new LowCarFactory();
        System.out.println("低端汽车特性：");
        Engine e1 = new LowEngine();
        e1.run();
        e1.start();
        Seat s1 = new LowSeat();
        s1.massage();
        Tyre t1 = new LowTyre();
        t1.revolve();

    }
}

运行结果

高端汽车特性：
转的快
启动快，自动启停
座椅很软，可按摩
转的快，磨损小
--------------------------------------------------------------------
低端汽车特性：
转的慢
启动慢
不可按摩
转的慢，磨损大

在抽象工厂模式中，抽象产品 (AbstractProduct) 可能是一个或多个，从而构成一个或多个产品族(Product Family)。 在只有一个产品族的情况下，抽象工厂模式实际上退化到工厂方法模式。

总结：抽象工厂中方法对应产品结构，具体工厂对应产品族。
（1）简单工厂模式是由一个具体的类去创建其他类的实例，父类是相同的，父类是具体的。
（2）工厂方法模式是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成。
（3）抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。