简单工厂、工厂、抽象工厂

***工厂方法模式的组成部分：

  1. Creator     工厂
  2. Product     抽象产品
  3. ConcreteProduct     具体产品

简单工厂方法模式

组成部分：

  • Creator:是简单工厂方法模式的核心，包含应用程序所需要的业务逻辑，当客户类Client

需要的时候，委托工厂类创建产品类的对象。

  • Product:可以是Java接口或者java抽象类，是具体子类的超类或者共同接口。
  • ConcreteProduct:实现Product接口，或者继承抽象类Product。

代码如下：

 1 package com.china.shanghai.wanson;
 2 
 3 public abstract class Product {
 4     public  abstract  void show();
 5 }
 6 
 7 
 8 package com.china.shanghai.wanson;
 9 
10 public class ConcreteProduct1 extends  Product {
11     public void show() {
12         System.out.println("产品一");
13 
14     }
15 }
16 
17 
18 
19 package com.china.shanghai.wanson;
20 
21 public class ConcreteProduct2 extends Product {
22     public void show() {
23         System.out.println("产品二");
24     }
25 }
26 
27 
28 
29 package com.china.shanghai.wanson;
30 
31 public class SimpleFactory {
32     public  SimpleFactory(){
33 
34     }
35     public  static  ConcreteProduct1 CreateProduct1(){
36         return  new ConcreteProduct1();
37     }
38     public  static ConcreteProduct2 CreateProduct2(){
39         return  new ConcreteProduct2();
40     }
41     public  static  Product createProduct(String type){
42         if("product1".equals(type)){
43             return  new ConcreteProduct1();
44         }else if("product2".equals(type)){
45             return  new ConcreteProduct2();
46         }else{
47             return null;
48         }
49     }
50 }
51 
52 
53 package com.china.shanghai.wanson;
54 
55 public class Driver {
56     public  static  void main(String[] args){
57         ConcreteProduct1 concreteProduct1=new ConcreteProduct1();
58         concreteProduct1.show();
59         ConcreteProduct2 concreteProduct2=new ConcreteProduct2();
60         concreteProduct2.show();
61         System.out.println("**************************\n");
62         /*方法2
63                 工厂有了后，通过工厂创建
64          */
65         ConcreteProduct1 concreteProduct11=
66                 SimpleFactory.CreateProduct1();
67         concreteProduct11.show();
68         ConcreteProduct2 concreteProduct21=SimpleFactory.CreateProduct2();
69         concreteProduct21.show();
70 
71         /*方法3
72            改进工厂后
73          */
74         Product product=SimpleFactory.createProduct("product1");
75         product.show();
76         product=SimpleFactory.createProduct("product2");
77         product.show();
78 
79         product=SimpleFactory.createProduct("procuct3");
80         if(product!=null){
81             product.show();
82         }else{
83             System.out.println("对不起，我们不生产这个东西");
84         }
85 
86     }
87 }

 



工厂方法模式


简单工厂和工厂方法模式的区别


    

  • 两个模式的中心点不同。工厂方法模式的中心点是抽象工厂类或者接口，而简单工厂方法模式的中心是一个实的工厂类。
    • 

  • 简单工厂不支持开闭原则，工厂方法模式支持开闭原则。在简单工厂模式中，如果要增加一个新产品类，相应的在工厂类中也要增加一个条件语句，用于创建对象。
    • 

  • 在简单工厂模式中，必要的创建对象的逻辑判断包含在工厂类中；在工厂方法模式中，工厂类不必要包含创建对象的逻辑语句。
    • 



代码如下




 1 package com.china.wanson;
 2 
 3 public interface Factory {
 4     public  abstract  Product createProudct();
 5 }
 6 
 7 
 8 package com.china.wanson;
 9 
10 public class ConcreteFactory1 implements  Factory {
11     public Product createProudct() {
12         return  new ConcreteProduct1();
13     }
14 }
15 
16 
17 package com.china.wanson;
18 
19 public class ConcreteFactory2 implements Factory {
20     public Product createProudct() {
21         return  new ConcreteProduct2();
22     }
23 }
24 
25 
26 package com.china.wanson;
27 
28 public abstract class Product {
29     public abstract void show();
30 }
31 
32 
33 package com.china.wanson;
34 
35 public class ConcreteProduct1 extends  Product{
36     public void show() {
37         System.out.println("product1");
38     }
39 }
40 
41 
42 package com.china.wanson;
43 
44 public class ConcreteProduct2 extends Product {
45     public void show() {
46         System.out.println("product2");
47     }
48 }
49 
50 
51 
52 
53 package com.china.wanson;
54 
55 public class Diver {
56     public static void main(String[] args) {
57         Factory factory=new ConcreteFactory1();
58         Product product=factory.createProudct();
59         product.show();
60 
61         factory =new ConcreteFactory2();
62         product=factory.createProudct();
63         product.show();
64     }
65 
66 }




 


