黄污视频在线观看,四虎影院在线域名免费观看,91成人精品网站

骑警

AAAAA — Fri, 20 Jul 2007 09:28:00 GMT

AAAAA 2007-07-20 17:28 发表评论

AAAAA — Tue, 10 Jul 2007 02:36:00 GMT

    常听说这么一句话(大意是这�?�Q�不必可以去套用设计模式�Q�如果按照面向对象的基本原则�~�程�Q�自然是优雅的设计，即��没有��L��使用模式�Q�设计也会近乎于模式。开始感觉有一点玄�Q�但在看了�?/span>C#设计模式�U�|��谈》视频后�Q�觉得有所收获。下面，��参�?/span>视频的内容，��试着写这么一个过�E�：�Ҏ(gu��)��面向对象的一般原则对设计�q�行重构�Q�逐渐演化��察者模式�?/span>
涉及的面向对象设计原则：单一职责原则、封装变化、面向接口编�E�、依赖倒置原则、开闭原则�?/span>

1.发布订阅模型�Q?



假如有需求如�?

银行需要把帐户的如汇款、�{账或取款�{�操作通知用户�Q�途径包括手机短信�?email�{�。如图所式�?br>
自然圎ͼ�我们可以�q�样做：

public class ATM
{
     BankAccount bankAccount;

     public void process()
     {
          //bankAccount...
         this.sendEmail(userEmail);
         this.sendPhone(phoneNumber);
     }

     private void sendEmail(String userEmail)
     {
         //
     }

    private void sendMobile(String phoneNumber)
     {
         //
     }
}

ATM机的 process()�Ҏ(gu��)��在处理完业务逻辑后，由email和phone通知用户�?br>
2.初步重构

好像有bad smells�Q�恩�Q�根�?span style="COLOR: #049a0e">单一职责原则。新增Email�c�d��Phone�c�，�q�把相关业务逻辑改到BankAccount�c�d��成。于是我们的代码可以�q�样�Q?br>

public class ATM
{
    BankAccount bankAccount;


    public void process()
    {
          //
          bankAccount.withDraw();
    }

}

public class BankAccount
{
    Email email;
    Mobile mobile;

    public void withDraw()
    {
         //
         email.sendEmail(userEmail);
         mobile.sendMobile(phoneNumber);
    }
}

public class Email
{
    public void sendEmail(String userEmail)
    {
    }
}

public class Mobile
{
    public void sendMobile(String phoneNumber)
    {
    }
}

下面是代码的UML图：

3.拥抱变化

�q�个解决�Ҏ(gu��)��有问题吗?可能没有问题。它实现了我们的需求：在帐��h��操作变动的时候，通知Email和Mobile��d��送信息给用户。但�q�样设计��p��够了吗？可能��_��了，可能�q�不够�?br>考虑如下两种情况�Q?br>1.在很长一�D�|��间里�Q�订阅方式很�E�_��Q�比如系�l�只通过邮�g和手机短信进行信息订阅，那么�q�个实现没有太大问题�Q?br>2.在近一两年或更短的旉��Q�更多的订阅方式��会源源不断地被加进来：比如可以��d��官方�|�站�{�等�Q�那�q�个实现��有问题�Q�再看一下我们的UML图，�c�BankAccount依赖于Email和Mobile�c�！��是��_��如果需要添加新的订阅方式ATM�cȝ��process()�Ҏ(gu��)��势必要重新设计！

于是我们的BankAccount�c�M��得不变成�Q?br>

public class  BankAccount
{
    Email email;
    Mobile mobile;
    Web web;

    public void withDraw()
    {
          //
         email.sendEmail(userEmail);
         mobile.sendMobile(phoneNumber);
         web.sendWeb(webSite);
    }

}

如果�q�有另一�U�方式，那么process()�Ҏ(gu��)��又会需要加入：otherSubscribe.send...();�{�方法，另外如果订阅�cȝ��接口(�q�里指sendEmail�{�方�?发生变化�Q�BankAccount的withDraw()�Ҏ(gu��)��也必��L��相应的变化！�q�当然是�U�灾难。我们必��L��变这�U�情��c�?br>先解决遗留问题：�W�一�U�情况：订阅方式相对�E�_��的情况下呢？不改动会产生��N��吗？
个�h认�ؓ�Q�不会。比如某个系�l�信息只通过手机短信订阅�Q�那��没有必要太在意�q�个问题。考虑周全一点不好吗�Q�如果将来有�c�M��需求呢�Q�小�?span style="COLOR: red">�q�度设计�Q��ؓ了将来可能出现需求而进行的预先设计�q�不太好。有需求，才有设计�?br>
现在来看解决之道�Q?br>
�q�用面向对象的思想�Q�抽象出问题所在。BankAccount�c�M��赖于 Email�c�d��Mobile�c�，而Email和Mobile是具体的�c�，ATM依赖于具体的�c?/span>了，而且�q�不止一个！回忆一�?span style="COLOR: #2000ff">依赖倒置原则�Q�具体应该依赖于抽象�Q�底层模式应该依赖于高层模式�?/span>那怎么实现依赖倒置原则�?面向对象�~�程中有一条�ȝ��原则�Q?span style="COLOR: #049a0e">��装变化。如何实�?span style="COLOR: #049a0e">��装变化�Q�需要我们这��P��面向接口�~�程�?/span>

回顾一下：我们在设计中实现�c�M��赖了具体的类�Q�违反了依赖倒置原则。�ؓ了遵循依赖倒置原则�Q�我们采用面向接口编�E�的�Ҏ(gu��)��Q�从而实��C��面向对象的一条�ȝ��原则�Q�封装变化�?/span>

看代码：

public interface AccountObserver
{
    public void upDate(UserAccount userAccount);
}

public class Email implements AccountObserver
{
    public void upDate(UserAccount userAccount)
    {
    }
}

public class Mobile
{
    public void upDate(UserAccount userAccount)
    {
    }
}

public class BankAccount
{
    List <AccountObserver> observer = new ArrayList<AccountObserver>;

    public void withDraw()
    {
         //
         for (AccountObserver ao : observer)
         {
            ao.upDate(userAccount)
          }
    }

    public void addOberver(AccountObserver accountObserver)
    {
          observer.add(accountObserver);
     }
}

UML图：

现在�Q�BankAccount依赖于interface AccountObserver。Email和Mobile实现AccountObserver接口�?span style="COLOR: #049a0e">通过遵��@面向接口�~�程遵��@�?span style="COLOR: #049a0e">依赖倒置原则�?/span>

4.开闭原�?/span>

�l�于修改好了�Q�我们解决了订阅者变化的问题。但如果发布者也們֐�于变化呢�Q�这��q��涉到面向对象里的另一个原则：开闭原�?/span>�?span style="COLOR: #049a0e">卻I��Ҏ(gu��)��展开放，对修改关闭�?/span>具体怎么做呢�Q�通过抽象�c�，从抽象类�l�承具体�c�R�?br>看最�l�的代码(只写几个关键的方法，全貌可看最后的UML�?�Q?br>
订阅�Q?

发布�Q?br>

public abstract class Subject
{
     List <AccountObserver> observer = new ArrayList<AccountObserver>;

    protected void withDraw()
    {
         //
         notify();

    }

    protected void notify(UserAccount userAccount)
    {
         for (AccountObserver ao : observer)
         {
            ao.upDate(userAccount)
          }
     }

    protected void addOberver(AccountObserver accountObserver)
    {
          observer.add(accountObserver);
     }

      protected void deleteOberver(AccountObserver accountObserver)
    {
          observer.remove(accountObserver);
     }

}

public class BankAccount extends Subject
{
    public void withDraw()
    {
         //
         for (AccountObserver ao : observer)
         {
            ao.upDate(userAccount)
          }
    }

}

看UML图：

5.观察者模式概�?/span>

�q�就是观察者模式了�Q�对比一下官方的UML图，是不是一目了然了呢？
�E�作说明(�q�里的依赖都是指�q�义的依�?�Q?br>1.被观察者ConcreteSubject�l�承自Subject抽象�c�；
2.Subject抽象�c�M��赖于观察者Observer抽象接口�Q?br>3.观察者ConcreteObserver实现Observer 接口�Q?br>4.观察者ConcreteObserver间接依赖于ConcreteSubject�c�R�?br>如果要增加具体的观察者，只要再实现Obsever接口卛_��Q�而被观察方不需要做��M��修改。而如果需要修改被观察者，只要从Subject抽象�cȝ��承即可�?br>

AAAAA 2007-07-10 10:36 发表评论