04工厂设计模式详解

1.概念以及实例

简介

在本文中，我们将详细介绍工厂设计模式及其作用和优势。工厂设计模式是一种创建对象的软件设计模式，它提供了一种灵活的方式来实例化和组织对象的创建。

什么是工厂设计模式

工厂设计模式是一种创建对象的设计模式，它通过一个公共接口或基类来创建对象，而无需暴露对象的具体实现。这样可以减少代码的重复，并使系统更加灵活和可扩展。

工厂设计模式的作用和优势

工厂设计模式的主要作用是将对象的创建与使用分离，从而降低耦合度。它可以隐藏对象的具体实现细节，使代码更易于理解和维护。此外，工厂设计模式还可以通过集中管理对象的创建过程，提供更好的灵活性和可扩展性。

1-简单工厂模式

定义和原理

简单工厂模式是工厂设计模式中最简单的一种形式。它通过一个工厂类来负责创建不同的对象，并根据不同的条件返回相应的实例。

示例代码和实现方式

public interface Product {
    void use();
}

public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

public class SimpleFactory {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        } else {
            throw new IllegalArgumentException("无效的产品类型");
        }
    }
}

适用场景和注意事项

简单工厂模式适用于只需根据少量条件创建对象的情况。它可以使客户端代码更加简洁，但由于所有的对象创建逻辑都集中在一个工厂类中，所以当需要添加新的产品时，需要修改工厂类的代码。

2-工厂方法模式

工厂方法模式是一种将对象的创建延迟到子类中来完成的设计模式。它通过定义一个创建对象的抽象方法，在子类中实现具体的对象创建逻辑。

示例代码和实现方式

public interface Product {
    void use();
}

public class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

public class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

public interface ProductFactory {
    Product createProduct();
}

public class ConcreteProductAFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

public class ConcreteProductBFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
}

适用场景和注意事项

工厂方法模式适用于需要根据不同条件创建不同对象的情况。它可以使系统更加灵活，但需要客户端代码与具体工厂进行耦合。

3-抽象工厂模式

抽象工厂模式是一种通过定义一个接口或抽象类来创建一系列相关或相互依赖的对象的设计模式。它将对象的创建交给具体的工厂类，并由工厂类负责创建和管理相关对象。

示例代码和实现方式

public interface ProductA {
    void use();
}

public interface ProductB {
    void use();
}

public class ConcreteProductA1 implements ProductA {
    @Override
    public void use() {
        System.out.println("使用产品A1");
    }
}

public class ConcreteProductA2 implements ProductA {
    @Override
    public void use() {
        System.out.println("使用产品A2");
    }
}

public class ConcreteProductB1 implements ProductB {
    @Override
    public void use() {
        System.out.println("使用产品B1");
    }
}

public class ConcreteProductB2 implements ProductB {
    @Override
    public void use() {
        System.out.println("使用产品B2");
    }
}

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();
    }
}

适用场景和注意事项

抽象工厂模式适用于需要创建一系列相关或相互依赖对象的情况。它可以确保系统中的所有对象都是由同一个具体工厂创建的，保证了对象之间的兼容性。但由于增加新的产品族或产品等级结构时需要修改抽象工厂和具体工厂的代码，所以增加新的产品类型比较困难。

 

2.实践

1-简单工厂

--测试

 

2-普通工厂

-测试

 

3-抽象工厂 -降低耦合

-测试

3-实践代码

Test2-简单工厂和普通工厂

CreateProductAFactory CreateProductBFactory CreateProductCFactory

package Test2;
/**
 *
 * 小工厂----只生产A物品
 * */
public class CreateProductAFactory implements CreateProductFactory{
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

package Test2;

public class CreateProductBFactory implements CreateProductFactory{
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

package Test2;

public class CreateProductCFactory implements CreateProductFactory{
    @Override
    public Product createProduct() {
        return new ProductC();
    }
}

 CreateProductFactory

package Test2;
/**
*
* 工厂接口
* */
public interface CreateProductFactory {
   public Product createProduct();//创建物品
}

 FactoryProduct

package Test2;

public class FactoryProduct {
    public Product createProduct(String name){
        if(name.equals("A")){
            return new ProductA();
        }else if(name.equals("B")){
            return new ProductB();
        }else if(name.equals("C")){
            return new ProductC();
        } else{
            System.out.println("无法创建该物品");
            return null;
        }
    }
}

 Product 

package Test2;
/*
*
* 物品接口
* */
public interface Product {
    public void use(); //创建物品
}

 ProductA  ProductB  ProductC

package Test2;

public class ProductA implements Product{
    @Override
    public void use(){
        System.out.println("创建A物品");
    }
}

package Test2;

public class ProductB implements Product{
    @Override
    public void use(){
        System.out.println("创建B物品");
    }
}

package Test2;

public class ProductC implements Product{
    @Override
    public void use(){

        System.out.println("创建C物品");
    }

}

 测试 Test2

package Test2;

public class Test {
    public static void main(String[] args){
        //创建工厂
        FactoryProduct factoryProduct = new FactoryProduct();
        Product product = factoryProduct.createProduct("A");
        product.use();//使用物品
        Product product1 = factoryProduct.createProduct("B");
        product1.use();
        Product product2 = factoryProduct.createProduct("C");
        product2.use();



        //创建工厂
        CreateProductFactory factoryA = new CreateProductAFactory();
        Product productA = factoryA.createProduct();
        productA.use();

        CreateProductFactory factoryB = new CreateProductBFactory();
        Product productB = factoryB.createProduct();
        productB.use();
        CreateProductFactory factoryC = new CreateProductCFactory();
        Product productC = factoryC.createProduct();
        productC.use();
        

    }
}

Test3 -抽象工厂 

FactoryProduct 

package Test3;

public interface FactoryProduct {
    ProductA createProductA();
    ProductB createProductB();

}

 FactoryProductImpl 

package Test3;

public class FactoryProductImpl implements FactoryProduct{

    @Override
    public ProductA createProductA() {
//        System.out.println("创建A物品");
        return new ProductAImpl();
    }

    @Override
    public ProductB createProductB() {
//        System.out.println("创建B物品");
        return new ProductBImpl();
    }

}

ProductA

package Test3;

public interface ProductA {
    void use();
}

 ProductAImpl 

package Test3;

public class ProductAImpl implements ProductA{
    @Override
    public void use() {
        System.out.println("创建A物品111");
    }
}

 ProductB 

package Test3;

public interface ProductB {
    void use();
}

ProductBImpl  

package Test3;

public class ProductBImpl implements ProductB{
    @Override
    public void use() {
        System.out.println("创建B物品111");
    }
}

测试 Test

package Test3;

public class Test {
    public static void main(String[] args){
        //创建工厂
        FactoryProductImpl factoryProduct = new FactoryProductImpl();
        //创建物品
        ProductA productA = factoryProduct.createProductA();
        ProductB productB = factoryProduct.createProductB();
        productA.use();
        productB.use();
    }
}