简单工厂模式（Simple Factory Pattern）是一种创建型设计模式，提供一个创建对象的接口，但由工厂类来决定具体实例化哪个类。在简单工厂模式中，创建对象的逻辑被隐藏在工厂类的内部。
下面通过一个示例代码来说明简单工厂模式的使用。
假设我们有一个图形类（Shape），包括圆形（Circle）、矩形（Rectangle）和三角形（Triangle）三种实现。我们希望根据用户输入的图形类型，创建相应的对象。
定义图形接口（Shape）：
```java
public interface Shape {
void draw();
}
```
实现具体的图形类，包括圆形（Circle）、矩形（Rectangle）和三角形（Triangle）：
```java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("我是一个圆形");
}
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("我是一个矩形");
}
}
public class Triangle implements Shape {
@Override
public void draw() {
System.out.println("我是一个三角形");
}
}
```
定义一个工厂类（ShapeFactory），根据用户输入的图形类型创建相应的对象：
```java
public class ShapeFactory {
public static Shape createShape(String shapeType) {
if (shapeType == null) {
return null;
} else if (shapeType.equalsIgnoreCase("Circle")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("Rectangle")) {
return new Rectangle();
} else if (shapeType.equalsIgnoreCase("Triangle")) {
return new Triangle();
}
return null;
}
}
```
将工厂类的创建方法调用封装至客户端类（Client）中，用于根据用户输入创建对应的图形对象：
```java
public class Client {
public static void main(String[] args) {
String shapeType = "Circle";
Shape shape = ShapeFactory.createShape(shapeType);
shape.draw();
}
}
```
在上述代码中，用户输入的图形类型为"Circle"，根据用户输入，工厂类ShapeFactory将创建一个圆形对象并调用其draw()方法来绘制圆形。
通过简单工厂模式，我们将对象的创建逻辑封装在工厂类中，客户端通过调用工厂类的静态方法来创建对象，从而实现了对象的创建与使用的分离，提高了代码的灵活性和可维护性。当需要增加新的图形类型时只需在工厂类中添加相应的逻辑即可，不需要修改客户端的代码。
java设计模式工厂模式怎么实现
Java设计模式之工厂模式的实现
工厂模式是一种常见的创建型设计模式，提供了一种创建对象的最佳方式。在Java编程中，工厂模式被广泛应用于对象的创建和管理，特别是在需要根据不同条件创建不同对象的场景下。我们将介绍如何在Java中实现工厂模式。
工厂模式的核心思想是将对象的创建与使用分离。通过定义一个公共的接口，然后由具体的工厂类负责创建不同类型的对象，从而使得客户端代码只需要关注接口而无需关心具体的实现类。这种方式能够达到代码的解耦、降低维护成本和增加可扩展性的效果。
在Java中，我们可以通过两种方式实现工厂模式：简单工厂模式和抽象工厂模式。
1. 简单工厂模式
简单工厂模式是工厂模式中最简单的一种实现方式。通过一个工厂类负责创建不同类型的对象，根据客户端的需求返回相应的对象。下面是一个简单工厂模式的示例代码：
```java
public interface Product {
void use();
}
public class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("使用具体产品A");
}
}
public class ConcreteProductB implements Product {
@Override
public void use() {
System.out.println("使用具体产品B");
}
}
public class SimpleFactory {
public static Product createProduct(String type) {
if (type.equals("A")) {
return new ConcreteProductA();
} else if (type.equals("B")) {
return new ConcreteProductB();
} else {
throw new IllegalArgumentException("Unsupported product type: " + type);
}
}
}
public class Client {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.use();
Product productB = SimpleFactory.createProduct("B");
productB.use();
}
}
```
在上述代码中，我们定义了一个接口`Product`，具体的产品类`ConcreteProductA`和`ConcreteProductB`实现了该接口。`SimpleFactory`作为工厂类负责创建不同类型的产品。客户端通过调用`SimpleFactory`的`createProduct`方法来创建产品对象。
2. 抽象工厂模式
抽象工厂模式是工厂模式中更为复杂的一种实现方式。通过定义一组接口，用于创建一系列相关或依赖对象的产品族。下面是一个抽象工厂模式的示例代码：
```java
public interface ProductA {
void use();
}
public class ConcreteProductA1 implements ProductA {
@Override
public void use() {
System.out.println("使用具体产品A1");
}
}
public class ConcreteProductA2 implements ProductA {
@Override
public void use() {
System.out.println("使用具体产品A2");
}
}
public interface ProductB {
void use();
}
public class ConcreteProductB1 implements ProductB {
@Override
public void use() {
System.out.println("使用具体产品B1");
}
}
public class ConcreteProductB2 implements ProductB {
@Override
public void use() {
System.out.println("使用具体产品B2");
}
}
public interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
public class ConcreteFactory1 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
public class ConcreteFactory2 implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
public class Client {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
productA1.use();
ProductB productB1 = factory1.createProductB();
productB1.use();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
productA2.use();
ProductB productB2 = factory2.createProductB();
productB2.use();
}
}
```
在上述代码中，我们定义了两个产品族`ProductA`和`ProductB`，分别有两个具体的产品实现类。`AbstractFactory`作为抽象工厂接口，由具体的工厂类`ConcreteFactory1`和`ConcreteFactory2`负责创建相应的产品族。客户端可以根据不同的工厂选择不同的产品族。
java设计模式之工厂模式
工厂模式是一种创建型设计模式，提供了一种创建对象的最佳方式，解决了直接实例化对象的问题。在工厂模式中，我们通过调用工厂类的方法，不是直接调用对象的构造函数来创建对象。
工厂模式主要包含三个角色：抽象工厂、具体工厂和产品。抽象工厂是工厂模式的核心，定义了一个创建对象的接口，具体工厂实现了抽象工厂接口，用于创建具体的产品。产品是由具体工厂创建的，们共同实现了一个抽象产品接口。
工厂模式的优点之一是可以隐藏对象创建的细节，使得客户端代码与具体产品的创建过程解耦。客户端只需要通过工厂类创建产品对象，无需关心具体的实现细节。这样可以在不影响客户端代码的情况下，改变产品的实现方式。
工厂模式还可以根据需要创建不同类型的产品。只需要增加具体工厂和具体产品的实现，即可扩展工厂模式。这种灵活性使得工厂模式在实际项目中广泛应用。
下面以一个简单的例子来说明工厂模式的应用。假设我们在开发一个游戏，需要创建不同类型的角色，如战士、法师和射手。这些角色都有共同的基类Character，但具体的实现方式不同。
我们定义一个抽象工厂CharacterFactory，包含一个创建角色的方法createCharacter。我们定义具体的工厂WarriorFactory、MagicianFactory和ArcherFactory，们实现了CharacterFactory接口，分别用于创建战士、法师和射手角色。
我们定义一个角色的抽象基类Character，包含一个抽象方法display，用于展示角色的信息。我们定义具体的角色类Warrior、Magician和Archer，们继承了Character基类并实现了display方法。
我们在客户端代码中使用工厂类创建角色对象。客户端只需要通过CharacterFactory调用createCharacter方法，无需关心具体的角色实现方式。
通过工厂模式，我们可以很方便地扩展角色的种类，只需要增加具体工厂和具体角色的实现。如果需要创建新的角色类型，如刺客，只需要定义新的具体工厂和具体角色类。