简单工厂模式、工厂模式、抽象工厂模式

---

一、简单工厂模式

1.角色分类

• 工厂角色

public class ChartFactory {

    public static Chart getChart(String type){
        Chart chart = null;

        if (type.equalsIgnoreCase("histogram")){
            chart = new HistogramChart();
            return chart;
        }else if(type.equalsIgnoreCase("line")){
            chart = new LineChart();
            return chart;
        }else {
            return null;
        }
    }
}

• 抽象产品角色

public interface Chart {
    public void display();
}

• 具体产品角色

public class HistogramChart implements Chart {
    public HistogramChart(){
        System.out.println("创建柱状图");
    }
    @Override
    public void display() {
        System.out.println("显示柱状图");
    }
}

public class LineChart implements Chart {

    public LineChart(){
        System.out.println("创建折线图");
    }

    @Override
    public void display() {
        System.out.println("显示折线图");
    }
}

• 客户端

public class Client {

    public static void main(String[] args) {
        Chart chart;
        chart = ChartFactory.getChart("line");
        chart.display();
    }
}

2.理解

简单工厂创建的所有类都写在了工厂类里面，工厂类职责不够单一，后期需要加入其他类需要改动代码，不易扩展。

二、工厂模式

1.角色分类

• 抽象工厂

public interface LoggerFactory {
    public Logger createLogger();
}

• 具体工厂

public class FileLoggerFactory implements LoggerFactory{
    @Override
    public Logger createLogger() {
        return new FileLogger();
    }
}

public class DatabaseLoggerFactory implements LoggerFactory {
    @Override
    public Logger createLogger() {
        return new DatabaseLogger();
    }
}

• 抽象角色

public interface Logger {
    public void writeLog();
}

• 具体角色

public class DatabaseLogger implements Logger {
    @Override
    public void writeLog() {
        System.out.println("记录数据库日志");
    }
}

public class FileLogger implements Logger {
    @Override
    public void writeLog() {
        System.out.println("记录文件日志");
    }
}

• 客户端

public class Client01 {
    public static void main(String[] args) {
        LoggerFactory loggerFactory = new FileLoggerFactory();
        Logger logger = loggerFactory.createLogger();
        logger.writeLog();
    }
}

2.理解

工厂模式相对于简单工厂模式把工厂类的职责分开，想要添加新的工厂类只需要继承抽象工厂类就可以，有利于项目扩展新的工厂类。同时工厂发放也增加了类的数量。

三.抽象工厂模式

1.角色分类

• 抽象工厂

public interface SkinFactory {
    public Button createButton();
    public TextField createTextField();
}

• 具体工厂

public class SpringSkinFactory implements SkinFactory {
    @Override
    public Button createButton() {
        return new SpringButton();
    }

    @Override
    public TextField createTextField() {
        return new SpringTextField();
    }
}

public class SummerSkinFactory implements SkinFactory {
    @Override
    public Button createButton() {
        return new SummerButton();
    }

    @Override
    public TextField createTextField() {
        return new SummerTextField();
    }
}

• 抽象产品

public interface Button {
    public void display();
}

public interface TextField {
    public void display();
}

• 具体产品

public class SpringButton implements Button {
    @Override
    public void display() {
        System.out.println("春季按钮");
    }
}

public class SpringTextField implements TextField {
    @Override
    public void display() {
        System.out.println("春季文本输入框");
    }
}

public class SummerButton implements Button {
    @Override
    public void display() {
        System.out.println("夏季按钮");
    }
}

public class SummerTextField implements TextField {
    @Override
    public void display() {
        System.out.println("夏季文本输入框");
    }
}

• 客户端

public class Client01 {
    public static void main(String[] args) {
        SkinFactory springSkinFactory = new SpringSkinFactory();
        Button button = springSkinFactory.createButton();
        button.display();
        TextField textField = springSkinFactory.createTextField();
        textField.display();

        SkinFactory summerSkinFactory = new SummerSkinFactory();
        Button button1 = summerSkinFactory.createButton();
        TextField textField1 = summerSkinFactory.createTextField();
        button1.display();
        textField1.display();
    }
}

2.理解

抽象工厂模式相对于工厂模式增加了对产品族类的处理，一个工厂类可以生产一个产品族的类，这样就不会增加那么多产品类。

---

总结

简单工厂模式的工厂类职责过于沉重，所以类的生产都在这一个类里面，不利于后续新类的扩展。
工厂模式拆分了原来的简答工厂类，有了抽象工厂类和具体工厂类，当需要新的工厂类时只要继承抽象工厂类就可以，但这样会增加了项目中类的数量（一个新类的生产就需要一个对应的工厂类）。
抽象工厂模式增加了对产品族类（比如格力电器就是一个产品族，里面有格力电视机、格力冰箱、格力洗衣机等等）的生成，一个具体工厂类可以生产一个产品族的类，这样可以减少项目中的工厂类。