设计模式之工厂模式 --- Java

工厂模式的使用场合：1. 通常要与一系列实现了同一个接口、可以被同等对待的类打交道。2. 实例化所有对象之前先一次性的进行设置，如果所用的类要求加载外部库的话，这尤其有用。
工厂模式主要由三类：
1. 简单工厂模式，由一个具体的类去创建其他类的实例，父类是相同的；
2. 工厂方法模式，是有一个抽象的父类定义公共接口，子类负责生成具体的对象，这样做的目的是将类的实例化操作延迟到子类中完成；
3. 抽象工厂模式，提供一个创建一系列相关或相互依赖对象的接口，而无须指定他们具体的类。它针对的是有多个产品的等级结构。而工厂方法模式针对的是一个产品的等级结构。

public class BMW320 {
    public BMW320(){
        System.out.println("制造-->BMW320");
    }
}

public class BMW523 {
    public BMW523(){
        System.out.println("制造-->BMW523");
    }
}

public class Customer {
    public static void main(String[] args) {
        BMW320 bmw320 = new BMW320();
        BMW523 bmw523 = new BMW523();
    }
}

客户需要知道怎么去创建一款车，客户和车紧密耦合在一起。简单工厂模式，将创建车的细节都放在了工厂里面去，直接传入车的型号就可以。这就是简单工厂模式

1. 简单工厂模式
public class Factory {
public BMW createBMW(int type) {
switch (type) {

    case 320:
        return new BMW320();

    case 523:
        return new BMW523();

    default:
        break;
    }
    return null;
}

}

abstract class BMW {
    public BMW(){

    }
}

public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("制造-->BMW320");
    }
}
public class BMW523 extends BMW{
    public BMW523(){
        System.out.println("制造-->BMW523");
    }
}

简单工厂模式不符合开闭原则，当需要增加一款车型时，需要修改工厂类的业务逻辑。所以就出现了工厂方法模式。

2. 工厂方法模式
产品类：

abstract class BMW {
    public BMW(){

    }
}
public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("制造-->BMW320");
    }
}
public class BMW523 extends BMW{
    public BMW523(){
        System.out.println("制造-->BMW523");
    }
}

工厂类：

abstract class BMW {
    public BMW(){

    }
}
public class BMW320 extends BMW {
    public BMW320() {
        System.out.println("制造-->BMW320");
    }
}
public class BMW523 extends BMW{
    public BMW523(){
        System.out.println("制造-->BMW523");
    }
}

customer:

public class Customer {
    public static void main(String[] args) {
        FactoryBMW320 factoryBMW320 = new FactoryBMW320();
        BMW320 bmw320 = factoryBMW320.createBMW();

        FactoryBMW523 factoryBMW523 = new FactoryBMW523();
        BMW523 bmw523 = factoryBMW523.createBMW();
    }
}

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式的"上帝类"。但是当产品种类非常多时，出现产品族。这就是需要用到抽象工厂模式。

3. 抽象工厂模式
产品类：

public interface Engine {

}

public class EngineA extends Engine {
    //do
}

public class EngineB extends Engine {
    //do
}

public interface Aircondition{

}

public class AirconditionA extends Engine {
    //do
}

public class AirconditionB extends Engine {
    //do
}

工厂类：

public class Factory {
    public BMW createBMW(int type) {
        switch (type) {

        case 320:
            return new BMW320();

        case 523:
            return new BMW523();

        default:
            break;
        }
        return null;
    }
}

customer:

public class Customer {
    public static void main(String[] args) {
        Factory factory = new Factory();
        BMW bmw320 = factory.createBMW(320);
        BMW bmw523 = factory.createBMW(523);
    }
}

创建工厂类：

public interface AbstractFactory {
    public Engine createEngine();
    public Aircondition createAircondition();
}

// 工厂A
public class FactoryA implements AbstractFactory{
    //
    //
}

// 工厂B
public class FactoryB implements AbstractFactory{
    //
    //
}

//customer side
public class Customer {
    public static void main(String[] args) {
        AbstractFactory fa = new FactoryA();
        //fa.
        //
        AbstractFactory fb = new FactoryB();
        //fb.
        //
    }
}