Abstract Factory抽象工厂(创建型模式)

new的问题

常规的对象创建方法：

// 创建一个Road对象
Road road  =   new  Road();

 

new的问题：

实现依赖，不能应对“具体实例化类型”的变化。

解决思路：

封装变化点——哪里变化，封装哪里。

潜台词：如果没有变化，当然不需要额外的封装！

 

工厂模式的缘起

l         变化点在“对象创建”，因此就封装“对象创建”；

l         面向接口编程——依赖接口，而非依赖实现；

l         最简单的解决方法：

class  RoadFactory ... {
  public static Road CreateRoad()
  ...{
    return new Road();
}
}

// 创建一个Road对象
Road road  =  RoadFactory.CreateRoad();

简单工厂的问题：

不能应对“不同系列对象”的变化。

解决方案：

使用面向对象的技术来“封装”变化点。

 

动机：
在软件系统中，经常面临着“一系列相互依赖的对象”的创建工作；同时，由于需求的变化，往往存在更多系列对象的创建工作。

如何应对这种变化？如何绕过常规的对象创建方法(new)，提供一种“封装机制”来避免客户程序和这种“多系列具体对象创建工作”的紧耦合？

意图：

提供一个接口，让该接口负责创建一系列“相关或者相互依赖的对象”，无需指定它们具体的类。

Abstract Factory模式的几个要点

l         如果没有应对“多系列对象构建”的需求变化，则没有必要使用Abstract Factory模式，这时候使用简单的静态工厂完全可以。

l         “系列对象”指的是这些对象之间有相互依赖、或作用的关系。

l         Abstract Factory模式主要在于应对“新系列”的需求变动。其缺点在于难以应对“新对象”的需求变动。

l         Abstract Factory模式经常和Factory Method模式共同组合来应对“对象创建”的需求变化。

 

花园规划工厂实例：

Garden.cs代码示例：

using  System;
using  System.Drawing ;
namespace  Gardener
... {
    /**//// <summary>
    /// Summary description for Garden.
    /// </summary>
    public class Garden ...{
        protected Plant center, shade, border;
        protected bool showCenter, showShade, showBorder;
        //select which ones to display
        public void setCenter() ...{showCenter = true;}
        public void setBorder() ...{showBorder =true;}
        public void setShade() ...{showShade =true;}
        //draw each plant
        public void draw(Graphics g) ...{
            if (showCenter) center.draw (g, 100, 100);
            if (showShade) shade.draw (g, 10, 50);
            if (showBorder) border.draw (g, 50, 150);
        }
    }
}

用设计模式术语来讲，Garden接口就是抽象工厂。它定义了具体类中的方法，并返回一系列相关类中的某个类。

Plant.cs代码示例：

using  System;
using  System.Drawing;

namespace  Gardener
... {
    /**//// <summary>
    /// Summary description for Plant.
    /// </summary>
    public class Plant     ...{
        private string name;
        private Brush br;
        private Font font;

        public Plant(string pname) ...{
            name = pname;     //save name
            font = new Font ("Arial", 12);
            br = new SolidBrush (Color.Black );
        }        
        //-------------
        public void draw(Graphics g, int x, int y) ...{
            g.DrawString (name, font, br, x, y);
        }
    }
}

Plant对象设置植物名字，在draw方法被调用时绘制自己。

 

AnnualGarden.cs代码示例：

using  System;
using  System.Drawing ;

namespace  Gardener
... {
    /**//// <summary>
    /// Summary description for AnnualGarden.
    /// </summary>
    public class AnnualGarden : Garden
    ...{
        public AnnualGarden () ...{
            shade = new Plant("Coleus");
            border = new Plant ("Alyssum");
            center = new Plant ("Marigold");
        }
    }
}

VeggieGarden.cs代码示例：

using  System;

namespace  Gardener
... {
    /**//// <summary>
    /// Summary description for VeggieGarden.
    /// </summary>
    public class VeggieGarden : Garden     ...{
        public VeggieGarden() ...{
            shade = new Plant("Broccoli");
            border = new Plant ("Peas");
            center = new Plant ("Corn");
        }
    }
}

