设计模式：可复用面向对象软件基础 第三章（1）

这本书没有办法划重点，每一句话都让人觉得精彩，适合反复阅读，下面说些自己的理解。

网上很多文章认为 Factory Method 与 Abstract Factory 之间的区别在于，后者在一个工厂中实现了一类 Factory Method，而我认为其中有着重点的不同， Abstract Factory 强调产品的特异性（如车窗与车门之间的特异性，是车的不同组件），而 Factory Method 强调产品的统一性（如法拉利与玛莎拉蒂之间的统一性，都是车么）。

Builder 与 Factory 之间的差别在于 Builder 是生产组件，然后由Director组装组件，而 Factory 是生产产品。

Abstract Factory适用于工厂中产出的产品虽然有关，但不是一类物品，比如代码中车窗和车门，这两者可以包含于一个Abstract Factory中，而对于不同的工厂，产出的同类产品应该实现一个接口

public class AbstractFactory {
    public static void main(String[] args) {
        CarFactory carFactory = BenzCarFactory.getFactory();
        carFactory.makeCarDoor().print();
        carFactory.makeCarWindow().print();

        carFactory = FerrariFactory.getFactory();
        carFactory.makeCarDoor().print();
        carFactory.makeCarWindow().print();
    }
}

interface CarFactory {
    CarWindow makeCarWindow();
    CarDoor makeCarDoor();
}

class BenzCarFactory implements CarFactory {
    private BenzCarFactory() {}

    @Override
    public CarWindow makeCarWindow() {
        return new BenzCarWindow();
    }

    @Override
    public CarDoor makeCarDoor() {
        return new BenzCarDoor();
    }

    public static BenzCarFactory getFactory() {
        return factory;
    }

    private static final BenzCarFactory factory = new BenzCarFactory();
}

class FerrariFactory implements CarFactory {
    private FerrariFactory() {}

    @Override
    public CarWindow makeCarWindow() {
        return new FerrariCarWindow();
    }

    @Override
    public CarDoor makeCarDoor() {
        return new FerrariCarDoor();
    }

    public static FerrariFactory getFactory() {
        return factory;
    }

    private static final FerrariFactory factory = new FerrariFactory();
}

interface CarWindow {
    void print();
}

interface CarDoor {
    void print();
}

class BenzCarWindow implements CarWindow {
    @Override
    public void print() {
        System.out.println("BenzCarWindow");
    }
}

class BenzCarDoor implements CarDoor {
    @Override
    public void print() {
        System.out.println("BenzCarDoor");
    }
}

class FerrariCarWindow implements CarWindow {
    @Override
    public void print() {
        System.out.println("FerrariCarWindow");
    }
}

class FerrariCarDoor implements CarDoor {
    @Override
    public void print() {
        System.out.println("FerrariCarDoor");
    }
}

 

Factory Method 产出的所有产品实现同一接口，他们之间是统一的。

public class FactoryMethod {
    public static void main(String[] args) {
        CarFactory factory = BenzFactory.getFactory();
        factory.make().print();

        factory = FerrariFactory.getFactory();
        factory.make().print();

        factory = MaseratiFactory.getFactory();
        factory.make().print();
    }
}

interface CarFactory {
    Cars make();
}

class BenzFactory implements CarFactory {
    private BenzFactory() {}

    @Override
    public Cars make() {
        return new Benz();
    }

    public static BenzFactory getFactory() {
        return factory;
    }

    private static final BenzFactory factory = new BenzFactory();
}

class FerrariFactory implements CarFactory {
    private FerrariFactory() {}

    @Override
    public Cars make() {
        return new Ferrari();
    }

    public static FerrariFactory getFactory() {
        return factory;
    }

    private static final FerrariFactory factory = new FerrariFactory();
}

class MaseratiFactory implements CarFactory {
    private MaseratiFactory() {}

    @Override
    public Cars make() {
        return new Maserati();
    }

    public static MaseratiFactory getFactory() {
        return factory;
    }

    private static final MaseratiFactory factory = new MaseratiFactory();
}

public interface Cars {
    void print();
}

class Benz implements Cars {
    @Override
    public void print() {
        System.out.println("Benz");
    }
}

class Ferrari implements Cars {
    @Override
    public void print() {
        System.out.println("Ferrari");
    }
}

class Maserati implements Cars {
    @Override
    public void print() {
        System.out.println("Maserati");
    }
}

Builder：

import java.util.LinkedList;
import java.util.List;

public class Builder {
    public static void main(String[] args) {
        Director director = new Director(new HighPriceBuilder());
        director.build();
        for (Parts parts: director.getProduct())
            parts.print();

        director = new Director(new LowPriceBuilder());
        director.build();
        for (Parts parts: director.getProduct())
            parts.print();
    }
}

class CarBuilder {
    void makeDoor() {}
    void makeWindow() {}
    void makeDecoration() {}
    void addIn(Parts parts) {
        partsList.add(parts);
    }

    List<Parts> partsList = new LinkedList<>();
}

class HighPriceBuilder extends CarBuilder {
    @Override
    void makeDoor() {
        addIn(new HighPriceDoor());
    }

    @Override
    void makeWindow() {
        addIn(new HighPriceWindow());
    }

    @Override
    void makeDecoration() {
        addIn(new Decoration());
    }
}

class LowPriceBuilder extends CarBuilder {
    @Override
    void makeDoor() {
        addIn(new LowPriceDoor());
    }

    @Override
    void makeWindow() {
        addIn(new LowPriceWindow());
    }
}

public interface Parts {
    void print();
}

class HighPriceWindow implements Parts {

    @Override
    public void print() {
        System.out.println("HighPriceWindow");
    }
}

class LowPriceWindow implements Parts {

    @Override
    public void print() {
        System.out.println("LowPriceWindow");
    }
}

class HighPriceDoor implements Parts {

    @Override
    public void print() {
        System.out.println("HighPriceDoor");
    }
}

class LowPriceDoor implements Parts {

    @Override
    public void print() {
        System.out.println("LowPriceDoor");
    }
}

class Decoration implements Parts {

    @Override
    public void print() {
        System.out.println("HighPriceDecoration");
    }
}

import java.util.List;

public class Director {
    Director(CarBuilder c) {
        carBuilder = c;
    }

    void build() {
        carBuilder.makeDecoration();
        carBuilder.makeDoor();
        carBuilder.makeWindow();
        carBuilder.makeWindow();
    }

    List<Parts> getProduct() {return carBuilder.partsList; }

    CarBuilder carBuilder;
}