工厂设计模式之：简单工厂、工厂方法、抽象工厂

简单工厂模式（Simple Factory）：简单工厂模式又叫静态工厂模式，顾名思义，通过一个具体的工厂类，在该工厂类中定义返回值为不同实例对象的静态方法，来获得各种具体的实例对象。

工厂方法模式（Factory Method）：建立一个抽象工厂，其不同的工厂实例用来创建不同的产品实例对象（单个产品），如果要增加新的产品，只需增加新的产品工厂即可。符合开闭原则。

抽象工厂模式（Abstract Factory）：建立一个抽象工厂，用来实例化工厂子类，这些工厂子类用来生产对应的产品族（即一组对象实例）。

代码：

package com.yan.factory;

/**
 * 接口Car的一个实现类CarA
 * 
 * @author Yan
 *
 */
public class CarA implements Car {

    public CarA() {
    }

    public void run() {
        System.out.println("CarA is running...");
    }
}

package com.yan.factory;

/**
 * 接口Car的一个实现类CarB
 * 
 * @author Yan
 *
 */
public class CarB implements Car {

    public CarB() {
    }

    public void run() {
        System.out.println("CarB is running...");
    }
}

package com.yan.factory;

/**
 * 接口Car的一个实现类CarC
 * 
 * @author Yan
 *
 */
public class CarC implements Car {

    public CarC() {
    }

    public void run() {
        System.out.println("CarC is running...");
    }
}

package com.yan.factory;

/**
 * 静态工厂类CarFactory，用来创建Car实例
 * 
 * @author Yan
 *
 */
public class CarFactory {

    public CarFactory() {
    }

    public static Car getCar(String car) {
        switch (car) {
        case "CarA":
            return new CarA();
        case "CarB":
            return new CarB();
        case "CarC":
            return new CarC();

        default:
            System.out.println("Illeagle input...");
            return null;
        }
    }

}

package com.yan.factory;

/**
 * 用于测试静态工厂的客户端Client
 * 
 * @author Yan
 *
 */
public class Client {

    public Client() {
    }

    public static void main(String[] args) {
        Car carA = CarFactory.getCar("CarA");
        Car carB = CarFactory.getCar("CarC");
        Car carC = CarFactory.getCar("CarB");
        carA.run();
        carB.run();
        carC.run();
    }
}

 工厂方法模式：

 创建工厂接口

package com.yan.factoryMethod;

public interface FactoryInterface {
    Car createCar();
}

 分别创建CarA、CarB、CarC的工厂类

package com.yan.factoryMethod;

/**
 * 工厂接口FactoryInterface的实现工厂类CarAFactory，用来创建CarA实例
 * 
 * @author Yan
 *
 */
public class CarAFactory implements FactoryInterface {

    public CarAFactory() {
    }

    @Override
    public Car createCar() {
        return new CarA();
    }

}

package com.yan.factoryMethod;

/**
 * 工厂接口FactoryInterface的实现工厂类CarBFactory，用来创建CarB实例
 * 
 * @author Yan
 *
 */
public class CarBFactory implements FactoryInterface {

    public CarBFactory() {
    }

    @Override
    public Car createCar() {
        return new CarB();
    }

}

package com.yan.factoryMethod;

/**
 * 工厂接口FactoryInterface的实现工厂类CarBFactory，用来创建CarB实例
 * 
 * @author Yan
 *
 */
public class CarCFactory implements FactoryInterface {

    public CarCFactory() {
    }

    @Override
    public Car createCar() {
        return new CarC();
    }

}

测试客户端

package com.yan.factoryMethod;

/**
 * 用于测试的客户端Client
 * 
 * @author Yan
 *
 */
public class Client {

    public Client() {
    }

    public static void main(String[] args) {
        Car carA = new CarAFactory().createCar();
        Car carB = new CarBFactory().createCar();
        Car carC = new CarCFactory().createCar();
        carA.run();
        carB.run();
        carC.run();
    }
}

抽象工厂模式:需要用到产品族的概念，实现工厂接口的各个工厂分别负责一个产品族的生产。

1.引擎（高端、低端）

2.座椅（高端、低端）

3.工厂（高端（高端引擎、高端座椅）、低端（低端引擎、低端座椅））

package com.yan.abstractFactory;

/**
 * 引擎接口
 * 
 * @author Yan
 *
 */
public interface Engine {

    void engineMethod();
}

package com.yan.abstractFactory;

/**
 * 座椅接口
 * 
 * @author Yan
 *
 */
public interface Seat {
    void seatmethod();

}

package com.yan.abstractFactory;

/**
 * 定义工厂接口，用来定义生产产品要用到的方法
 * 
 * @author Yan
 *
 */
public interface FactoryInterface {
    Engine createEngine();

    Seat createSeat();
}

package com.yan.abstractFactory;

/**
 * 定义一个低端引擎类，实现引擎接口
 * 
 * @author Yan
 *
 */
public class LowEngine implements Engine {

    public LowEngine() {
    }

    @Override
    public void engineMethod() {
        System.out.println("This is a low engine...");
    }

}

package com.yan.abstractFactory;

/**
 * 定义一个低端座椅类，实现座椅接口
 * 
 * @author Yan
 *
 */
public class LowSeat implements Seat {

    public LowSeat() {
    }

    @Override
    public void seatmethod() {
        System.out.println("This is a low seat...");
    }

}

package com.yan.abstractFactory;

/**
 * 定义一个低端工厂类，实现工厂接口，用于生产低端产品族
 * 
 * @author Yan
 *
 */
public class LowFactory implements FactoryInterface {

    public LowFactory() {
    }

    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

}

package com.yan.abstractFactory;

/**
 * 定义高端引擎类，实现引擎接口
 * 
 * @author Yan
 *
 */
public class LuxuryEngine implements Engine {

    public LuxuryEngine() {
    }

    @Override
    public void engineMethod() {
        System.out.println("This is a Luxury Engine...");
    }

}

package com.yan.abstractFactory;

/**
 * 定义一个高端座椅类，实现座椅接口
 * 
 * @author Yan
 *
 */
public class LuxurySeat implements Seat {

    public LuxurySeat() {
    }

    @Override
    public void seatmethod() {
        System.out.println("This is a luxury seat...");
    }

}

package com.yan.abstractFactory;

/**
 * 定义一个高端工厂，实现工厂接口，用来生产高端的产品族
 * 
 * @author Yan
 *
 */
public class LuxuryFactory implements FactoryInterface {

    public LuxuryFactory() {
    }

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

}

package com.yan.abstractFactory;

/**
 * 用于测试抽象工厂模式的测试客户端
 * 
 * @author Yan
 *
 */
public class Client {

    public Client() {
    }

    public static void main(String[] args) {
        /* 生成高端工厂的实例，生产高端产品 */
        FactoryInterface factory = new LuxuryFactory();
        Engine engine = factory.createEngine();
        Seat seat = factory.createSeat();
        engine.engineMethod();
        seat.seatmethod();
        /* 成产低端工厂的实例，生产低端产品 */
        FactoryInterface factory2 = new LowFactory();
        Engine engine2 = factory2.createEngine();
        Seat seat2 = factory2.createSeat();
        engine2.engineMethod();
        seat2.seatmethod();
    }

}