Java中工厂模式的基本概念与原理
工厂模式是一种常见的设计模式，它旨在通过一个共同的接口来创建对象，而无需知道具体实现的细节。这种模式可以为我们提供更加灵活和可扩展的代码结构。在Java中，工厂模式有多种实现方式，包括简单工厂模式、工厂方法模式和抽象工厂模式。
- 简单工厂模式
简单工厂模式是工厂模式的最基本形式，它通过一个工厂类来创建对象。这个工厂类通常包含一个静态方法，根据不同的参数来创建不同的对象实例。以下是一个简单的示例：
public class SimpleFactory {
public static Product createProduct(String type) {
if(type.equals("A")) {
return new ConcreteProductA();
} else if(type.equals("B")) {
return new ConcreteProductB();
}
return null;
}
}
public interface Product {
void doSomething();
}
public class ConcreteProductA implements Product {
@Override
public void doSomething() {
System.out.println("Product A do something.");
}
}
public class ConcreteProductB implements Product {
@Override
public void doSomething() {
System.out.println("Product B do something.");
}
}
public class Main {
public static void main(String[] args) {
Product productA = SimpleFactory.createProduct("A");
productA.doSomething();
Product productB = SimpleFactory.createProduct("B");
productB.doSomething();
}
}在上述代码中，SimpleFactory是一个简单的工厂类，根据传入的参数创建相应的产品对象。Product是一个抽象接口，定义了产品对象的基本行为。ConcreteProductA和ConcreteProductB是具体的产品类，分别实现了Product接口。
- 工厂方法模式
工厂方法模式是在简单工厂模式的基础上进行了一定改进，它将具体的产品创建移到各自的工厂类中。这种模式通过定义一个抽象的工厂接口和多个具体的工厂类来实现对象的创建。以下是一个示例：
public interface Factory {
Product createProduct();
}
public class ConcreteFactoryA implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductA();
}
}
public class ConcreteFactoryB implements Factory {
@Override
public Product createProduct() {
return new ConcreteProductB();
}
}
public class Main {
public static void main(String[] args) {
Factory factoryA = new ConcreteFactoryA();
Product productA = factoryA.createProduct();
productA.doSomething();
Factory factoryB = new ConcreteFactoryB();
Product productB = factoryB.createProduct();
productB.doSomething();
}
}在上述代码中，Factory是一个抽象的工厂接口，定义了创建产品的方法。ConcreteFactoryA和ConcreteFactoryB是具体的工厂类，分别创建ConcreteProductA和ConcreteProductB产品对象。
- 抽象工厂模式
抽象工厂模式是工厂方法模式的进一步扩展，它对一组相关或有依赖关系的产品进行创建。这种模式提供了一个抽象的工厂接口和多个具体的工厂类，每个工厂类负责创建一组相关的产品。以下是一个示例：
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 interface ProductA {
void doSomething();
}
public class ConcreteProductA1 implements ProductA {
@Override
public void doSomething() {
System.out.println("ProductA1 do something.");
}
}
public class ConcreteProductA2 implements ProductA {
@Override
public void doSomething() {
System.out.println("ProductA2 do something.");
}
}
public interface ProductB {
void doSomething();
}
public class ConcreteProductB1 implements ProductB {
@Override
public void doSomething() {
System.out.println("ProductB1 do something.");
}
}
public class ConcreteProductB2 implements ProductB {
@Override
public void doSomething() {
System.out.println("ProductB2 do something.");
}
}
public class Main {
public static void main(String[] args) {
AbstractFactory factory1 = new ConcreteFactory1();
ProductA productA1 = factory1.createProductA();
productA1.doSomething();
ProductB productB1 = factory1.createProductB();
productB1.doSomething();
AbstractFactory factory2 = new ConcreteFactory2();
ProductA productA2 = factory2.createProductA();
productA2.doSomething();
ProductB productB2 = factory2.createProductB();
productB2.doSomething();
}
}在上述代码中，AbstractFactory是一个抽象的工厂接口，定义了创建多个产品的方法。ConcreteFactory1和ConcreteFactory2是具体的工厂类，分别创建ProductA和ProductB一组产品对象。ProductA和ProductB是抽象的产品接口，定义了产品的基本行为。ConcreteProductA1、ConcreteProductA2、ConcreteProductB1和ConcreteProductB2是具体的产品类，分别实现了ProductA和ProductB接口。
工厂模式可以帮助我们通过一个统一的接口来创建对象，将对象的创建和使用分离开来，提供更加灵活和解耦的代码结构。通过合理运用工厂模式，我们可以提高代码的可维护性和可扩展性。