23种设计模式UML类图.docx

23种设计模式UML类图.docx

《23种设计模式UML类图.docx》由会员分享，可在线阅读，更多相关《23种设计模式UML类图.docx（63页珍藏版）》请在冰豆网上搜索。

23种设计模式UML类图

23种设计模式UML类图及对应示例代码

1.DoFactory.GangOfFour.Abstract.Structural

     AbstractFactory：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

   工厂模式：

客户类和工厂类分开。

消费者任何时候需要某种产品，只需向工厂请求即可。

消费者无须修改就可以接纳新产品。

缺点是当产品修改时，工厂类也要做相应的修改。

如：

如何创建及如何向客户端提供。

using System;

namespace DoFactory.GangOfFour.Abstract.Structural

{

    /// 

    class MainApp

    {

        /// 

        public static void Main（）

        {

            // Abstract factory #1

            AbstractFactory factory1 = new ConcreteFactory1（）;

            Client client1 = new Client（factory1）;

            client1.Run（）;

            // Abstract factory #2

            AbstractFactory factory2 = new ConcreteFactory2（）;

            Client client2 = new Client（factory2）;

            client2.Run（）;

            // Wait for user input

            Console.Read（）;

        }

    }

    // "AbstractFactory"

    abstract class AbstractFactory

    {

        public abstract AbstractProductA CreateProductA（）;

        public abstract AbstractProductB CreateProductB（）;

    }

    // "ConcreteFactory1"

    class ConcreteFactory1 :

 AbstractFactory

    {

        public override AbstractProductA CreateProductA（）

        {

            return new ProductA1（）;

        }

        public override AbstractProductB CreateProductB（）

        {

            return new ProductB1（）;

        }

    }

    // "ConcreteFactory2"

    class ConcreteFactory2 :

 AbstractFactory

    {

        public override AbstractProductA CreateProductA（）

        {

            return new ProductA2（）;

        }

        public override AbstractProductB CreateProductB（）

        {

            return new ProductB2（）;

        }

    }

    // "AbstractProductA"

    abstract class AbstractProductA

    {

    }

    // "AbstractProductB"

    abstract class AbstractProductB

    {

        public abstract void Interact（AbstractProductA a）;

    }

    // "ProductA1"

    class ProductA1 :

 AbstractProductA

    {

    }

    // "ProductB1"

    class ProductB1 :

 AbstractProductB

    {

        public override void Interact（AbstractProductA a）

        {

            Console.WriteLine（this.GetType（）.Name + 

                " interacts with " + a.GetType（）.Name）;

        }

    }

    // "ProductA2"

    class ProductA2 :

 AbstractProductA

    {

    }

    // "ProductB2"

    class ProductB2 :

 AbstractProductB

    {

        public override void Interact（AbstractProductA a）

        {

            Console.WriteLine（this.GetType（）.Name + 

                " interacts with " + a.GetType（）.Name）;

        }

    }

    // "Client" - the interaction environment of the products

    class Client

    {

        private AbstractProductA AbstractProductA;

        private AbstractProductB AbstractProductB;

        // Constructor

        public Client（AbstractFactory factory）

        {

            AbstractProductB = factory.CreateProductB（）;

            AbstractProductA = factory.CreateProductA（）;

        }

        public void Run（）

        {

            AbstractProductB.Interact（AbstractProductA）;

        }

    }

}

2.DoFactory.GangOfFour.Adapter.Structural

      Adapter：

将一个类的接口转换成客户希望的另一个接口，使得原来由于接口不兼容而不能一起工作的那些类可以一起工作。

       适配器（变压器）模式：

把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口原因不匹配而无法一起工作的两个类能够一起工作。

适配类可以根据参数返还一个合适的实例给客户端。

using System;

namespace DoFactory.GangOfFour.Adapter.Structural

{

    /// 

    class MainApp

    {

        /// 

        static void Main（）

        {

            // Create adapter and place a request

            Target target = new Adapter（）;

            target.Request（）;

            // Wait for user

            Console.Read（）;

        }

    }

    // "Target" 

    class Target

    {

        public virtual void Request（）

        {

            Console.WriteLine（"Called Target Request（）"）;

        }

    }

    // "Adapter" 

    class Adapter :

 Target

    {

        private Adaptee adaptee = new Adaptee（）;

        public override void Request（）

        {

            // Possibly do some other work

            //   and then call SpecificRequest

            adaptee.SpecificRequest（）;

        }

    }

    // "Adaptee"

    class Adaptee

    {

        public void SpecificRequest（）

        {

            Console.WriteLine（"Called SpecificRequest（）"）;

        }

    }

}

3.DoFactory.GangOfFour.Bridge.Structural

     Bridge：

将抽象部分与它的实现部分分离，使之可以独立变化。

      桥梁模式：

