工厂模式+抽象工厂+建造者模式

part1

工厂模式

实现产品与创建产品解耦

 

 这里我用了两个工厂，每个工厂分别创建productA, productB，这里可以只写其中一个，IProduct, ProductA, IFactory, FactoryA， 我只是想写多个工厂而已。 这里我想创建两种产品（ProductA, ProductB）用到了两个工厂（FactoryA, FactoryB）

代码:

public interface IProduct {
    public void show();
}

public class ProductA implements IProduct {
    @Override
    public void show() {
        System.out.println("show productA");
    }
}

public class ProductB implements IProduct {
    @Override
    public void show() {
        System.out.println("show productB");
    }
}

public interface IFactory {
    public IProduct createProduct();
}

public class FactoryA implements IFactory {
    @Override
    public IProduct createProduct() {
        IProduct p = new ProductA();
        return p;
    }
}

public class FactoryB implements IFactory {
    @Override
    public IProduct createProduct() {
        IProduct p2 = new ProductB();
        return p2;
    }
}

public class Test {
    public static void main(String[] args) {
        //这里只是自己创建工厂A, 工厂B。对于工厂模式，写其中一个就可以。
        IFactory factoryA = new FactoryA();
        IProduct p1 = factoryA.createProduct();

        IFactory factoryB = new FactoryB();
        IProduct p2 = factoryB.createProduct();

        p1.show();
        p2.show();
    }
}

测试结果：

 

part2

抽象工厂，也是实现产品与创建产品解耦，与工厂模式不同的是，抽象工厂是一个工厂创建一族类似的产品，而工厂模式是一个工厂只创建一个产品。 所以在加入产品和减少产品的时候，抽象工厂和工厂模式可以互相转换。

 

 

 这里的代码就比较上面单一一点。没有测用多个工厂（也可以用多个工厂创建更多的就不赘述了）

代码：

interface IProduct1 {
    public void show();
}

public interface IProduct2 {
    public void show();
}

public class Product1ImplA implements IProduct1 {
    @Override
    public void show() {
        System.out.println("show product1");
    }
}

public class Product2ImplA implements IProduct2 {
    @Override
    public void show() {
        System.out.println("show product2");
    }
}


/**
 * 注意这里与工厂方法不同， 这里是一个工厂创建一族类似的产品。而工厂方法一个工厂只创建一个产品
 */
public interface IFactory {
    public IProduct1 createProduct1();
    public IProduct2 createProduct2();
}

public class Factory implements IFactory {
    @Override
    public IProduct1 createProduct1() {
        IProduct1 p = new Product1ImplA();
        return p;
    }

    @Override
    public IProduct2 createProduct2() {
        IProduct2 p = new Product2ImplA();
        return p;
    }
}

public class Test {
    public static void main(String[] args) {
        IFactory f = new Factory();
        //一个工厂能创建两种产品
        IProduct1 p1 = f.createProduct1();
        IProduct2 p2 = f.createProduct2();
        p1.show();
        p2.show();
    }
}

测试结果：

 

 

 

part3

建造者模式

建造者模式与工厂方法的不同在于，工厂方法就是一个产品，一个工厂。产品的所有创建过程全部在工厂类中，工厂提供最终产品。

建造者模式多引入了一个导演类，建造者类提供组件的创建过程， 导演类完成具体建造。由导演类按具体实际的要求创建对象，然后提供给客户端。

所以简单一些对象创建过程用工厂方法，更为复杂的用建造者模式。

代码：

 

 

/**
 * 为了简洁这里的产品没有用接口，这里可以像上面一样用接口
 */
public class Product {
    private String name;
    private String type;

    public void show() {
        System.out.println(name + " " + type);
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setType(String type) {
        this.type = type;
    }
}

public interface IBuilder {
    public Product getProduct();
    public void setPart(String name, String type);
}

public class ConcreteBuilder implements IBuilder {
    Product p = new Product();
    @Override
    public Product getProduct() {
        return p;
    }

    @Override
    public void setPart(String name, String type) {
        p.setName(name);
        p.setType(type);
    }
}

public class Director {
    public Product getProductA() {
        ConcreteBuilder c1 = new ConcreteBuilder();
        c1.setPart("a", "typeA");
        Product product = c1.getProduct();
        return product;
    }

    public Product getProductB() {
        ConcreteBuilder c2 = new ConcreteBuilder();
        c2.setPart("b", "typeB");
        Product product = c2.getProduct();
        return product;
    }
}

public class Test {
    public static void main(String[] args) {
        Director d = new Director();
        Product productA = d.getProductA();
        Product productB = d.getProductB();

        productA.show();
        productB.show();
    }
}

 

 测试结果：