设计模式实践：工厂模式在Java中的应用案例

原创ゝ一纸荒年。 2024-11-08 08:15 10阅读 0赞

工厂模式（Factory Pattern）是一种创建型设计模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。工厂模式主要分为三种：简单工厂模式、工厂方法模式和抽象工厂模式。

以下是工厂模式在Java中的一个应用案例：

###简单工厂模式**场景**：假设我们有一个应用程序，需要根据不同的配置文件创建不同类型的日志记录器。

**代码示例**：

```java//产品接口public interface Logger {
 void log(String message);
}

//具体产品public class ConsoleLogger implements Logger {
 public void log(String message) {
 System.out.println("Console: " + message);
 }
}

public class FileLogger implements Logger {
 public void log(String message) {
 System.out.println("File: " + message);
 }
}

//工厂类public class LoggerFactory {
 public static Logger getLogger(String type) {
if (type == null) {
 return null;
 }
if (type.equalsIgnoreCase("console")) {
 return new ConsoleLogger();
} else if (type.equalsIgnoreCase("file")) {
 return new FileLogger();
 }
 return null;
 }
}

//客户端代码public class Client {
 public static void main(String[] args) {
Logger logger = LoggerFactory.getLogger("console");
 logger.log("This is an info message.");
 }
}
```###工厂方法模式**场景**：假设我们有一个图形界面库，需要根据不同的操作系统创建不同的窗口。

**代码示例**：

```java//产品接口public interface Window {
 void draw();
}

//具体产品public class WindowsWindow implements Window {
 public void draw() {
 System.out.println("Drawing a Windows window");
 }
}

public class MacWindow implements Window {
 public void draw() {
 System.out.println("Drawing a Mac window");
 }
}

//抽象工厂public abstract class WindowFactory {
 public abstract Window createWindow();
}

//具体工厂public class WindowsWindowFactory extends WindowFactory {
 public Window createWindow() {
 return new WindowsWindow();
 }
}

public class MacWindowFactory extends WindowFactory {
 public Window createWindow() {
 return new MacWindow();
 }
}

//客户端代码public class Client {
 public static void main(String[] args) {
WindowFactory factory;
if (args.length >0 && args[0].equalsIgnoreCase("windows")) {
 factory = new WindowsWindowFactory();
} else {
 factory = new MacWindowFactory();
 }
Window window = factory.createWindow();
 window.draw();
 }
}
```###抽象工厂模式**场景**：假设我们有一个更复杂的图形界面库，需要根据不同的操作系统创建不同的窗口和按钮。

**代码示例**：

```java//产品接口public interface Window {
 void draw();
}

public interface Button {
 void paint();
}

//具体产品public class WindowsWindow implements Window {
 public void draw() {
 System.out.println("Drawing a Windows window");
 }
}

public class WindowsButton implements Button {
 public void paint() {
 System.out.println("Painting a Windows button");
 }
}

public class MacWindow implements Window {
 public void draw() {
 System.out.println("Drawing a Mac window");
 }
}

public class MacButton implements Button {
 public void paint() {
 System.out.println("Painting a Mac button");
 }
}

//抽象工厂public interface GUIFactory {
Window createWindow();
Button createButton();
}

//具体工厂public class WindowsFactory implements GUIFactory {
 public Window createWindow() {
 return new WindowsWindow();
 }
 public Button createButton() {
 return new WindowsButton();
 }
}

public class MacFactory implements GUIFactory {
 public Window createWindow() {
 return new MacWindow();
 }
 public Button createButton() {
 return new MacButton();
 }
}

//客户端代码public class Client {
 public static void main(String[] args) {
 GUIFactory factory;
if (args.length >0 && args[0].equalsIgnoreCase("windows")) {
 factory = new WindowsFactory();
} else {
 factory = new MacFactory();
 }
Window window = factory.createWindow();
Button button = factory.createButton();
 window.draw();
button.paint();
 }
}
```这些代码示例展示了工厂模式在Java中的不同应用场景。通过使用工厂模式，我们可以将对象的创建和使用分离，提高代码的灵活性和可维护性。