面向对象设计：使用Java实现简单工厂模式

原创爱被打了一巴掌 2024-10-25 17:00 23阅读 0赞

简单工厂模式是一种创建型设计模式，它提供了一种创建对象的统一接口，但不需要指定具体类型。

以下是使用Java实现简单工厂模式的例子：

```java
// 定义产品类
public abstract class Product {
    protected String name;

public Product(String name) {
        this.name = name;
    }

// 提供一个获取产品名称的方法
    public String getName() {
        return name;
    }
}

// 定义具体产品的子类
public class ConcreteProductA extends Product {
    public ConcreteProductA(String name) {
        super(name);
    }
}

public class ConcreteProductB extends Product {
    public ConcreteProductB(String name) {
        super(name);
    }
}

// 简单工厂类
public class SimpleFactory {

// 定义一个抽象方法，根据传入的参数类型创建产品对象
    public abstract Product createProduct(String type);

// 测试代码
    public static void main(String[] args) {
        SimpleFactory factory;

// 如果传入的是"产品A"，则创建ConcreteProductA对象
        if ("产品A".equals(args[0]))){
            factory = new ConcreteProductASimpleFactory();
        }
        // 否则，如果传入的是"产品B"，则创建ConcreteProductB对象
        else if ("产品B".equals(args[0])))){
            factory = new ConcreteProductBSimpleFactory();
        }
        // 不支持的类型打印错误信息
        else {
            System.out.println("不支持的产品类型！");
            return;
        }

// 使用工厂方法根据传入类型创建并使用对象
        Product product = factory.createProduct(args[0]));
        System.out.println("产品名称: " + product.getName());
    }
}

// 简单工厂的实现类，根据传入的参数类型创建对应的Product对象
class ConcreteProductASimpleFactory extends SimpleFactory {
    @Override
    public Product createProduct(String type) {
        if ("产品A".equals(type)) {
            return new ConcreteProductA();
        } else {
            System.out.println("不支持的产品类型：" + type);
            return null;
        }
    }
}

class ConcreteProductBSimpleFactory extends SimpleFactory {
    @Override
    public Product createProduct(String type) {
        if ("产品B".equals(type)) {
            return new ConcreteProductB();
        } else {
            System.out.println("不支持的产品类型：" + type);
            return null;
        }
    }
}
```

这段代码定义了产品（`Product`）和具体的抽象产品A（`ConcreteProductA`），以及具体的抽象产品B（`ConcreteProductB`）。

然后创建了一个简单工厂（`SimpleFactory`）的实现类，根据传入的参数类型创建对应的Product对象。最后在main方法中测试了这个简单工厂模式。