Java工厂模式详解

开头解决方案

在软件开发中，创建对象时直接使用new关键字可能会导致代码的耦合性过高。为了解决这个问题，Java提供了工厂模式，这是一种常用的创建型设计模式。通过工厂模式，我们可以将对象的创建逻辑封装到一个独立的类或方法中，从而降低系统的耦合度，并提高代码的可维护性和扩展性。

Java中的工厂模式，包括简单工厂模式、工厂方法模式和抽象工厂模式，并通过实际代码示例来帮助理解每种模式的应用场景和实现方式。

1. 简单工厂模式

简单工厂模式是一种最简单的工厂模式，它通过一个工厂类来负责创建所有类型的对象。虽然它不属于GoF设计模式之一，但在实际开发中非常常用。

解决问题

假设我们有一个需求：根据用户输入的类型（如"circle"、"square"等），创建对应的图形对象并计算其面积。

实现代码

java
// 定义一个接口
interface Shape {
    void draw();
}</p>

<p>// 实现类1
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}</p>

<p>// 实现类2
class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Square");
    }
}</p>

<p>// 简单工厂类
class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}</p>

<p>// 测试类
public class SimpleFactoryDemo {
    public static void main(String[] args) {
        Shape shape1 = ShapeFactory.getShape("CIRCLE");
        shape1.draw(); // 输出: Drawing Circle</p>

<pre><code>    Shape shape2 = ShapeFactory.getShape("SQUARE");
    shape2.draw(); // 输出: Drawing Square
}

}

优点

将对象的创建逻辑集中到一个地方，便于维护。
客户端无需知道具体实现类的细节。

缺点

违反开闭原则，当需要新增一个形状时，必须修改工厂类。

2. 工厂方法模式

工厂方法模式是简单工厂模式的改进版，它通过定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。

解决问题

继续以图形为例，我们希望每个子类自己决定如何创建对象，而不是由一个统一的工厂类来管理。

实现代码

java
// 定义一个接口
interface Shape {
    void draw();
}</p>

<p>// 实现类1
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}</p>

<p>// 实现类2
class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Square");
    }
}</p>

<p>// 抽象工厂接口
interface ShapeFactory {
    Shape getShape();
}</p>

<p>// 具体工厂1
class CircleFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Circle();
    }
}</p>

<p>// 具体工厂2
class SquareFactory implements ShapeFactory {
    @Override
    public Shape getShape() {
        return new Square();
    }
}</p>

<p>// 测试类
public class FactoryMethodDemo {
    public static void main(String[] args) {
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.getShape();
        circle.draw(); // 输出: Drawing Circle</p>

<pre><code>    ShapeFactory squareFactory = new SquareFactory();
    Shape square = squareFactory.getShape();
    square.draw(); // 输出: Drawing Square
}

}

优点

符合开闭原则，新增形状时无需修改现有代码。
提高了灵活性，每个工厂类都可以独立扩展。

缺点

引入了更多的类，增加了复杂度。

3. 抽象工厂模式

抽象工厂模式提供了一种创建一系列相关或依赖对象的接口，而无需指定它们具体的类。它是工厂方法模式的进一步扩展。

解决问题

假设我们需要创建两种类型的对象：颜色（Color）和形状（Shape），并且这些对象之间存在关联关系。例如，红色圆形和蓝色正方形。

实现代码

java
// 定义颜色接口
interface Color {
    void fill();
}</p>

<p>// 实现类1
class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling Red color");
    }
}</p>

<p>// 实现类2
class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Filling Blue color");
    }
}</p>

<p>// 定义形状接口
interface Shape {
    void draw();
}</p>

<p>// 实现类1
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Circle");
    }
}</p>

<p>// 实现类2
class Square implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing Square");
    }
}</p>

<p>// 抽象工厂接口
interface AbstractFactory {
    Color getColor(String color);
    Shape getShape(String shape);
}</p>

<p>// 具体工厂1
class ShapeFactory implements AbstractFactory {
    @Override
    public Color getColor(String color) {
        return null; // 不处理颜色
    }</p>

<pre><code>@Override
public Shape getShape(String shape) {
    if (shape.equalsIgnoreCase("CIRCLE")) {
        return new Circle();
    } else if (shape.equalsIgnoreCase("SQUARE")) {
        return new Square();
    }
    return null;
}

}

// 具体工厂2
class ColorFactory implements AbstractFactory {
@Override
public Color getColor(String color) {
if (color.equalsIgnoreCase("RED")) {
return new Red();
} else if (color.equalsIgnoreCase("BLUE")) {
return new Blue();
}
return null;
}

@Override
public Shape getShape(String shape) {
    return null; // 不处理形状
}

}

// 工厂生成器
class FactoryProducer {
public static AbstractFactory getFactory(String choice) {
if (choice.equalsIgnoreCase("SHAPE")) {
return new ShapeFactory();
} else if (choice.equalsIgnoreCase("COLOR")) {
return new ColorFactory();
}
return null;
}
}

// 测试类
public class AbstractFactoryDemo {
public static void main(String[] args) {
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
Shape shape1 = shapeFactory.getShape("CIRCLE");
shape1.draw(); // 输出: Drawing Circle

    AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
    Color color1 = colorFactory.getColor("RED");
    color1.fill(); // 输出: Filling Red color
}

}

优点

提供了一个创建一系列相关对象的接口，减少了客户端代码与具体类的耦合。
易于扩展新的产品族。

缺点

系统变得更加复杂，引入了更多类和接口。

工厂模式是创建型设计模式的一种，主要用于解决对象创建的问题。三种常见的工厂模式：
1. 简单工厂模式：适合小型项目，但不满足开闭原则。
2. 工厂方法模式：通过子类决定创建哪个对象，符合开闭原则。
3. 抽象工厂模式：适用于创建一组相关或依赖的对象。

根据实际需求选择合适的工厂模式，可以有效降低代码耦合度，提高系统的可维护性和扩展性。

// 来源：https://www.nzw6.com

Java工厂模式详解

开头解决方案

1. 简单工厂模式

解决问题

实现代码

优点

缺点

2. 工厂方法模式

解决问题

实现代码

优点

缺点

3. 抽象工厂模式

解决问题

实现代码

优点

缺点

相关推荐：