工厂模式

工厂模式

工厂模式有两种，分别是：工厂方法模式和抽象工厂模式，两种工厂模式都是用于创建对象，

工厂方法模式

定义：定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。它让类把实例化推迟到子类。

案例类图

案例代码

定义Pizza抽象类

public abstract class Pizza {
    public String state;//记录是什么pizza
    public void operator1(){
        System.out.println("披萨操作1");
    }
    public void operator2(){
        System.out.println("披萨操作2");
    }
}

几个具体的Pizza子类

public class PizzaA extends Pizza{

    public PizzaA(){
        this.state="我是PizzaA";
    }
}


public class PizzaB extends Pizza{

    public PizzaB(){
        this.state="我是PizzaB";
    }
}

抽象的披萨店类

public abstract class PizzaStore {

    public  abstract  Pizza createPizza();

    public void orderPizza(){
        Pizza pizza = createPizza();
        System.out.println(pizza.state);
        pizza.operator1();
        pizza.operator2();
        System.out.println("披萨操作完成！");
    }
}

具体的店

public class PizzaStoreA extends PizzaStore{
    @Override
    public Pizza createPizza() {
        /**这个方法一般都会有一个参数，
        if(条件){
              return new PizzaB();
        }else{
           return new PizzaA();
         }**/
        System.out.println("做了一个A店口味的披萨！");
        return new PizzaA();
    }
}

public class PizzaStoreB extends PizzaStore{
    @Override
    public Pizza createPizza() {
        System.out.println("做了一个B店口味的披萨！");
        return new PizzaB();
    }
}

public static void main(String[] args) {
        PizzaStore ps = new PizzaStoreA();
        ps.orderPizza();

        ps = new PizzaStoreB();
        ps.orderPizza();
    }

测试结果

抽象工厂

定义：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

类图

代码

抽象工厂接口，定义了AB两种产品族

public abstract class AbstractFactory {
    public abstract AbstractProductA getProductA();
    public abstract AbstractProductB getProductB();
}

具体工厂，实现抽象工厂

public class ProductFactory1 extends AbstractFactory{

    @Override
    public AbstractProductA getProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB getProductB() {
        return new ProductB1();
    }
}

public class ProductFactory2 extends AbstractFactory{

    @Override
    public AbstractProductA getProductA() {
        return new ProductA2();
    }

    @Override
    public AbstractProductB getProductB() {
        return new ProductB2();
    }
    
}

产品族接口

public interface AbstractProductA {
    void toSay();
}

public interface AbstractProductB {
    void toSay();
}

具体产品

public class ProductA1 implements AbstractProductA{
    @Override
    public void toSay() {
        System.out.println("我是产品A1");
    }
}

public class ProductA2 implements AbstractProductA{
    @Override
    public void toSay() {
        System.out.println("我是产品A2");
    }
}


public class ProductB1 implements AbstractProductB{
    @Override
    public void toSay() {
        System.out.println("我是产品B1");
    }
}


public class ProductB2 implements AbstractProductB{
    @Override
    public void toSay() {
        System.out.println("我是产品B2");
    }
}

测试

 public static void main(String[] args) {

        AbstractFactory factory = new ProductFactory1();
        AbstractProductA productA = factory.getProductA();
        AbstractProductB productB=factory.getProductB();
        productA.toSay();
        productB.toSay();

        factory = new ProductFactory2();
        productA = factory.getProductA();
        productB=factory.getProductB();
        productA.toSay();
        productB.toSay();

    }

测试结果

总结

工厂方法使用继承：把对象的创建委托给子类，子类实现工厂方法来创建对象。
抽象工厂使用对象组合：对象的创建被实现在工厂接口所暴露出来的方法中。
工厂方法允许类将实例化延迟到之类进行；抽象工厂创建相关的对象家族，而不需要依赖他们的具体类。