工厂方法笔记

简单工厂模式

/**
 * @ClassName FactoryPattern
 * @Description 工厂模式
 *      将对象的创建过程封装在工厂对象中，通过关键字获取指定的对象
 *      可以将一些复杂的创建过程封装起来
 *      如果需要增加新的实现类，需要修改工程生成对象的逻辑
 * @Author zhaozhenwei
 * @LastChangeDate 2022/3/30 15:37
 * @Version v1.0
 */
public class FactoryPatternTest {
    public static void main(String[] args) {
        Shape rectangle = ShapeFactory.getShape("Rectangle");
        rectangle.draw();

        Shape square = ShapeFactory.getShape("Square");
        square.draw();

        Shape circle = ShapeFactory.getShape("Circle");
        circle.draw();

    }
}

interface Shape {
    void draw();
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Rectangle.draw");
    }
}

class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Square.draw");
    }
}

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Circle.draw");
    }
}

class ShapeFactory {
    public static Shape getShape(String type) {
        if (null == type) {
            return null;
        }
        switch (type) {
            case "Rectangle":
                return new Rectangle();
            case "Square":
                return new Square();
            case "Circle":
                return new Circle();
            default:
                return null;
        }

    }
}

工厂模式

/**
 * @ClassName FactoryMethod
 * @Description     工厂方法模式
 *      在简单工厂中，如果需要新增新的产品，则需要修改工程方法创建工厂的逻辑，违反了开闭原则。
 *      工厂方法将工厂也抽象出来，对于每一种产品通过一个工厂去生成。
 *          新增产品的时候，通过新增工厂去实现产品的创建，不用去调整已有的代码
 * @Author zhaozhenwei
 * @LastChangeDate 2022/3/30 16:07
 * @Version v1.0
 */
public class FactoryMethodTest {
    public static void main(String[] args) {
        PhoneFactory miPhoneFactory = new MiPhoneFactory();
        miPhoneFactory.makePhone().callPhone();

        PhoneFactory iPhoneFactory = new IPhoneFactory();
        iPhoneFactory.makePhone().callPhone();
    }
}

interface Phone {
    void callPhone();
}

class MiPhone implements Phone{
    @Override
    public void callPhone() {
        System.out.println("MiPhone.callPhone");
    }
}

class IPhone implements Phone{
    @Override
    public void callPhone() {
        System.out.println("IPhone.callPhone");
    }
}

interface PhoneFactory {
    Phone makePhone();
}

class MiPhoneFactory implements PhoneFactory {
    @Override
    public Phone makePhone() {
        return new MiPhone();
    }
}

class IPhoneFactory implements PhoneFactory {
    @Override
    public Phone makePhone() {
        return new IPhone();
    }
}

抽象工厂

/**
 * @ClassName AbstractFactoryPatternTest
 * @Description 抽象工厂
 *          在工厂方法中加入多个方法，每个方法生成需要产品的一部分。
 *              比如，出去玩的时候，需要准备吃的、喝的、车子这些。
 *              则抽象工厂方法创建三个方法，用来准备。
 *              在不同的工厂实现类中，根据不同的需要，对三个方法实现不同的逻辑
 * @Author zhaozhenwei
 * @LastChangeDate 2022/3/30 15:53
 * @Version v1.0
 */
public class AbstractFactoryPatternTest {
    public static void main(String[] args) {
        IHouseholdElectricFactory factory = new MeideHouseholdElectricFactory();
        factory.createFridge().closeStorage();
        factory.createWasher().wash();
    }
}

/**
 * 冰箱
 */
interface IFridge {
    /**
     * 冷藏
     */
    void closeStorage();
}

/**
 * 洗衣机
 */
interface IWasher {
    void wash();
}

class MeideFridge implements IFridge {
    @Override
    public void closeStorage() {
        System.out.println("美的冰箱");
    }
}

class MeideWasher implements  IWasher {
    @Override
    public void wash() {
        System.out.println("美的洗衣机");
    }
}

class GeliFridge implements IFridge {
    @Override
    public void closeStorage() {
        System.out.println("格力冰箱");
    }
}

class GeliWasher implements  IWasher {
    @Override
    public void wash() {
        System.out.println("格力洗衣机");
    }
}

/**
 * 抽象工厂，生产冰箱和洗衣机
 */
interface IHouseholdElectricFactory {
    /**
     * 生产冰箱
     * @return  冰箱
     */
    IFridge createFridge();

    /**
     * 生成洗衣机
     * @return  洗衣机
     */
    IWasher createWasher();
}

/**
 * 美的工厂实现类
 */
class MeideHouseholdElectricFactory implements IHouseholdElectricFactory {
    @Override
    public IFridge createFridge() {
        return new MeideFridge();
    }

    @Override
    public IWasher createWasher() {
        return new MeideWasher();
    }
}

/**
 * 格力工厂实现类
 */
class GeliHouseholdElectricFactory implements IHouseholdElectricFactory {
    @Override
    public IFridge createFridge() {
        return new GeliFridge();
    }

    @Override
    public IWasher createWasher() {
        return new GeliWasher();
    }
}

1. 简单工厂：由一个工厂根据传入的参数返回不同的对象
2. 工厂方法：将工厂抽象出来，一个产品对应一个具体的工厂类
3. 抽象工厂：一个工厂生产一个产品族的一系列产品