【设计模式二】工厂模式和建造者模式简介

工厂模式作用

• 用于对象的创建，将对象的组装过程封装起来，用户不必关心对象的创建过程。

工厂模式案例1

• IProduct

package com.zhangyu.factory;

public interface IProduct {
    void productMethod();
}

• Product

package com.zhangyu.factory;

public class Product implements IProduct{

    @Override
    public void productMethod() {
        System.out.println("产品");
    }
}

• IFactory

package com.zhangyu.factory;

public interface IFactory {
    IProduct createProduct();
}

• Factory

package com.zhangyu.factory;

public class Factory implements IFactory{
    @Override
    public IProduct createProduct() {
        Product product = new Product();
        return product;
    }
}

Main

package com.zhangyu.factory;

public class Main {
    public static void main(String[] args) {
        IFactory factory = new Factory();
        IProduct product = factory.createProduct();
        product.productMethod();
    }
}

工厂模式案例2（汽车组装）

• 如果不使用工厂模式。

package com.zhangyu.factory2;

interface ICar {
    void show();
}

class Car implements ICar {

    private Engine engine;
    private Wheel wheel;
    private Underpan underpan;

    public Car(Engine engine, Wheel wheel, Underpan underpan) {
        this.engine = engine;
        this.wheel = wheel;
        this.underpan = underpan;
    }


    @Override
    public void show() {
        engine.getStyle();
        wheel.getStyle();
        underpan.getStyle();
    }

}

class Engine {
    public void getStyle() {
        System.out.println("这是汽车的发动机");
    }
}

class Wheel {
    public void getStyle() {
        System.out.println("这是汽车的轮胎");
    }
}

class Underpan {
    public void getStyle() {
        System.out.println("这是汽车的底盘");
    }
}

//使用普通方法
class Main {
    public static void main(String[] args) {
        Engine engine = new Engine();
        Wheel wheel = new Wheel();
        Underpan underpan = new Underpan();
        ICar car = new Car(engine, wheel, underpan);
        car.show();
    }
}

• 使用工厂模式

interface ICar {
    void show();
}

class Car implements ICar {

    private Engine engine;
    private Wheel wheel;
    private Underpan underpan;

    public Car(Engine engine, Wheel wheel, Underpan underpan) {
        this.engine = engine;
        this.wheel = wheel;
        this.underpan = underpan;
    }


    @Override
    public void show() {
        engine.getStyle();
        wheel.getStyle();
        underpan.getStyle();
    }

}

//使用工厂方法
interface IFactory {
    ICar createCar();
}

class Factory implements IFactory {

    @Override
    public ICar createCar() {
        Engine engine = new Engine();
        Wheel wheel = new Wheel();
        Underpan underpan = new Underpan();
        ICar car = new Car(engine, wheel, underpan);
        return car;
    }
}

class Main2 {
    public static void main(String[] args) {
        IFactory factory = new Factory();
        ICar car = factory.createCar();
        car.show();
    }
}

建造者模式定义：

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

优点

• 建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在导演类中对整体而言可以取得比较好的稳定性。
• 其次，建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。

建造者模式与工厂模式对比

• 建造者模式与工厂模式是极为相似的，总体上，建造者模式仅仅只比工厂模式多了一个“导演类”的角色。
• 工厂模式封装了一种创建对象的方式，建造者模式可以封装多种或者更复杂的情况
• 一般来说，如果产品的建造很复杂，那么请用工厂模式；如果产品的建造更复杂，那么请用建造者模式。

建造者案例

• Product.java

public class Product {
    private String name;
    private String type;
    private String file;

    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                ", type='" + type + '\'' +
                ", file='" + file + '\'' +
                '}';
    }

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

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

    public void setFile(String file) {
        this.file = file;
    }
}

Builder.java

 public interface Builder {
     void setPartA(String arg1, String arg2);
     void setPartB(String arg1,String arg2,String arg3);
     Product getProduct();
}

ConcreteBuilder.java

public class ConcreteBuilder implements Builder {

    Product product = new Product();

    @Override
    public void setPartA(String arg1, String arg2) {
        product.setName(arg1);
        product.setType(arg2);
    }

    @Override
    public void setPartB(String arg1, String arg2, String arg3) {
        product.setName(arg1);
        product.setType(arg2);
        product.setFile(arg3);
    }

    @Override
    public Product getProduct() {
        return product;
    }

}

Director.java

public class Director {
   Builder builder =   new ConcreteBuilder();
   public Product getAProduct(){
       builder.setPartA("宝马","x1");
       return builder.getProduct();
   }
   public Product getBProduct(){
       builder.setPartB("宝马","x2","zhangyu");
       return builder.getProduct();
   }
}

main.java

    public void main(){
        System.out.println("你好");

        Director director = new Director();
        Product aProduct = director.getAProduct();
        System.out.println(aProduct);

        Product bProduct = director.getBProduct();
        System.out.println(bProduct);

    }

测试结果

Product{name='宝马', type='x1', file='null'}
Product{name='宝马', type='x2', file='zhangyu'}