Shulou(Shulou.com)06/01 Report--

This article focuses on "how to implement the java generator pattern". Interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Let's let the editor take you to learn how to implement the java generator pattern.

Definition:

Separate the construction of a complex object from its representation, so that the same construction process can create different representations. The generator pattern uses a director object and a specific builder object to build all the parts one by one, thus building a complete object.

Four elements:

Builder: generator interface that defines the operations of the various parts needed to create a Product object.

ConcreteBuilder: a concrete generator implementation, which implements the creation of each part and is responsible for assembling each part of the Product object, and also provides a method for the user to get the assembled product object.

Director: the mentor, also known as the director, is mainly used to use the Builder interface to build the required Product objects in a unified process.

Product: a product that represents a complex object built by the generator and contains multiple parts.

Example:

KFC is used to describe the generator pattern on the Internet, which is easy to understand.

Suppose KFC offers two packages: Orleans chicken leg burger and spicy chicken leg burger.

The Orleans package includes: an Orleans chicken leg burger, a fried chicken wing, and a glass of Sprite.

The chicken leg burger package includes: a spicy chicken leg burger, an order of French fries, and a glass of coke.

Each set meal is: staple food, non-staple food, beverage.

KFC waiters have to provide set meals according to customer requirements, so what is fixed and what is changing in this demand? Obviously, the customers all want the set meal, and the customers' purpose is the same. The set meal is full of staple food, non-staple food and drinks, which is also fixed. As for what the staple food is, what the non-staple food is and what the drink is, this is changing.

In the actual process of software development, sometimes we are faced with the creation of "a complex object", which is usually composed of a certain combination of sub-objects of each part, due to changes in requirements. Each part of this complex object or its sub-objects often have to change (for example, the customers of the chicken leg burger meal do not like cola and want to change milk tea), but their structure is relatively stable (the package has to be a staple food). Non-staple food and drinks). When faced with such a scenario, it is more appropriate to use generator mode.

Define a product class:

Public class Entity1 {...}

Public class Entity2 {...}

Public class Entity3 {...}

Public class Product {Entity1 entity1; Entity2 entity2; Entity3 entity3;}

The small modules in the product category are different and are built by them to make up the product.

According to the specific scene requirements, define n generator classes:

Public interface IBuild {

Public void createEntity1 ()

Public void createEntity2 ()

Public void createEntity3 ()

Public Product composite ()

Public Product create ();}

Public class BuildProduct implements IBuild {Product p = new Product ()

Public void createEntity1 () {

/ / p.entity1 =.}

Public Product create () {

Return composite ();}.}

Public class BuildProduct1 implements IBuild {Product p = new Product ()

Public void createEntity1 () {

/ / p.entity1 =.}

Define a commander class to uniformly dispatch project:

Public class Director {

Private IBuild build

Public Director (IBuild build) {

This.build = buid;}

Public Product build () {build.create ();}

Public static void main () {IBuild build = new BuildProduct (); Director direcotr = new Director (build); Prodcut p = director.build ();}}

Advantages:

1. Using generator mode makes it unnecessary for the client to know the details of the internal composition of the product.

2, the specific builder classes are independent of each other, which is very beneficial to the expansion of the system.

3, because the specific builder is independent, the construction process can be gradually refined without any impact on other modules.

Disadvantages:

The "processing technology" of the builder mode is exposed, which makes the builder mode more flexible and makes the process opaque to customers. (to be verified, the author does not understand very well here, welcome to express his own opinion)

Application scenarios:

1, you need to generate a product object with a complex internal structure. Each internal component can be an object itself, or it can be a component of an object.

2. The properties of the product objects that need to be generated depend on each other. The construction model can enforce a step-by-step construction process.

3. Some other objects in the system will be used in the process of object creation, which are not easy to get in the process of creating product objects.

At this point, I believe you have a deeper understanding of "how to implement the java generator pattern". You might as well do it in practice. Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.