Java工厂模式详解

我在新疆养狼

于 2024-07-11 04:19:08 发布

阅读量43

点赞数

文章标签： java 开发语言

Java工厂模式详解

大家好，我是微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！今天，让我们一起深入研究Java中的一项关键设计模式——工厂模式。工厂模式是一种创建型设计模式，它提供了一种灵活的方式来创建对象，使得整个系统更加可维护和扩展。

Java工厂模式详解

什么是工厂模式？

工厂模式是一种创建型设计模式，它提供了一个创建对象的接口，但由子类决定要实例化的类是哪一个。这种模式的核心思想是将对象的实例化延迟到其子类。

工厂模式的优势

代码解耦： 将对象的创建和使用分离，降低了系统的耦合度。
易于扩展： 当需要添加新的产品时，只需添加相应的具体产品类和对应的具体工厂类，而不需要修改现有代码。
符合开闭原则： 对扩展开放，对修改关闭。

简单工厂模式

定义

简单工厂模式并不是GoF（Gang of Four）提出的23种设计模式之一，但它是工厂模式的一个简化版本。在简单工厂模式中，一个工厂类负责创建多个产品类的对象。

示例代码

// 产品接口
interface Product {
    void produce();
}

// 具体产品A
class ConcreteProductA implements Product {
    public void produce() {
        System.out.println("Product A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    public void produce() {
        System.out.println("Product B");
    }
}

// 简单工厂类
class SimpleFactory {
    public static Product createProduct(String productType) {
        switch (productType) {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new IllegalArgumentException("Invalid product type");
        }
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.produce();  // Output: Product A

        Product productB = SimpleFactory.createProduct("B");
        productB.produce();  // Output: Product B
    }
}

工厂方法模式

定义

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法使一个类的实例化延迟到其子类。

示例代码

// 产品接口
interface Product {
    void produce();
}

// 具体产品A
class ConcreteProductA implements Product {
    public void produce() {
        System.out.println("Product A");
    }
}

// 具体产品B
class ConcreteProductB implements Product {
    public void produce() {
        System.out.println("Product B");
    }
}

// 工厂接口
interface Factory {
    Product createProduct();
}

// 具体工厂A
class ConcreteFactoryA implements Factory {
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

// 具体工厂B
class ConcreteFactoryB implements Factory {
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.produce();  // Output: Product A

        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.produce();  //

 Output: Product B
    }
}

抽象工厂模式

定义

抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

示例代码

// 产品A接口
interface ProductA {
    void produce();
}

// 产品B接口
interface ProductB {
    void produce();
}

// 具体产品A1
class ConcreteProductA1 implements ProductA {
    public void produce() {
        System.out.println("Product A1");
    }
}

// 具体产品A2
class ConcreteProductA2 implements ProductA {
    public void produce() {
        System.out.println("Product A2");
    }
}

// 具体产品B1
class ConcreteProductB1 implements ProductB {
    public void produce() {
        System.out.println("Product B1");
    }
}

// 具体产品B2
class ConcreteProductB2 implements ProductB {
    public void produce() {
        System.out.println("Product B2");
    }
}

// 抽象工厂接口
interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

    public ProductB createProductB() {
        return new ConcreteProductB1();
    }
}

// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {
    public ProductA createProductA() {
        return new ConcreteProductA2();
    }

    public ProductB createProductB() {
        return new ConcreteProductB2();
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        AbstractFactory factory1 = new ConcreteFactory1();
        ProductA productA1 = factory1.createProductA();
        productA1.produce();  // Output: Product A1

        ProductB productB1 = factory1.createProductB();
        productB1.produce();  // Output: Product B1

        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        productA2.produce();  // Output: Product A2

        ProductB productB2 = factory2.createProductB();
        productB2.produce();  // Output: Product B2
    }
}