【创建型设计模式01】工厂设计模式java实例

工厂设计模式是一种常用的创建型设计模式，它通过定义一个工厂类来创建一组类似的对象。当我们需要创建大量类似对象时，可以使用工厂设计模式来避免重复的代码，并且提高代码的可重用性和可维护性。工厂方法模式有三种实现方式：简单工厂模式、工厂方法模式和抽象工厂模式。

下面是介绍三个Java实例以说明工厂设计模式的应用：

1. 简单工厂模式。简单工厂模式也称为静态工厂模式，它是工厂方法模式的一种特殊实现，通过一个静态方法来创建对象。在这种模式中，我们只需要传入需要的类的参数，即可获得一个实例对象。例如：

public class SimpleFactory {
    public static final int PRODUCT_A = 1;
    public static final int PRODUCT_B = 2;
    public static Product createProduct(int productId) {
        if(productId == PRODUCT_A) {
              return new ProductA();
        } else if(productId == PRODUCT_B) {
              return new ProductB();
        } else {
              return null;
        }
    }
}

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

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

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

//使用方法
Product product1 = SimpleFactory.createProduct(SimpleFactory.PRODUCT_A);
Product product2 = SimpleFactory.createProduct(SimpleFactory.PRODUCT_B);
product1.use();
product2.use();

2. 工厂方法模式。工厂方法模式将对象的创建过程抽象出来，将它交给子类来实现，从而实现了对象的多态性。例如：

public interface ProductFactory {
    public Product createProduct();
}

public class ProductAFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductA();
    }
}

public class ProductBFactory implements ProductFactory {
    @Override
    public Product createProduct() {
        return new ProductB();
    }
}

//使用方法
ProductFactory factory1 = new ProductAFactory();
ProductFactory factory2 = new ProductBFactory();
Product product1 = factory1.createProduct();
Product product2 = factory2.createProduct();
product1.use();
product2.use();

3. 抽象工厂模式。抽象工厂模式在工厂方法基础上增加了一层抽象，它将工厂类抽象出来，避免了直接使用具体工厂类的问题。例如：

public interface Factory {
    public Product1 createProduct1();
    public Product2 createProduct2();
}

public class FactoryA implements Factory {
    @Override
    public Product1 createProduct1() {
        return new Product1A();
    }
 
    @Override
    public Product2 createProduct2() {
        return new Product2A();
    }
}

public class FactoryB implements Factory {
    @Override
    public Product1 createProduct1() {
        return new Product1B();
    }

    @Override
    public Product2 createProduct2() {
        return new Product2B();
    }
}

public interface Product1 {
    public void use();
}

public class Product1A implements Product1 {
    @Override
    public void use() {
        System.out.println("use Product1A");
    }
}

public class Product1B implements Product1 {
    @Override
    public void use() {
        System.out.println("use Product1B");
    }
}

public interface Product2 {
    public void use();
}

public class Product2A implements Product2 {
    @Override
    public void use() {
        System.out.println("use Product2A");
    }
}

public class Product2B implements Product2 {
    @Override
    public void use() {
        System.out.println("use Product2B");
    }
}

//使用方法
Factory factory1 = new FactoryA();
Product1 product1 = factory1.createProduct1();
Product2 product2 = factory1.createProduct2();
product1.use();
product2.use();

以上三个实例使用了不同的工厂模式，它们都具有极高的可扩展性和可维护性，可以方便地添加新的产品或者新的工厂，从而实现更加复杂的应用场景。