Java中的设计模式：深入浅出工厂模式

Java中的设计模式：深入浅出工厂模式

大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！在Java编程中，设计模式是提高代码可读性和可维护性的关键。今天我们来深入浅出地聊一聊工厂模式。

1. 工厂模式简介

工厂模式（Factory Pattern）是一种创建型设计模式，它定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂模式使得一个类的实例化延迟到其子类。工厂模式主要有三种形式：简单工厂模式、工厂方法模式和抽象工厂模式。

2. 简单工厂模式

简单工厂模式又称为静态工厂方法模式，它通过专门定义一个类来负责创建其他类的实例，被创建的实例通常具有共同的父类。以下是一个简单工厂模式的实现例子：

package cn.juwatech.factory;

abstract class Product {
    public abstract void use();
}

class ConcreteProductA extends Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

class ConcreteProductB extends Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

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("Unknown product type");
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Product productA = SimpleFactory.createProduct("A");
        productA.use();
        Product productB = SimpleFactory.createProduct("B");
        productB.use();
    }
}

3. 工厂方法模式

工厂方法模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个。工厂方法让类的实例化推迟到子类。下面是工厂方法模式的示例：

package cn.juwatech.factorymethod;

abstract class Product {
    public abstract void use();
}

class ConcreteProductA extends Product {
    @Override
    public void use() {
        System.out.println("Using Product A");
    }
}

class ConcreteProductB extends Product {
    @Override
    public void use() {
        System.out.println("Using Product B");
    }
}

interface Factory {
    Product createProduct();
}

class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

public class Client {
    public static void main(String[] args) {
        Factory factoryA = new ConcreteFactoryA();
        Product productA = factoryA.createProduct();
        productA.use();
        Factory factoryB = new ConcreteFactoryB();
        Product productB = factoryB.createProduct();
        productB.use();
    }
}

4. 抽象工厂模式

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

package cn.juwatech.abstractfactory;

interface ProductA {
    void use();
}

class ConcreteProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A1");
    }
}

class ConcreteProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("Using Product A2");
    }
}

interface ProductB {
    void eat();
}

class ConcreteProductB1 implements ProductB {
    @Override
    public void eat() {
        System.out.println("Eating Product B1");
    }
}

class ConcreteProductB2 implements ProductB {
    @Override
    public void eat() {
        System.out.println("Eating Product B2");
    }
}

interface AbstractFactory {
    ProductA createProductA();
    ProductB createProductB();
}

class ConcreteFactory1 implements AbstractFactory {
    @Override
    public ProductA createProductA() {
        return new ConcreteProductA1();
    }

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

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();
        ProductB productB1 = factory1.createProductB();
        productA1.use();
        productB1.eat();
        
        AbstractFactory factory2 = new ConcreteFactory2();
        ProductA productA2 = factory2.createProductA();
        ProductB productB2 = factory2.createProductB();
        productA2.use();
        productB2.eat();
    }
}

5. 工厂模式的应用场景

工厂模式广泛应用于以下场景：

• 当一个类不知道它需要创建哪一个子类的实例时。
• 当一个类希望由子类来指定创建对象时。
• 当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪个帮助子类是代理者的信息局部化时。

本文著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！