抽象工厂方法模式


 工厂方法模式的不足：
通过引入工厂等级结构解决了简单工厂中工厂类职责太重的问题，但是由于工厂方法模式中的每一个具体工厂只有一个或者一组重载的工厂方法，只能产生一种产品，可能会导致系统中存在大量的工厂类势必会增大开销。

产品族：
在抽象工厂模式中，产品族是指同一个工厂生成的位于不同的产品等级结构中的一组产品。例如：海尔电器厂生产海尔电视、冰箱、空调。他们都属于一个产品族中。位于不同的等级结构。

产品等级结构：
产品等级结构即产品的继承结构。


抽象工厂模式概述:
当系统提供的工厂产生的具体产品不是简单的对象，而是多个位于不同等级结构，属于不同类型的产品时就可以使用抽象工厂模式。

抽象工厂和工厂的最大区别：
工厂方法模式针对的是一个等级结构，而抽象工厂模式需要面对多个产品等级结构，一个工厂等级结构可以负责多个不同等级结构中的产品对象的创建。
当一个工厂等级结构可以创建出不同的产品等级结构中的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更简单，更有效率。






  1 package com.factory;
  2 
  3 import com.product.AbstractProductMan;
  4 import com.product.AbstractProductWoman;
  5 
  6 public interface AbstractFactory {
  7     public AbstractProductWoman createWoman();
  8     public AbstractProductMan createMan();
  9 }
 10 
 11 
 12 
 13 package com.factory;
 14 
 15 import com.product.AbstractProductMan;
 16 import com.product.AbstractProductWoman;
 17 import com.product.ConcreteProductNorthMan;
 18 import com.product.ConcreteProductNorthWoman;
 19 
 20 public  class ConcreteNorthFactory implements AbstractFactory {
 21     public AbstractProductWoman createWoman() {
 22         return new ConcreteProductNorthWoman();
 23     }
 24 
 25     public AbstractProductMan createMan() {
 26         return new ConcreteProductNorthMan();
 27     }
 28 
 29 
 30 }
 31 
 32 
 33 package com.factory;
 34 
 35 import com.product.AbstractProductMan;
 36 import com.product.AbstractProductWoman;
 37 import com.product.ConcreteProductSouthMan;
 38 import com.product.ConcreteProductSouthWoman;
 39 
 40 public class ConcreteSouthFactory implements AbstractFactory {
 41     public AbstractProductWoman createWoman() {
 42         return  new ConcreteProductSouthWoman();
 43     }
 44 
 45     public AbstractProductMan createMan() {
 46         return  new ConcreteProductSouthMan();
 47     }
 48 }
 49 
 50 
 51 
 52 
 53 
 54 package com.product;
 55 
 56 public interface AbstractProductMan {
 57     public  void manufactureMan();
 58 }
 59 
 60 
 61 
 62 
 63 package com.product;
 64 
 65 public interface AbstractProductWoman {
 66     public void manufactureWoman();
 67 }
 68 
 69 package com.product;
 70 
 71 import com.factory.AbstractFactory;
 72 
 73 public class ConcreteProductNorthMan implements AbstractProductMan {
 74     public void manufactureMan() {
 75         System.out.println("北方男人");
 76     }
 77 }
 78 
 79 package com.product;
 80 
 81 public class ConcreteProductNorthWoman implements AbstractProductWoman {
 82     public void manufactureWoman() {
 83         System.out.println("北方女人");
 84     }
 85 }
 86 
 87 package com.product;
 88 
 89 public class ConcreteProductSouthMan implements  AbstractProductMan {
 90     public void manufactureMan() {
 91         System.out.println("南方男人");
 92     }
 93 }
 94 
 95 
 96 package com.product;
 97 
 98 public class ConcreteProductSouthWoman implements AbstractProductWoman {
 99     public void manufactureWoman() {
100         System.out.println("南方女人");
101     }
102 }






 


 








 


package com.Driver;

import com.factory.AbstractFactory;
import com.factory.ConcreteNorthFactory;
import com.factory.ConcreteSouthFactory;
import com.product.*;

import javax.swing.*;

public class driver {

    public static void main(String[] args) {


        AbstractFactory abstractFactory=new ConcreteNorthFactory();
        AbstractProductWoman abstractProductWoman=abstractFactory.createWoman();
        AbstractProductMan abstractProductMan=abstractFactory.createMan();

        abstractProductWoman.manufactureWoman();
        abstractProductMan.manufactureMan();


        AbstractFactory  abstractFactory1=new ConcreteSouthFactory();
        AbstractProductWoman abstractProductWoman1=abstractFactory1.createWoman();
        AbstractProductMan abstractProductMan1=abstractFactory1.createMan();

        abstractProductWoman1.manufactureWoman();
        abstractProductMan1.manufactureMan();
    }



}


















            

            
posted @ 
2018-12-13 17:08 
wq9 
阅读(162) 
评论(0) 
 
收藏 
举报