Java设计模式——工厂模式

目录

引言

示例场景介绍

1. 简单工厂模式

2. 工厂方法模式

3. 抽象工厂模式

总结推荐

---

引言

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式，允许客户端代码在不知道具体类的情况下创建对象。本文将详细介绍三种工厂模式的实现方式：简单工厂模式、工厂方法模式和抽象工厂模式，并通过具体的Java代码示例来展示它们的工作原理及各自的优缺点。

示例场景介绍

假设我们需要开发一个图形编辑器应用程序，该程序需要支持多种不同类型的图形元素，比如圆形（Circle）、矩形（Rectangle）和三角形（Triangle）。为了简化图形元素的创建过程，我们决定使用工厂模式来创建这些图形对象。

1. 简单工厂模式

简单工厂模式由一个工厂对象决定创建出哪一种产品类的实例。客户端不必知道所创建的具体产品类名，只需知道具体的产品类是由哪个工厂类创建的即可。

代码示例

首先定义图形接口：

public interface Shape {
    void draw();
}

定义具体图形类：

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

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

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

定义简单工厂类：

public class SimpleShapeFactory {
    public Shape createShape(String shapeType) {
        if ("CIRCLE".equalsIgnoreCase(shapeType)) {
            return new Circle();
        } else if ("RECTANGLE".equalsIgnoreCase(shapeType)) {
            return new Rectangle();
        } else if ("TRIANGLE".equalsIgnoreCase(shapeType)) {
            return new Triangle();
        }
        return null; // or throw an exception
    }
}

使用客户端代码：

public class Client {
    public static void main(String[] args) {
        SimpleShapeFactory factory = new SimpleShapeFactory();
        
        Shape circle = factory.createShape("CIRCLE");
        circle.draw();
        
        Shape rectangle = factory.createShape("RECTANGLE");
        rectangle.draw();
        
        Shape triangle = factory.createShape("TRIANGLE");
        triangle.draw();
    }
}

原理

简单工厂模式通过一个工厂类集中管理对象的创建，客户端通过传递一个参数来指定需要创建的对象类型。

优点

• 封装产品的创建细节，客户端不需要知道具体的产品类是如何创建的。

• 降低客户端代码与产品类之间的耦合度。

缺点

• 违反开闭原则，每新增一个产品都需要修改工厂类。

• 工厂类过于庞大，难以管理和维护。

2. 工厂方法模式

工厂方法模式定义了一个创建对象的接口，但让实现这个接口的类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

代码示例

定义图形接口：

public interface Shape {
    void draw();
}

定义具体图形类：

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

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

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

定义工厂接口：

public interface ShapeFactory {
    Shape createShape();
}

定义具体工厂类：

public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

public class RectangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

public class TriangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Triangle();
    }
}

使用客户端代码：

public class Client {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw();

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw();

        ShapeFactory triangleFactory = new TriangleFactory();
        Shape triangle = triangleFactory.createShape();
        triangle.draw();
    }
}

原理

工厂方法模式通过定义一个创建对象的接口，让具体子类决定实例化哪一个类。客户端通过工厂接口来创建对象。

优点

• 符合开闭原则，增加新的产品时只需新增具体工厂类。

• 更好的解耦，客户端代码只需要知道工厂接口。

缺点

• 每新增一个产品就需要新增一个工厂类，类的数量增加。

3. 抽象工厂模式

抽象工厂模式提供一个创建一系列相关或依赖对象的接口，而无需指定它们具体的类。每个具体工厂负责创建一个产品族中的所有对象。

代码示例

定义抽象产品类：

public interface AbstractShape {
    void draw();
}

public interface AbstractColor {
    void fill();
}

定义具体产品类：

public class Red implements AbstractColor {
    @Override
    public void fill() {
        System.out.println("Filling color as red.");
    }
}

public class Green implements AbstractColor {
    @Override
    public void fill() {
        System.out.println("Filling color as green.");
    }
}

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

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

定义抽象工厂类：

public interface AbstractFactory {
    AbstractShape createShape();
    AbstractColor createColor();
}

定义具体工厂类：

public class ShapeColorFactory implements AbstractFactory {
    private String colorType;
    
    public ShapeColorFactory(String colorType) {
        this.colorType = colorType;
    }

    @Override
    public AbstractShape createShape() {
        return new Circle(); // Example: Always create Circle for simplicity
    }

    @Override
    public AbstractColor createColor() {
        if ("RED".equalsIgnoreCase(colorType)) {
            return new Red();
        } else if ("GREEN".equalsIgnoreCase(colorType)) {
            return new Green();
        }
        return null; // or throw an exception
    }
}

使用客户端代码：

public class Client {
    public static void main(String[] args) {
        AbstractFactory redFactory = new ShapeColorFactory("RED");
        AbstractShape shape = redFactory.createShape();
        shape.draw();
        
        AbstractColor color = redFactory.createColor();
        color.fill();
    }
}

原理

抽象工厂模式通过定义一个创建一系列相关对象的接口，让具体工厂负责创建一个产品族中的所有对象。

优点

• 更好的解耦，客户端代码只需要知道抽象工厂接口。

• 方便增加新的产品族，只需要添加新的具体工厂类。

缺点

• 增加新的产品时需要修改工厂类。

• 系统复杂度增加，需要维护更多的工厂类。

总结推荐

从上面的讨论中可以看出，三种工厂模式各有特点。简单工厂模式适合于产品种类较少且未来扩展可能性不大的情况；工厂方法模式更适合于产品种类较多且未来可能会增加更多产品的情况；抽象工厂模式则适用于需要创建一系列相关产品族的情况。

推荐方式：对于大多数场景，工厂方法模式是较好的选择。它符合开闭原则，便于扩展，同时也保持了良好的解耦。如果系统中存在多个互不相容的产品族，并且需要创建一系列相关对象，则可以选择抽象工厂模式。简单工厂模式虽然简单易懂，但由于其违反开闭原则，因此在实际项目中使用较少。