工厂模式

分类：简单工厂模式、工厂方法模式、抽象工厂模式
简单工厂模式包括：一个具体的工厂类，一个抽象的产品类，多个具体的产品类。
工厂方法模式：一个抽象的工厂类，多个具体的工厂类，一个抽象的产品类，多个具体的产品类。
抽象工厂模式：一个抽象的工厂类，多个具体的工厂类，多个抽象的产品类，多个具体的产品类。
简单工厂模式又被成为静态工厂方法模式，是它的一个特例。
工厂方法模式代码示例如下：

public class Main {

    public Main() {
        // TODO Auto-generated constructor stub
    }
    public static void main(String[] args){
        Car bmw = new BMWFactory().create();
        Car benzi = new BenziFactory().create();

    }

}

abstract class Car{

}
class BMW extends Car{
    public BMW(){
        System.out.println("生产一辆：BMW");
    }
}
class Benzi extends Car{
    public Benzi(){
        System.out.println("生产一辆：Benzi");
    }
}
interface Factory{
    public Car create();
}

class BMWFactory implements Factory{

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

}
class BenziFactory implements Factory{

    @Override
    public Car create() {
        return new Benzi();
    }

}

抽象工厂模式示例代码如下：

public class Main2 {

    public Main2() {
        // TODO Auto-generated constructor stub
    }
    public static void main(String[] args){
        Factory bmwFactory = new BMWFactory();
        Factory benziFactory = new BenziFactory();
        Condition conditionA = bmwFactory.createCondition();
        Engine EngineA = bmwFactory.createEngine();
        Condition conditionB = benziFactory.createCondition();
        Engine EngineB = benziFactory.createEngine();
    }

}
abstract class Condition{

}
class ConditionA extends Condition{
    public ConditionA(){
        System.out.println("生产A型号的空调");
    }
}
class ConditionB extends Condition{
    public ConditionB(){
        System.out.println("生产B型号的空调");
    }
}

abstract class Engine{

}
class EngineA extends Engine{
    public EngineA(){
        System.out.println("生产A型号的引擎");
    }
}
class EngineB extends Engine{
    public EngineB(){
        System.out.println("生产B型号的引擎");
    }
}

interface Factory{
    public Condition createCondition();
    public Engine createEngine();
}

class BMWFactory implements Factory{

    @Override
    public Condition createCondition() {
        return new ConditionA();
    }

    @Override
    public Engine createEngine() {
        return new EngineA();
    }
}
class BenziFactory implements Factory{

    @Override
    public Condition createCondition() {
        return new ConditionB();
    }

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

}

工厂方法模式和抽象工厂模式区别：
1、工厂方法模式每个具体的工厂类生产具体的产品示例，
抽象工厂模式每个具体的工厂类可以生产多个具体的产品示例。
2、工厂方法模式有一个抽象的产品类，抽象工厂模式可以有多个。
适用范围：工厂模式的目的就是为了解耦，当遇到复杂的情况时，
工厂方法模式就转化抽象工厂模式。