当前位置：首页 > article >正文

Java设计模式——工厂模式

article 2024/11/14 20:14:34

引言

示例场景介绍

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();
    }
}

原理

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

优点