Java设计模式：工厂模式详解
引言
1. 工厂模式的定义
2. 工厂模式的类型
2.1 简单工厂模式
2.1.1 结构
2.1.2 示例代码
2.2 工厂方法模式
2.2.1 结构
2.2.2 示例代码
2.3 抽象工厂模式
2.3.1 结构
2.3.2 示例代码
3. 工厂模式的优点
4. 工厂模式的缺点
5. 实际应用场景
6. 总结
引言
工厂模式（Factory Pattern）是创建型设计模式之一，它提供了一种创建对象的最佳方式。在工厂模式中，我们不再直接通过
new关键字来实例化对象，而是通过调用工厂方法来获取对象。这种方式将对象的创建和使用分离，提高了代码的灵活性和可维护性。
1. 工厂模式的定义
工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但允许子类决定实例化哪一个类。工厂方法让类的实例化推迟到子类。
2. 工厂模式的类型
工厂模式主要有以下几种类型：
- 简单工厂模式（Simple Factory）
- 工厂方法模式（Factory Method）
- 抽象工厂模式（Abstract Factory）
2.1 简单工厂模式
简单工厂模式不是严格意义上的设计模式，因为它并不符合开闭原则。但它提供了一个简单的对象创建机制。
2.1.1 结构
- 产品接口（Product Interface）：定义产品的公共接口。
- 具体产品（Concrete Product）：实现产品接口的具体类。
- 工厂类（Factory Class）：包含创建产品的方法，根据传入的参数返回相应的产品实例。
2.1.2 示例代码
// 产品接口
interface Shape {
void draw();
}
// 具体产品
class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Circle");
}
}
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Rectangle");
}
}
// 工厂类
class ShapeFactory {
// 根据传入的形状类型创建相应的形状对象
public static Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
}
return null;
}
}
// 客户端代码
public class SimpleFactoryDemo {
public static void main(String[] args) {
Shape circle = ShapeFactory.getShape("CIRCLE");
circle.draw();
Shape rectangle = ShapeFactory.getShape("RECTANGLE");
rectangle.draw();
}
}2.2 工厂方法模式
工厂方法模式定义了一个用于创建对象的接口，但由子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
2.2.1 结构
- 产品接口（Product Interface）：定义产品的公共接口。
- 具体产品（Concrete Product）：实现产品接口的具体类。
- 工厂接口（Factory Interface）：声明创建产品的方法。
- 具体工厂（Concrete Factory）：实现工厂接口，创建具体的产品实例。
2.2.2 示例代码
// 产品接口
interface Shape {
void draw();
}
// 具体产品
class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Circle");
}
}
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Rectangle");
}
}
// 工厂接口
interface ShapeFactory {
Shape createShape();
}
// 具体工厂
class CircleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Circle();
}
}
class RectangleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Rectangle();
}
}
// 客户端代码
public class FactoryMethodDemo {
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();
}
}2.3 抽象工厂模式
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
2.3.1 结构
- 抽象产品接口（Abstract Product Interface）：定义一组产品接口。
- 具体产品（Concrete Product）：实现抽象产品接口的具体类。
- 抽象工厂接口（Abstract Factory Interface）：声明创建抽象产品的方法。
- 具体工厂（Concrete Factory）：实现抽象工厂接口，创建具体的产品实例。
2.3.2 示例代码
// 抽象产品接口
interface Shape {
void draw();
}
interface Color {
void fill();
}
// 具体产品
class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Circle");
}
}
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a Rectangle");
}
}
class Red implements Color {
@Override
public void fill() {
System.out.println("Filling with Red color");
}
}
class Green implements Color {
@Override
public void fill() {
System.out.println("Filling with Green color");
}
}
// 抽象工厂接口
interface AbstractFactory {
Shape createShape(String shapeType);
Color createColor(String colorType);
}
// 具体工厂
class ShapeFactory implements AbstractFactory {
@Override
public Shape createShape(String shapeType) {
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
}
return null;
}
@Override
public Color createColor(String colorType) {
return null;
}
}
class ColorFactory implements AbstractFactory {
@Override
public Shape createShape(String shapeType) {
return null;
}
@Override
public Color createColor(String colorType) {
if (colorType.equalsIgnoreCase("RED")) {
return new Red();
} else if (colorType.equalsIgnoreCase("GREEN")) {
return new Green();
}
return null;
}
}
// 客户端代码
public class AbstractFactoryDemo {
public static void main(String[] args) {
AbstractFactory shapeFactory = new ShapeFactory();
Shape circle = shapeFactory.createShape("CIRCLE");
circle.draw();
AbstractFactory colorFactory = new ColorFactory();
Color red = colorFactory.createColor("RED");
red.fill();
}
}3. 工厂模式的优点
- 封装性：对象的创建过程被封装在工厂方法中，客户端不需要知道具体的创建细节。
- 解耦：客户端与具体的产品类解耦，可以方便地更换具体的产品类。
- 扩展性：添加新的产品类时，只需扩展工厂类即可，不需要修改现有的代码。
- 一致性：所有对象都通过工厂方法创建，确保了创建的一致性和完整性。
4. 工厂模式的缺点
- 增加复杂度：引入了额外的工厂类，增加了系统的复杂度。
- 单一职责原则：工厂类可能变得非常庞大，违反了单一职责原则。
5. 实际应用场景
- 数据库访问层：根据不同的数据库类型（如 MySQL、Oracle），创建相应的数据库连接对象。
- 日志系统：根据不同的日志级别（如 DEBUG、INFO、ERROR），创建相应的日志记录器。
- 图形界面：根据不同的平台（如 Windows、Linux），创建相应的 UI 控件。
6. 总结
工厂模式是一种非常实用的设计模式，它可以提高代码的可维护性和扩展性。通过将对象的创建过程封装在工厂类中，客户端可以更加灵活地使用对象，而不必关心具体的创建细节。