PerennialGarden.cs代码示例：

using  System;

namespace  Gardener
... {
    /**//// <summary>
    /// Summary description for PerennialGarden.
    /// </summary>
    public class PerennialGarden : Garden
    ...{
        public PerennialGarden() ...{
            shade = new Plant("Astilbe");
            border = new Plant ("Dicentrum");
            center = new Plant ("Sedum");
        }
    }
}

GdPic.cs代码示例：

using  System;
using  System.Collections;
using  System.ComponentModel;
using  System.Drawing;
using  System.Data;
using  System.Windows.Forms;

namespace  Gardener
... {
    /**//// <summary>
    /// Summary description for GdPic.
    /// </summary>
    public class GdPic : System.Windows.Forms.PictureBox 
    ...{
        /**//// <summary> 
        /// Required designer variable.
        /// </summary>
        private System.ComponentModel.Container components = null;
        private Brush br;
        private Garden gden;
        private void init () ...{
            br = new SolidBrush (Color.LightGray );
        }
        public GdPic()     ...{
            // This call is required by the Windows.Forms Form Designer.
            InitializeComponent();
            init();
        }
        public void setGarden(Garden garden) ...{
            gden = garden;
        }
        protected override void OnPaint ( PaintEventArgs pe )...{
            Graphics g = pe.Graphics;
            g.FillEllipse (br, 5, 5, 100, 100);
            if(gden != null)
                gden.draw (g);    
        }

        /**//// <summary> 
        /// Clean up any resources being used.
        /// </summary>
        protected override void Dispose( bool disposing )
        ...{
            if( disposing )
            ...{
                if(components != null)
                ...{
                    components.Dispose();
                }
            }
            base.Dispose( disposing );
        }

        Component Designer generated code#region Component Designer generated code
        /**//// <summary> 
        /// Required method for Designer support - do not modify 
        /// the contents of this method with the code editor.
        /// </summary>
        private void InitializeComponent()
        ...{
            // 
            // GdPic
            // 
            
        }
        #endregion

    }
}

图片框

 

处理单选按钮和按钮事件

private   void  opAnnual_CheckedChanged( object  sender, EventArgs e)  ... {
    setGarden( new AnnualGarden ());
}
// -----
private   void  opVegetable_CheckedChanged( object  sender, EventArgs e)  ... {
    setGarden( new VeggieGarden ());
}
// -----
private   void  opPerennial_CheckedChanged( object  sender, EventArgs e)  ... {
    setGarden( new PerennialGarden ());
}         
// -----
private   void  setGarden(Garden gd)  ... {
    garden = gd;            //save current garden
    gdPic1.setGarden ( gd);    //tell picture bos
    gdPic1.Refresh ();        //repaint it
    ckCenter.Checked =false;    //clear all
    ckBorder.Checked = false;    //check
    ckShade.Checked = false;    //boxes
}
private   void  ckCenter_CheckedChanged( object  sender, System.EventArgs e)  ... {
    garden.setCenter ();
    gdPic1.Refresh ();
}
// -----
private   void  ckBorder_CheckedChanged( object  sender, System.EventArgs e)  ... {
    garden.setBorder();
    gdPic1.Refresh ();
}
// -----
private   void  ckShade_CheckedChanged( object  sender, System.EventArgs e)  ... {
    garden.setShade ();
    gdPic1.Refresh ();
}

抽象工厂的一个强大功能是很容易添加新的子类。

 

抽象工厂的效果：

抽象工厂的一个主要目的是它能隔离要生成的具体类。这些类的实际类名隐藏在工厂里，在客户端根本不需要知道。

尽管抽象工厂生成的所有类都具有相同的基类，但还是无法避免某些子类具有额外的、与其他类不同的方法。

解决方案(一)：

在基类中定义所有的方法，即使这些方法没有实际的功能；

解决方案(二)：

再派生出一个新的基类接口，它包含读者需要的所有方法和所有花园类型的子类；