工厂模式（Factory Pattern）是Java中一种创建型设计模式，它提供了一种创建对象的接口，而无需指定具体要创建的对象类型。工厂模式的主要目的是使类的实例化延迟到其子类，或通过接口和抽象类来进行实例化。
工厂模式定义一个用于创建对象的接口，但让子类决定实例化哪一个类。工厂模式让一个类的实例化延迟到其子类。
工厂模式的核心在于将对象的创建和使用分离，从而增加了代码的灵活性和可扩展性。通过定义一个创建对象的接口，工厂模式允许子类在需要时替换具体的实现，而客户端代码则无需修改。
在复杂的系统中，对象的创建可能涉及多个步骤和条件。工厂模式通过封装对象的创建过程，可以简化客户端代码，使其专注于业务逻辑而不是对象的实例化。
假设有一个形状（Shape）接口，以及实现该接口的多个类（如Circle、Rectangle等）。使用简单工厂模式，可以创建一个ShapeFactory类来根据输入参数返回相应的形状对象。
// Shape接口
public interface Shape {
void draw();
}
// Circle类实现Shape接口
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing Circle");
}
}
// Rectangle类实现Shape接口
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing Rectangle");
}
}
// ShapeFactory类
public class ShapeFactory {
// 使用getShape方法获取形状类型的对象
public 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;
}
}
在工厂方法模式中，每个子类都实现了工厂方法以创建对应类的对象。这种模式在需要创建不同种类的对象时特别有用。
// Shape接口
public interface Shape {
void draw();
}
// Circle类实现Shape接口
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing Circle");
}
}
// Rectangle类实现Shape接口
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing Rectangle");
}
}
// ShapeFactory接口
public interface ShapeFactory {
Shape createShape();
}
// CircleFactory类实现ShapeFactory接口
public class CircleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Circle();
}
}
// RectangleFactory类实现ShapeFactory接口
public class RectangleFactory implements ShapeFactory {
@Override
public Shape createShape() {
return new Rectangle();
}
}
抽象工厂模式用于创建相关或依赖对象的家族，而无需明确指定具体类。它提供了更高级别的抽象来封装复杂对象的创建过程。
// 抽象产品A
public interface Button {
void paint();
}
// 具体产品A1
public class WindowsButton implements Button {
@Override
public void paint() {
System.out.println("You have created a WindowsButton.");
}
}
// 具体产品A2
public class MacButton implements Button {
@Override
public void paint() {
System.out.println("You have created a MacButton.");
}
}
// 抽象产品B
public interface TextArea {
void render();
}
// 具体产品B1
public class WindowsTextArea implements TextArea {
@Override
public void render() {
System.out.println("You have created a WindowsTextArea.");
}
}
// 具体产品B2
public class MacTextArea implements TextArea {
@Override
public void render() {
System.out.println("You have created a MacTextArea.");
}
}
// 抽象工厂
public interface GUIFactory {
Button createButton();
TextArea createTextArea();
}
// 具体工厂1
public class WindowsFactory implements GUIFactory {
@Override
public Button createButton() {
return new WindowsButton();
}
@Override
public TextArea createTextArea() {
return new WindowsTextArea();
}
}
// 具体工厂2
public class MacFactory implements GUIFactory {
@Override
public Button createButton() {
return new MacButton();
}
@Override
public TextArea createTextArea() {
return new MacTextArea();
}
}
// 客户端代码
public class Application {
private Button button;
private TextArea textArea;
// 构造函数接收一个工厂对象
public Application(GUIFactory factory) {
button = factory.createButton();
textArea = factory.createTextArea();
}
public void paint() {
button.paint();
textArea.render();
}
public static void main(String[] args) {
GUIFactory factory;
String osName = System.getProperty("os.name").toLowerCase();
if (osName.contains("win")) {
factory = new WindowsFactory();
} else if (osName.contains("mac")) {
factory = new MacFactory();
} else {
throw new UnsupportedOperationException("Unsupported OS");
}
Application app = new Application(factory);
app.paint();
}
}
工厂模式是一种非常有用的设计模式，它通过将对象的创建过程封装在工厂类中，从而简化了客户端代码并提高了系统的可扩展性和灵活性。在复杂对象创建的场景中，工厂模式尤其能够发挥其优势，使代码更加清晰和易于维护。