工厂模式

定义一个创建对象的抽象类,有子类来决定具体实例化哪个类,使一个类的创建延迟到子类中
创建的对象Product不会变，但是对象的具体实现经常变换，如果发生变化，增加新的FacotoryMethods子类就可以了
满足对开放--封闭原则
C#版本代码:

1. public abstract class Product
   
2.     {
   
3.         public abstract void work();
   
4.     }
   
5.     public class ProductA : Product
   
6.     {
   
7.         public override void work()
   
8.         {
   
9.             Console.Write("ProductA");
   
10.         }
    
11.     }
    
12.     public class ProductB : Product
    
13.     {
    
14.         public override void work()
    
15.         {
    
16.             Console.Write("ProductB");
    
17.         }
    
18.     }
    
19.     public abstract class FactoryMethods
    
20.     {
    
21.         public abstract Product newproduct();
    
22.     }
    
23.     //对不同产品的实例化，由不同的工厂来具体实现,每一个工厂生产具体的商品
    
24.     public class FactoryMethodA : FactoryMethods//具体工厂
    
25.     {
    
26.         public override Product newproduct()
    
27.         {
    
28.             return new ProductA();//实现具体的实例化
    
29.         }
    
30.     }
    
31.     public class FactoryMethodB : FactoryMethods//具体工厂
    
32.     {
    
33.         public override Product newproduct()
    
34.         {
    
35.             return new ProductB();//实现具体的实例化
    
36.         }
    
37.     }
    
38.     public class FactoryMethodClient
    
39.     {
    
40.         public static void GetFactoryMethod()
    
41.         {
    
42.             //产品种类是变化的，如果发生变化，新增一个工厂就可以了,在调用的地方掉用新的方法
    
43.             //体现出对修改封闭，对扩展开放，新增新的功能对原来的没有影响
    
44.             FactoryMethods factorysubA = new FactoryMethodA();
    
45.             FactoryMethods factorysubB = new FactoryMethodB();
    
46.             Product pruductA = factorysubA.newproduct();
    
47.             Product pruductB = factorysubB.newproduct();
    
48.             pruductA.work();
    
49.             pruductB.work();
    
50.         }
    
51.     }