java设计模式-工厂模式

简单工厂:

又称为静态工厂方法模式,
组成 :
(1) 工厂类角色 : 本模式核心, 含有一定的商业逻辑和判断逻辑, 用于创建产品 .
(2) 抽象产品角色 : 一般是具体产品继承的父类或者实现的接口 .
(3) 具体产品角色 : 工厂类所创建的对象就是此角色的实例, 在java中由一个具体类实现 .
缺点 : 当增加一种产品, 都需要在工厂类中增加相应的创建业务逻辑 , 这显然违背了开闭原则 .

• 产品类

public class Car {

}
public class Audi extends Car {

}
public class Bmw extends Car {

}

• 工厂类

public class SimpleFactory {
    public static Car createCar(String carType) {
        if(carType.equals("Audi")) {
            return createAudi();
        } else if (carType.equals("Bmw")) {
            return createBmw();
        }
        return null;
    }
    public static Bmw createBmw() {
        return new Bmw();
    }
    public static Audi createAudi() {
        return new Audi();
    }
}

---

工厂方法:

工厂方法模式去掉了简单工厂方法的静态属性,使得可以被子类继承, 这样在简单工厂模式里几种在工厂方法上的压力可以由工厂方法模式里的不同的工厂子类来分担 .
(1) 抽象工厂角色 : 工厂方法的核心, 和应用程序无关, 是具体工厂角色必须实现的接口或者必须继承的父类, 在java中用抽象类或者接口实现 .
(2) 具体工厂角色 : 它含有和具体业务相关的代码, 由应用程序调用以创建对应的具体产品对象 .
(3) 抽象产品角色 : 它是具体产品继承的父类或者实现的接口.
(4) 具体产品角色 : 具体工厂角色所创建的对象就是此角色实例 .
工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂中的”上帝类” , 这样分担了对象承受的压力, 而且这种使得结构变得灵活起来–当有新产品生产时, 只要按照抽象产品角色, 抽象工厂角色提供合同完成, 就可以被客户使用, 而不需要修改现有代码, 工厂方法的结构符合开闭原则 .

• 产品类

public abstract class Bmw {

}
public class Bmw320 extends Bmw {

    public Bmw320() {
        System.out.println("生产bmw320");
    }
}
public class Bmw523 extends Bmw {

    public Bmw523() {
        System.out.println("生产bmw523");
    }
}

• 工厂类

public abstract class FactoryBmw {
    public abstract Bmw createBmw();
}
public class FactoryBmw523 extends FactoryBmw {

    @Override
    public Bmw createBmw() {
        return new Bmw523();
    }
}

public class FactoryBmw320 extends FactoryBmw {

    @Override
    public Bmw createBmw() {
        return new Bmw320();
    }
}

• 客户端

public class Client {

    public static void main(String[] args) {
        FactoryBmw factory1 = new FactoryBmw320();
        factory1.createBmw();

        FactoryBmw factory2 = new FactoryBmw523();
        factory2.createBmw();
    }
}

---

抽象工厂:

当每一个抽象产品都有多于一个的具体子类的时候(空调有A和B型号, 发动机有A和B型号) , 工厂角色怎么知道实例化哪一个子类呢? 比如每个抽象角色产品都有两个具体角色(产品空调有两个具体产品空调A和空调B) , 抽象工厂模式提供两个具体工厂角色(宝马320系列工厂和宝马230系列工厂) , 分别对应于两个具体产品角色, 每一个具体工厂角色只负责某一个产品角色的实例化, 每一个具体工厂只负责创建抽象产品的某一个具体的子类的实例 .

• 产品类

public interface Engine {
}
public class EngineA implements Engine {
    public EngineA() {
        System.out.println("制造engine--->A");
    }
}
public class EngineB implements Engine {
    public EngineB() {
        System.out.println("制造engine--->B");
    }
}



public interface Aircondition {
}
public class AirconditionA implements Aircondition {
    public AirconditionA() {
        System.out.println("生产airCondition--->A");
    }
}
public class AirconditionB implements Aircondition {
    public AirconditionB() {
        System.out.println("生产Aircondition--->B");
    }
}

• 工厂类

public abstract class AbstractFactory {

    public abstract Engine createEngine();

    public abstract Aircondition createAircondition();
}
public class FactoryBMW523 extends AbstractFactory{
    @Override
    public Engine createEngine() {
        return new EngineB();
    }
    @Override
    public Aircondition createAircondition() {
        return new AirconditionB();
    }
}
public class FactoryBMW320 extends AbstractFactory {
    @Override
    public Engine createEngine() {

        return new EngineA();
    }
    @Override
    public Aircondition createAircondition() {

        return new AirconditionA();
    }
}

• 客户端

public class Client {

    public static void main(String[] args) {
        AbstractFactory factoryA = new FactoryBMW320();
        factoryA.createEngine();
        factoryA.createAircondition();

        AbstractFactory factoryB = new FactoryBMW523();
        factoryB.createEngine();
        factoryB.createAircondition();
    }
}

---

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