【Design Pattern】-----Facade

        

  【Design Pattern】-----Facade

 

目录

基础概念... 

类图：...

java版   Facade. 

     SystemOne.java. 

     StystemTwo.java. 

     StystemThree.java. 

     StystemFour.java. 

     Facade.java. 

     User.java (客户端)

.net例子代码：... 

     SubSystem.cs. 

     Facade.cs. 

     Program.cs (客户端)

小结：... 

     实用什么场景？... 

     使用外观模式的好处...1

 

 

 

基础概念：

 /**

 * 外观模式的总结：

 * 概念：为子系统的一组接口提供一个一致的界面，定义了一个高层接口，

 * 这个接口使得这一子系统更加容易使用。

 * 目的：使得耦合性大大降低

 * @author Daniel.He

 *

 */

 

类图：

            

java版  Facade

              

   

SystemOne.java

public class SystemOne {
    public void OpenSystemOne()
    {
        System.out.println("Open SystemOne");
    }
    
    public void ShutSystemOne()
    {
        System.out.println("Shut SystemOne");
    }
}
 

StystemTwo.java

public class SystemTwo {
    public void OpenSystemTwo()
    {
        System.out.println("Open SystemTwo");
    }
    
    public void ShutSystemTwo()
    {
        System.out.println("Shut SystemTwo");
    }
}

StystemThree.java

public class SystemThree {
    
    public void OpenSystemThree()
    {
        System.out.println("Open SystemThree");
    }
    
    public void ShutSystemThree()
    {
        System.out.println("Shut SystemThree");
    }
}

 

StystemFour.java

public class StystemFour {
    public void OpenStsytemFour()
    {
        System.out.println("Open StystemFour");
    }
    
    public void ShutStsytemFour()
    {
        System.out.println("Shut StystemFour");
    }
}

 

Facade.java

public class Facade {
    SystemOne One;
    SystemTwo Two;
    SystemThree Three;
    StystemFour Four;
    
    public Facade()
    {
        One=new SystemOne();
        Two=new SystemTwo();
        Three=new SystemThree();
        Four=new StystemFour();
    }
    
    public void MethodOPen()
    {
        One.OpenSystemOne();
        Two.OpenSystemTwo();
        Three.OpenSystemThree();
        Four.OpenStsytemFour();        
    }
    
    public void MethodShut()
    {
        
        One.ShutSystemOne();
        Two.ShutSystemTwo();
        Three.ShutSystemThree();
        Four.ShutStsytemFour();
        
        
    }
    
}
 

User.java (客户端)

public class User {
     public static void main(String[] args)
     {
         Facade facade=new Facade();
          facade.MethodOPen();
          facade.MethodShut();
          
     }
}

 

.net例子代码：

            

  

SubSystem.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Facade1._3
{
    class SubSystemOne
    {
        public void MethodOne()
        {
            Console.WriteLine("子系统方法一");
        }
    }
    class SubSystemTwo
    {
        public void MethodTwo()
        {
            Console.WriteLine("子系统方法二");
        }
    }
    class SubSystemThree
    {
        public void MethodThree()
        {
            Console.WriteLine("子系统方法三");
        }
    }
    class SubSystemFour
    {
        public void MethodFour()
        {
            Console.WriteLine("子系统方法四");
        }
    }
}

 

Facade.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Facade1._3
{
    class Facade
    {
        SubSystemOne One;
        SubSystemTwo Two;
        SubSystemThree Three;
        SubSystemFour Four;
        public Facade()
        {
            One = new SubSystemOne();
            Two = new SubSystemTwo();
            Three = new SubSystemThree();
            Four = new SubSystemFour();
        }
        public void MethodA()
        {
            Console.WriteLine("\n 方法组A()-----");
            One.MethodOne();
            Two.MethodTwo();
            Four.MethodFour();
        }
        public void MethodB()
        {
            Console.WriteLine("\n 方法组A()------");
            Two.MethodTwo();
            Three.MethodThree();
        }
    }
}

 

Program.cs (客户端)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Facade1._3
{
    class Program
    {
        static void Main(string[] args)
        {
            Facade facade = new Facade();
            facade.MethodA();
            facade.MethodB();
            Console.Read();
        }
    }
}
 

小结：

    外观模式主要就是为子系统中的一组接口提供一个一致的界面，定义一个高层接口，这个接口使得这一子系统更加容易使用。

   实用什么场景？

   （1）设计初期阶段，应该有意识的讲不通层分离，层与层之间建立外观模式。

   （2）开发阶段，子系统越来越复杂，增加外观模式提高一个简单的调用接口。

   （3）维护一个大型遗留系统的时候，可能这个系统已经难以维护和扩展，但又包含非常重要的功能，为其开发一个外观来，以便更新系统与其交互。

使用外观模式的好处：

   （1）实现子系统与客户端之间的松耦合关系。

  （2）客户端屏蔽了子系统组件，减少了客户端所处理的对象的数目，并使得子系统使用起来更加容易。