------Factory Method Pattern for Java 23 design Patterns

First, the factory method mode

There are three types of factory method models

1, Ordinary Factory mode : is to establish a factory class, the implementation of the same interface for some classes to create instances. First look at the diagram:

Here's an example: (Let's give an example of sending an email and a text message)

First, create a common interface for both:

1. Public interface Sender {
2. public void Send ();
3. }

Second, create the implementation class:

1. public class MailSender implements Sender {
2. @Override
3. public void Send () {
4. System.out.println ("This is mailsender!");
5. }
6. }

1. public class Smssender implements Sender {
3. @Override
4. public void Send () {
5. System.out.println ("This is SMS sender!");
6. }
7. }

Finally, build the factory class:

2. public class Sendfactory {
6. Public Sender Produce (String type) {
8. if ("Mail". Equals (type)) {
10. return new MailSender ();
12. } else if ("SMS". Equals (type)) {
14. return new Smssender ();
16. } else {
18. System.out.println ("Please enter the correct type!");
20. return null;
22. }
24. }
26. }

Let's test it out:

1. public class Factorytest {
3. public static void Main (string[] args) {
4. Sendfactory factory = new Sendfactory ();
5. Sender sender = factory.produce ("SMS");
6. Sender. Send ();
7. }
8. }

Output: This is SMS sender!

2, multiple factory method mode , is the improvement of the common factory method mode, in the normal factory method mode, if the passed string error, the object cannot be created correctly, and the multiple factory method pattern is to provide multiple factory methods, create the object respectively. Diagram:

Make the above code changes, change the next Sendfactory class on the line, as follows:

public class Sendfactory {public Sender producemail () {

1. return new MailSender ();
2. }
4. Public Sender producesms () {
5. return new Smssender ();
6. }
7. }

The test classes are as follows:

1. public class Factorytest {
3. public static void Main (string[] args) {
4. Sendfactory factory = new Sendfactory ();
5. Sender sender = Factory.producemail ();
6. Sender. Send ();
7. }
8. }

Output: This is mailsender!

2.2, Static factory method mode , the above method of multiple factory methods to static, do not need to create an instance, directly call.

1. public class Sendfactory {
3. public static Sender Producemail () {
4. return new MailSender ();
5. }
7. public static Sender producesms () {
8. return new Smssender ();
9. }
10. }

[Java]View Plaincopy

1. public class Factorytest {
3. public static void Main (string[] args) {
4. Sender sender = Sendfactory.producemail ();
5. Sender. Send ();
6. }
7. }

Output: This is mailsender!

In general, the factory model is suitable: when a large number of products need to be created, and have a common interface, can be created through the factory method mode. In the above three modes, the first if the incoming string is wrong, the object is not created correctly, the third is relative to the second, do not need to instance the chemical plant class, so, in most cases, we will choose the third-static factory method mode.

3. Abstract Factory mode (Factory)

The problem with factory method mode is that class creation relies on the factory class, that is, if you want to expand the program, the factory class must be modified, which violates the closure principle, so from the design point of view, there are certain problems, how to solve? Use the abstract factory pattern to create multiple factory classes so that once you need to add new functionality, you can add new factory classes directly, without having to modify the previous code. Because the abstract factory is not very well understood, we first look at the diagram, and then the code, it is more easily understood.

Take a look at the example:

1. Public interface Sender {
2. public void Send ();
3. }

Two implementation classes:

1. public class MailSender implements Sender {
2. @Override
3. public void Send () {
4. System.out.println ("This is mailsender!");
5. }
6. }

1. public class Smssender implements Sender {
3. @Override
4. public void Send () {
5. System.out.println ("This is SMS sender!");
6. }
7. }

Two factory classes:

1. public class Sendmailfactory implements Provider {
3. @Override
4. Public Sender Produce () {
5. return new MailSender ();
6. }
7. }

1. public class Sendsmsfactory implements provider{
3. @Override
4. Public Sender Produce () {
5. return new Smssender ();
6. }
7. }

In providing an interface:

1. Public interface Provider {
2. Public Sender produce ();
3. }

Test class:

1. public class Test {
3. public static void Main (string[] args) {
4. Provider Provider = new Sendmailfactory ();
5. Sender sender = Provider.produce ();
6. Sender. Send ();
7. }
8. }

In fact, the advantage of this model is that if you want to add a function now: Send timely information, you just need to do an implementation class, to implement the sender interface, at the same time do a factory class, implement Provider interface, OK, no need to change the ready-made code. To do so, expand better!

The content of this article https://www.cnblogs.com/hnrainll/archive/2011/12/29/2305582.html

------Factory Method Pattern for Java 23 design Patterns