CSDN博客

img yuucyf

创建型模式总结

发表于2008/10/2 23:51:00  462人阅读

 

概述

创建型模式,就是用来创建对象的模式,抽象了实例化的过程。它帮助一个系统独立于如何创建、组合和表示它的那些对象。本文对五种常用创建型模式进行了比较,通过一个游戏开发场景的例子来说该如何使用创建型模式。

 

为什么需要创建型模式

所有的创建型模式都有两个永恒的主旋律:

<!--[if !supportLists]-->第一,   <!--[endif]-->它们都将系统使用哪些具体类的信息封装起来。

<!--[if !supportLists]-->第二,   <!--[endif]-->它们隐藏了这些类的实例是如何被创建和组织的。

外界对于这些对象只知道它们共同的接口,而不清楚其具体的实现细节。正因如此,创建型模式在创建什么(what),由谁(who)来创建,以及何时(when)创建这些方面,都为软件设计者提供了尽可能大的灵活性。

假定在一个游戏开发场景中,会用到一个现代风格房屋的对象,按照我们的一般想法,既然需要对象就创建一个:

ModernRoom room = new ModernRoom();

好了,现在现代风格房屋的对象已经有了,如果这时房屋的风格变化了,需要的是古典风格的房屋,修改一下:

ClassicalRoom room = new ClassicalRoom();

试想一下,在我们的程序中有多少处地方用到了这样的创建逻辑,而这里仅仅是房屋的风格变化了,就需要修改程序中所有的这样的语句。现在我们封装对象创建的逻辑,把对象的创建放在一个工厂方法中:

ModernFactory factory = new ModernFactory();

ModernRoom room = factory.Create();

当房屋的风格变化时,只需要修改

ClassicalFactory factory = new ClasscalFactory();

ClassicalRoom room = factory.Create();

而其它的用到room的地方仍然不变。这就是为什么需要创建型模式了。创建者模式作用可以概括为如下两点:

<!--[if !supportLists]-->1.       <!--[endif]-->封装创建逻辑,绝不仅仅是new一个对象那么简单。

<!--[if !supportLists]-->2.       <!--[endif]-->封装创建逻辑变化,客户代码尽量不修改,或尽量少修改。

 

常见的五种创建型模式

单件模式(Singleton Pattern):解决的是实体对象的个数问题,其他的都是解决new所带来的耦合关系问题。

工厂方法模式(Factory Method Pattern):在工厂方法中,工厂类成为了抽象类,其实际的创建工作将由其具体子类来完成。工厂方法的用意是定义一个创建产品对象的工厂接口,将实际创建工作推迟到子类中去,强调的是“单个对象”的变化。

抽象工厂模式(Abstract Factory Pattern):抽象工厂是所有工厂模式中最为抽象和最具有一般性的一种形态。抽象工厂可以向客户提供一个接口,使得客户可以在不必指定产品的具体类的情况下,创建多个产品族中的产品对象,强调的是“系列对象”的变化。

生成器模式(Builder Pattern):把构造对象实例的逻辑移到了类的外部,在这个类的外部定义了这个类的构造逻辑。他把一个复杂对象的构造过程从对象的表示中分离出来。其直接效果是将一个复杂的对象简化为一个比较简单的目标对象。他强调的是产品的构造过程。

原型模式(Prototype Pattern):和工厂模式一样,同样对客户隐藏了对象创建工作,但是,与通过对一个类进行实例化来构造新对象不同的是,原型模式是通过拷贝一个现有对象生成新对象的。

 

如何选择使用创建型模式

继续考虑上面提到的游戏开发场景,假定在这个游戏场景中我们使用到的有墙(Wall),屋子(Room),门(Door)几个部件。在这个过程中,同样是对象的创建问题,但是会根据所要解决的问题不同而使用不同的创建型模式。

如果在游戏中,一个屋子至允许有一个门存在,那么这就是一个使用Signleton模式的例子,确保只有一个Door类的实例被创建。解决的是对象创建个数的问题。


示例代码:

using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:SigletonDoor类
    
/// 编写:Kalen_Chen
    
/// 日期:2007年5月12日
    
/// </summary>

    public sealed class SigletonDoor
    
{

        
static readonly SigletonDoor instance = new SigletonDoor();

        
static SigletonDoor()
        

        }


        
public static SigletonDoor Instance
        
{
            
get
            
{
                
return instance;
            }

        }


    }


}


在游戏中需要创建墙、屋子的实例时,为了避免直接对构造器的调用而实例化类,这时就是工厂方法模式了,每一个部件都有它自己的工厂类。解决的是“单个对象”的需求变化问题。


示例代码:

using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:Wall类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public abstract class Wall
    
