Design Model (1)-factory Model

Simple factory Mode

1. Purpose
The factory mode is specifically responsible for instantiating a large number of classes with common interfaces, and you do not have to know which class to instantiate each time. It defines an interface used to create objects, and the subclass determines which class to instantiate.
2. Structure of the simple factory Model

3. A simple example of Java code

1. // Product Interface
2. Public interface product {
4. Public void getname ();
6. }
8. // Product
9. Public class producta implements product {
11. Public void getname (){
12. System. Out. println ("I am producta ");
13. }
15. }
17. // Product B
18. Public class productb implements product {
20. Public void getname (){
21. System. Out. println ("I am productb ");
22. }
24. }
26. // Factory type
27. Public class productcreator {
29. Public Product createproduct (string type ){
30. If ("A". Equals (type )){
31. Return new producta ();
32. }
33. If ("B". Equals (type )){
34. Return new productb ();
35. } Else
36. Return NULL;
37. }
39. Public static void main (string [] ARGs ){
40. Productcreator creator = new productcreator ();
41. Creator. createproduct ("A"). getname ();
42. Creator. createproduct ("B"). getname ();
43. }
44. }

4. Summary applicability of the factory Model
? You cannot predict the type of instance to be created during encoding.
? A class uses its subclass to create objects.
? Developers do not want to create an instance of any class or expose the information about how to create an instance to external programs.

 

Abstract Factory Model

1. abstract factory models can be said to be extensions of simple factory models. The main difference between them is the complexity of object creation.
In the abstract factory model, abstract products may be one or more to form one or more product families. In the case of only one product family, the abstract factory mode actually degrades to the factory method mode.
2. Abstract The structure of the factory Model

 

3. A simple example

Java code

1. // Product plant interface
2. Public interface plant {
3. }
5. // Specific products: planta and plantb
6. Public class planta implements plant {
8. Public planta (){
9. System. Out. println ("create planta! ");
10. }
12. Public void dosomething (){
13. System. Out. println ("planta do something ");
14. }
15. }
17. Public class plantb implements plant {
18. Public plantb (){
19. System. Out. println ("create plantb! ");
20. }
22. Public void dosomething (){
23. System. Out. println ("plantb do something ");
24. }
25. }
27. // Product fruit Interface
28. Public interface fruit {
29. }
31. // Specific products: Fruita and fruitb
32. Public class Fruita implements fruit {
33. Public Fruita (){
34. System. Out. println ("create Fruita! ");
35. }
37. Public void dosomething (){
38. System. Out. println ("Fruita do something ");
39. }
40. }
42. Public class fruitb implements fruit {
43. Public fruitb (){
44. System. Out. println ("create fruitb! ");
45. }
47. Public void dosomething (){
48. System. Out. println ("fruitb do something ");
49. }
50. }
52. // Abstract Factory method
53. Public interface abstractfactory {
54. Public plant createplant ();
56. Public fruit createfruit ();
57. }
59. // Specific factory Method
60. Public class factorya implements actfactory {
61. Public plant createplant (){
62. Return new planta ();
63. }
65. Public fruit createfruit (){
66. Return new Fruita ();
67. }
68. }
70. Public class factoryb implements actfactory {
71. Public plant createplant (){
72. Return new plantb ();
73. }
75. Public fruit createfruit (){
76. Return new fruitb ();
77. }
78. }

4. Summary
The abstract factory mode should be considered in the following cases.
First, a system should not depend on the details of product instances being created, formed, and expressed. This is important for all forms of factory models.
Second, there are more than one product family in this system.
Third, products belonging to the same product family are designed to be used together. This constraint must be reflected in the system design.
Finally, different products appear with a series of interfaces, so that the system does not depend on the Interface implementation details.
Among them, the second and third conditions are the key conditions for choosing the abstract factory model rather than other factory models.

Design Model (1)-factory Model