将抽象化与实现化脱耦，使得二者可以独立的变化，也就是说将他们之间的强关联变成弱关联，也就是指在一个软件系统的抽象化和实现化之间使用组合/聚合关系而不是继承关系，从而使两者可以独立的变化。

using System;

namespace DoFactory.GangOfFour.Bridge.Structural

{

    /// 

    class MainApp

    {

        /// 

        static void Main（）

        {

            Abstraction ab = new RefinedAbstraction（）;

            // Set implementation and call

            ab.Implementor = new ConcreteImplementorA（）;

            ab.Operation（）;

            // Change implemention and call

            ab.Implementor = new ConcreteImplementorB（）;

            ab.Operation（）;

            // Wait for user

            Console.Read（）;

        }

    }

    // "Abstraction"

    class Abstraction

    {

        protected Implementor implementor;

        // Property

        public Implementor Implementor

        {

            set{ implementor = value; }

        }

        public virtual void Operation（）

        {

            implementor.Operation（）;

        }

    }

    // "Implementor" 

    abstract class Implementor

    {

        public abstract void Operation（）;

    }

    // "RefinedAbstraction"

    class RefinedAbstraction :

 Abstraction

    {

        public override void Operation（）

        {

            implementor.Operation（）;

        }

    }

    // "ConcreteImplementorA"

    class ConcreteImplementorA :

 Implementor

    {

        public override void Operation（）

        {

            Console.WriteLine（"ConcreteImplementorA Operation"）;

        }

    }

    // "ConcreteImplementorB"

    class ConcreteImplementorB :

 Implementor

    {

        public override void Operation（）

        {

            Console.WriteLine（"ConcreteImplementorB Operation"）;

        }

    }

}

4.DoFactory.GangOfFour.Builder.Structural

　　Builder:

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

　　建造者模式：

将产品的内部表象和产品的生成过程分割开来，从而使一个建造过程生成具有不同的内部表象的产品对象。

建造模式使得产品内部表象可以独立的变化，客户不必知道产品内部组成的细节。

建造模式可以强制实行一种分步骤进行的建造过程。

using System;

using System.Collections;

namespace DoFactory.GangOfFour.Builder.Structural

{

    /// 

    public class MainApp

    {

        /// 

        public static void Main（）

        { 

            // Create director and builders

            Director director = new Director（）;

            Builder b1 = new ConcreteBuilder1（）;

            Builder b2 = new ConcreteBuilder2（）;

            // Construct two products

            director.Construct（b1）;

            Product p1 = b1.GetResult（）;

            p1.Show（）;

            director.Construct（b2）;

            Product p2 = b2.GetResult（）;

            p2.Show（）;

            // Wait for user

            Console.Read（）;

        }

    }

    // "Director" 

    class Director

    {

        // Builder uses a complex series of steps

        public void Construct（Builder builder）

        {

            builder.BuildPartA（）;

            builder.BuildPartB（）;

        }

    }

    // "Builder" 

    abstract class Builder

    {

        public abstract void BuildPartA（）;

        public abstract void BuildPartB（）;

        public abstract Product GetResult（）;

    }

    // "ConcreteBuilder1" 

    class ConcreteBuilder1 :

 Builder

    {

        private Product product = new Product（）;

        public override void BuildPartA（）

        {

            product.Add（"PartA"）;

        }

        public override void BuildPartB（）

        {

            product.Add（"PartB"）;

        }

        public override Product GetResult（）

        {

            return product;

        }

    }

    // "ConcreteBuilder2" 

    class ConcreteBuilder2 :

 Builder

    {

        private Product product = new Product（）;

        public override void BuildPartA（）

        {

            product.Add（"PartX"）;

        }

        public override void BuildPartB（）

        {

            product.Add（"PartY"）;

        }

        public override Product GetResult（）

        {

            return product;

        }

    }

    // "Product" 

    class Product

    {

        ArrayList parts = new ArrayList（）;

        public void Add（string part）

        {

            parts.Add（part）;

        }

        public void Show（）

        {

            Console.WriteLine（"\nProduct Parts -------"）;

            foreach （string part in parts）

                Console.WriteLine（part）;

        }

    }

}

5.DoFactory.GangOfFour.Chain.Structural

　　ChainofResponsibility：

为解除请求的发送者和接收者之间的耦合，而使多个对象有机会处

理这个请求。

将这些请求连成一个链，并沿着这条链传递该请求，直到有个对象处理它。

      责任链模式：

在责任链模式中，很多对象由每一个对象对其下家的引用而接起来形成一条链。

请求在这个链上传递，直到链上的某一个对象决定处理此请求。

客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。

处理者有两个选择：

承担责任或者把责任推给下家。

一个请求可以最终不被