{
        
public abstract void Display();
    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ModernWall
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ModernWall:Wall
    
{
        
public override void Display()
        
{
            Console.WriteLine(
"ModernWall Builded");
        }

    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:WallFactory
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class WallFactory
    
{
        
public abstract Wall Create();
    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ModernFactory
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ModernFactory:WallFactory
    
{
        
public override Wall Create()
        
{
            
return new ModernWall();
        }

    }

}


在游戏场景中,不可能只有一种墙或屋子,有可能有现代风格(Modern),古典风格(Classical)等多系列风格的部件。这时就是一系列对象的创建问题了,是一个抽象工厂的例子。解决的是“系列对象”的需求变化问题。



示例代码:

using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:Wall类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public abstract class Wall
    
{
        
public abstract void Display();
    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ModernWall
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ModernWall:Wall
    
{
        
public override void Display()
        
{
            Console.WriteLine(
"ModernWall Builded");
        }

    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ClasscalWall类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ClasscalWall:Wall
    
{
        
public override void Display()
        
{
            Console.WriteLine(
"ClassicalWall Builded");
        }

    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:Room类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public abstract class Room
    
{
        
public abstract void Display();
    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ModernRoom类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ModernRoom:Room
    
{
        
public override void Display()
        
{
            Console.WriteLine(
"ModernRoom Builded");
        }

    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ClassicalRoom类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ClassicalRoom:Room
    
{
        
public override void Display()
        
{
            Console.WriteLine(
"ClassicalRoom Builded");
        }

    }

}



using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:AbstractFactory
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public abstract class AbstractFactory
    
{
        
public abstract Wall CreateWall();
        
public abstract Room CreateRoom();
    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ModernFactory
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ModernFactory:AbstractFactory
    
{
        
public override Wall CreateWall()
        
{
            
return new ModernWall();
        }


        
public override Room CreateRoom()
        
{
            
return new ModernRoom();
        }

    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ClassicalFactory类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ClassicalFactory:AbstractFactory
    
{
        
public override Wall CreateWall()
        
{
            
return new ClasscalWall();
        }


        
public override Room CreateRoom()
        
{
            
return new ClassicalRoom();
        }

    }

}


如果在游戏场景中,构成某一个场景的算法比较稳定,例如:这个场景就是用四堵墙,一个屋子,一扇门来构成的,但具体是用什么风格的墙、屋子和门则是不停的变化的,这就是一个生成器模式的例子。解决的是“对象部分”的需求变化问题。
 

示例代码:

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:GameScene类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class GameScene
    
{
        ArrayList parts 
= new ArrayList();

        
public void Add(string part)
        
{
            parts.Add(part);
        }


        
public void Display()
        
{
            Console.WriteLine(
"GameScene Parts:");
            
foreach (string part in parts)
            
{
                Console.WriteLine(part);
            }

        }


    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:Builder类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public abstract class Builder
    
{
        
public abstract void BuildWall();
        
public abstract void BuildRoom();
        
public abstract void BuildDoor();
        
public abstract GameScene GetResult();
    }

}


using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:Director类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class Director
    
{
        
public void Construct(Builder builder)
        
{
            builder.BuildWall();
            builder.BuildRoom();
            builder.BuildDoor();
        }

    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:GameBuilder类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class GameBuilder:Builder
    
{
        
private GameScene g;

        
public override void BuildWall()
        
{
            g.Add(
"Wall");
        }


        
public override void BuildRoom()
        
{
            g.Add(
"Room");
        }


        
public override void BuildDoor()
        
{
            g.Add(
"Door");
        }


        
public override GameScene GetResult()
        
{
            
return g;
        }


    }

}


如果在游戏中,需要大量的古典风格或现代风格的墙或屋子,这时可以通过拷贝一个已有的原型对象来生成新对象,就是一个原型模式的例子了。通过克隆来解决“易变对象”的创建问题。


示例代码:

using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:RoomPrototype
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public abstract class RoomPrototype
    
{
        
public abstract RoomPrototype Clone();
    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ModernPrototype类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ModernPrototype:RoomPrototype
    
{
        
public override RoomPrototype Clone()
        
{
            
return (RoomPrototype)this.MemberwiseClone();
        }

    }

}


using System;
using System.Collections.Generic;
using System.Text;

namespace CreationalPattern
{
    
/// <summary>
    
/// 功能:ClassicalPrototype类
    
/// 编写:Kalen_Chen
    
/// 日期:年月日
    
/// </summary>

    public class ClassicalPrototype:RoomPrototype
    
{
        
public override RoomPrototype Clone()
        
{
            
return (RoomPrototype)this.MemberwiseClone();
        }

    }

}


究竟选用哪一种模式取决于很多的因素。使用Abstract FactoryPrototype PatternBuilder Pattern的设计比使用Factory Method Pattern的设计更灵活,但是也更加复杂,尤其Abstract Factory不要庞大的工厂类来支持。通常,设计以使用Factory Method开始,并且当设计者发现需要更大的灵活性时,设计便会向其他设计模式演化,当你在多个设计模式之间进行权衡的时候,了解多个设计模式可以给你提供更多的选择余地。

总结

使用创建者模式是为了提高系统的可维护性和可扩展性,提高应对需求变化的能力!

阅读全文
0 0

相关文章推荐

img
取 消
img