设计模式之工厂模式

简单工厂模式

根据传入的参数构造不同的子类。方法返回值类型是超类类型。
简单工厂模式例子：

public class TEST {
        //简单工厂
    public static A factoryA(String name) {
        if(name.equals("B"))
            return new B();
        else if(name.equals("C"))
            return new C();
        else if(name.equals("D"))
            return new D();
        else
            throw new IllegalArgumentException();
    }

    public static void main(String[] args) {
        factoryA("B").hello();
        factoryA("C").hello();
        factoryA("D").hello();
    }
}

public abstract class A {
    public abstract void hello();
}


public class B extends A{
    public void hello() {
        System.out.println("B");
    }
}

public class C extends A{
    public void hello() {
        System.out.println("C");
    }
}

public class D extends A{
    public void hello() {
        System.out.println("D");
    }
}

工厂方法模式

将factoryMethod设置为抽象的，由子类来实现并决定创建的对象是什么
定义：定义一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类把实例化推迟到子类。

public abstract class Factory {
    public abstract Product factoryMethod(type);

    public void doSometime(int type) {
        Product product = factoryMethod(type);

        product.doSometime();
        
    }
}


public class FactoryA extends Factory {
    public Product factoryMethod(type) {
        if(type == 1) {
            return new ProductA1();
        } else if(type == 2)
            return new ProductA2();
        else
            return null;
    }

    public void doSometime(int type) {
        Product product = factoryMethod(type);

        product.doSometime();
        
    }
}

• java.util.Calendar

抽象工厂模式

提供一个接口，用于创建相关的对象家族。

抽象工厂模式用创建的是对象家族，工厂方法模式只是用来创建一个对象。

public abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}

public class ConcreteFactory1 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA1();
    }

    AbstractProductB createProductB() {
        return new ProductB1();
    }
}

public class ConcreteFactory2 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA2();
    }

    AbstractProductB createProductB() {
        return new ProductB2();
    }
}