Home >Java >javaTutorial >In-depth understanding of the three implementation methods of Java factory pattern
In-depth understanding of the three implementation methods of Java factory pattern
The factory pattern is a creational design pattern, which provides the best way to create objects. Separating the object creation process from the usage process can help us decouple the code and improve the maintainability and scalability of the code. In Java, the factory pattern has a wide range of applications. This article will introduce three implementation methods of Java factory pattern and provide specific code examples.
Simple factory pattern is also called static factory pattern. Through a factory class, different instance objects are created according to different parameters. . It contains three roles: factory class, abstract product class and concrete product class.
The following is a sample code of a simple factory pattern:
// 抽象产品类 interface Product { void print(); } // 具体产品类A class ProductA implements Product { @Override public void print() { System.out.println("Product A"); } } // 具体产品类B class ProductB implements Product { @Override public void print() { System.out.println("Product B"); } } // 工厂类 class SimpleFactory { public static Product createProduct(String type) { if (type.equals("A")) { return new ProductA(); } else if (type.equals("B")) { return new ProductB(); } else { throw new IllegalArgumentException("Invalid product type."); } } } // 测试代码 public class Main { public static void main(String[] args) { Product productA = SimpleFactory.createProduct("A"); productA.print(); // 输出:Product A Product productB = SimpleFactory.createProduct("B"); productB.print(); // 输出:Product B } }
In the above code, the abstract product class Product
defines a printing method, and the specific product class ProductA
and ProductB
implement this method. The factory class SimpleFactory
uses the static method createProduct
to create the corresponding product object according to the incoming parameter type.
The factory method pattern is also called the factory pattern, which distributes the logic of creating products in the factory class to each specific factory in subcategories. It contains four roles: abstract factory class, concrete factory class, abstract product class and concrete product class.
The following is a sample code of the factory method pattern:
// 抽象产品类 interface Product { void print(); } // 具体产品类A class ProductA implements Product { @Override public void print() { System.out.println("Product A"); } } // 具体产品类B class ProductB implements Product { @Override public void print() { System.out.println("Product B"); } } // 抽象工厂类 interface Factory { Product createProduct(); } // 具体工厂类A class FactoryA implements Factory { @Override public Product createProduct() { return new ProductA(); } } // 具体工厂类B class FactoryB implements Factory { @Override public Product createProduct() { return new ProductB(); } } // 测试代码 public class Main { public static void main(String[] args) { Factory factoryA = new FactoryA(); Product productA = factoryA.createProduct(); productA.print(); // 输出:Product A Factory factoryB = new FactoryB(); Product productB = factoryB.createProduct(); productB.print(); // 输出:Product B } }
In the above code, the abstract product class Product
defines a printing method, and the specific product class ProductA
and ProductB
implement this method. The abstract factory class Factory
defines an abstract method for creating products. The specific factory classes FactoryA
and FactoryB
respectively implement this method and create corresponding product objects.
The abstract factory pattern is an extension of the factory method pattern. It consists of multiple abstract product classes, multiple concrete product classes, It consists of an abstract factory class and multiple concrete factory classes. It provides an optimal way to create a family of related or interdependent objects.
The following is a sample code of the abstract factory pattern:
// 抽象产品类A interface ProductA { void print(); } // 具体产品A1 class ProductA1 implements ProductA { @Override public void print() { System.out.println("Product A1"); } } // 具体产品A2 class ProductA2 implements ProductA { @Override public void print() { System.out.println("Product A2"); } } // 抽象产品类B interface ProductB { void print(); } // 具体产品B1 class ProductB1 implements ProductB { @Override public void print() { System.out.println("Product B1"); } } // 具体产品B2 class ProductB2 implements ProductB { @Override public void print() { System.out.println("Product B2"); } } // 抽象工厂类 interface AbstractFactory { ProductA createProductA(); ProductB createProductB(); } // 具体工厂类1 class ConcreteFactory1 implements AbstractFactory { @Override public ProductA createProductA() { return new ProductA1(); } @Override public ProductB createProductB() { return new ProductB1(); } } // 具体工厂类2 class ConcreteFactory2 implements AbstractFactory { @Override public ProductA createProductA() { return new ProductA2(); } @Override public ProductB createProductB() { return new ProductB2(); } } // 测试代码 public class Main { public static void main(String[] args) { AbstractFactory factory1 = new ConcreteFactory1(); ProductA productA1 = factory1.createProductA(); productA1.print(); // 输出:Product A1 ProductB productB1 = factory1.createProductB(); productB1.print(); // 输出:Product B1 AbstractFactory factory2 = new ConcreteFactory2(); ProductA productA2 = factory2.createProductA(); productA2.print(); // 输出:Product A2 ProductB productB2 = factory2.createProductB(); productB2.print(); // 输出:Product B2 } }
In the above code, the abstract product classes ProductA
and ProductB
respectively define a print Method, specific product classes ProductA1
, ProductA2
, ProductB1
and ProductB2
implement this method. The abstract factory class AbstractFactory
defines two abstract methods for creating products. The concrete factory classes ConcreteFactory1
and ConcreteFactory2
respectively implement these two methods to create corresponding products. object.
Through the code examples of the above three implementation methods, we can have a deeper understanding of the application and implementation of the Java factory pattern. Depending on different scenarios and needs, choosing a suitable factory pattern can help us improve the maintainability and scalability of our code, thereby making our code more flexible and easier to maintain.
The above is the detailed content of In-depth understanding of the three implementation methods of Java factory pattern. For more information, please follow other related articles on the PHP Chinese website!