每天一个java设计模式

好的，今天我来为你介绍另一种常见的Java设计模式：工厂模式（Factory Pattern）。

工厂模式是一种创建型设计模式，它提供了一种创建对象的最佳方式。在Java中，工厂模式可以分为三种：简单工厂模式、工厂方法模式、抽象工厂模式。

1. 简单工厂模式

简单工厂模式又称为静态工厂方法模式，通过一个工厂类来创建产品类的实例。具体实现方法如下：

// 抽象产品类
public interface Product {
    void doSomething();
}

// 具体产品类1
public class Product1 implements Product {
    public void doSomething() {
        System.out.println("Product1 do something...");
    }
}

// 具体产品类2
public class Product2 implements Product {
    public void doSomething() {
        System.out.println("Product2 do something...");
    }
}

// 工厂类
public class Factory {
    public static Product createProduct(String type) {
        if ("product1".equals(type)) {
            return new Product1();
        } else if ("product2".equals(type)) {
            return new Product2();
        } else {
            return null;
        }
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Product product1 = Factory.createProduct("product1");
        product1.doSomething();
        
        Product product2 = Factory.createProduct("product2");
        product2.doSomething();
    }
}

在这个实现中，抽象产品类定义了产品的公共接口，具体产品类实现了抽象产品类的接口。工厂类负责创建产品类的实例，根据传入的参数来判断需要创建哪种产品。

2. 工厂方法模式

工厂方法模式又称为多态性工厂模式，它定义了一个创建产品对象的接口，由具体的工厂类来实现。具体实现方法如下：

// 抽象产品类
public interface Product {
    void doSomething();
}

// 具体产品类1
public class Product1 implements Product {
    public void doSomething() {
        System.out.println("Product1 do something...");
    }
}

// 具体产品类2
public class Product2 implements Product {
    public void doSomething() {
        System.out.println("Product2 do something...");
    }
}

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

// 具体工厂类1
public class Factory1 implements Factory {
    public Product createProduct() {
        return new Product1();
    }
}

// 具体工厂类2
public class Factory2 implements Factory {
    public Product createProduct() {
        return new Product2();
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Factory factory1 = new Factory1();
        Product product1 = factory1.createProduct();
        product1.doSomething();
        
        Factory factory2 = new Factory2();
        Product product2 = factory2.createProduct();
        product2.doSomething();
    }
}

在这个实现中，抽象产品类和具体产品类的定义与简单工厂模式相同。工厂接口定义了创建产品对象的接口，具体的工厂类实现了工厂接口，负责创建具体的产品对象。

3. 抽象工厂模式

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

// 抽象产品A
public interface ProductA {
    void doSomething();
}

// 抽象产品B
public interface ProductB {
    void doSomething();
}

// 具体产品A1
public class ProductA1 implements ProductA {
    public void doSomething() {
        System.out.println("ProductA1 do something...");
    }
}

// 具体产品A2
public class ProductA2 implements ProductA {
    public void doSomething() {
        System.out.println("ProductA2 do something...");
    }
}

// 具体产品B1
public class ProductB1 implements ProductB {
    public void doSomething() {
        System.out.println("ProductB1 do something...");
    }
}

// 具体产品B2
public class ProductB2 implements ProductB {
    public void doSomething() {
        System.out.println("ProductB2 do something...");
    }
}

// 抽象工厂
public interface Factory {
    ProductA createProductA();
    ProductB createProductB();
}

// 具体工厂1
public class Factory1 implements Factory {
    public ProductA createProductA() {
        return new ProductA1();
    }
    public ProductB createProductB() {
        return new ProductB1();
    }
}

// 具体工厂2
public class Factory2 implements Factory {
    public ProductA createProductA() {
        return new ProductA2();
    }
    public ProductB createProductB() {
        return new ProductB2();
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Factory factory1 = new Factory1();
        ProductA productA1 = factory1.createProductA();
        productA1.doSomething();
        ProductB productB1 = factory1.createProductB();
        productB1.doSomething();
        
        Factory factory2 = new Factory2();
        ProductA productA2 = factory2.createProductA();
        productA2.doSomething();
        ProductB productB2 = factory2.createProductB();
        productB2.doSomething();
    }
}

在这个实现中，抽象产品A和抽象产品B定义了产品的公共接口，具体产品A和具体产品B实现了抽象产品的接口。抽象工厂定义了创建一系列产品对象的接口，具体工厂类实现了抽象工厂，负责创建具体的产品对象。

希望这个简单的例子能帮助你更好地理解工厂模式。如果你有任何问题或者需要进一步的解释，请随时告诉我！