工厂模式及其在 Java 中的实现124

简介

工厂模式是一种创建型设计模式，它为创建对象提供了一种抽象接口。通过使用工厂，客户端代码可以通过提供所需类型的名称来创建对象，而无需指定创建它的具体类。

工厂方法模式

工厂方法模式是工厂模式最基本的形式。它涉及定义一个能够创建产品对象的工厂接口。每个具体工厂实现都创建一个特定类型的产品对象。
interface Product {
void doSomething();
}
class ConcreteProductA implements Product {
@Override
public void doSomething() {
("ConcreteProductA: doSomething()");
}
}
class ConcreteProductB implements Product {
@Override
public void doSomething() {
("ConcreteProductB: doSomething()");
}
}
interface Creator {
Product factoryMethod();
}
class ConcreteCreatorA implements Creator {
@Override
public Product factoryMethod() {
return new ConcreteProductA();
}
}
class ConcreteCreatorB implements Creator {
@Override
public Product factoryMethod() {
return new ConcreteProductB();
}
}
public class FactoryMethodPattern {
public static void main(String[] args) {
Creator creator1 = new ConcreteCreatorA();
Product product1 = ();
();
Creator creator2 = new ConcreteCreatorB();
Product product2 = ();
();
}
}

简单工厂模式

简单工厂模式是一种工厂模式，它提供了一个单一的工厂类负责创建所有类型的产品对象。它使用对象的类型名称作为创建特定产品对象的密钥。
public class SimpleFactoryPattern {
public static Product createProduct(String type) {
switch (type) {
case "A":
return new ConcreteProductA();
case "B":
return new ConcreteProductB();
default:
throw new IllegalArgumentException("Invalid product type");
}
}
public static void main(String[] args) {
Product product1 = ("A");
();
Product product2 = ("B");
();
}
}

抽象工厂模式

抽象工厂模式涉及一个更高级别的工厂接口，它可以创建一系列相关或依赖的对象。它允许客户端代码通过提供所需的工厂类型名称来创建多个对象，这些对象都来自同一个产品系列。
interface AbstractFactory {
ProductA createProductA();
ProductB createProductB();
}
class ConcreteFactoryA implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA1();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB1();
}
}
class ConcreteFactoryB implements AbstractFactory {
@Override
public ProductA createProductA() {
return new ConcreteProductA2();
}
@Override
public ProductB createProductB() {
return new ConcreteProductB2();
}
}
interface ProductA {
void doSomething();
}
class ConcreteProductA1 implements ProductA {
@Override
public void doSomething() {
("ConcreteProductA1: doSomething()");
}
}
class ConcreteProductA2 implements ProductA {
@Override
public void doSomething() {
("ConcreteProductA2: doSomething()");
}
}
interface ProductB {
void doSomething();
}
class ConcreteProductB1 implements ProductB {
@Override
public void do something() {
("ConcreteProductB1: doSomething()");
}
}
class ConcreteProductB2 implements ProductB {
@Override
public void do something() {
("ConcreteProductB2: doSomething()");
}
}
public class AbstractFactoryPattern {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactoryA();
ProductA productA1 = ();
ProductB productB1 = ();
();
();
AbstractFactory factory2 = new ConcreteFactoryB();
ProductA productA2 = ();
ProductB productB2 = ();
();
();
}
}