设计模式总结 - 结构型

组合类和对象，成为更大的数据结构

Adapter（适配器模式）：将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
Proxy（代理模式）：为其他对象提供一个代理以控制对这个对象的访问。
Bridge（桥接模式）：将抽象部分与它的实现部分分离，使它们都可以独立地变化。
Composite（组合模式）：将对象组合成树型结构以表示“部分－整体”的层次结构。Composite使得客户对单个对象和复合对象的使用具有一致性。
Decorator（装饰者模式）：动态地给一个对象添加一些额外的职责。就扩展功能而言，Decorator模式比生成子类方式更为灵活。
Facade（外观模式）：为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
Flyweight（享元模式）：运用共享技术有效地支持大量细粒度的对象。

1、适配器模式

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

=》定义相同的对外约束，通过代理模式思想，转换达到相同的接口调用目的

 

 

 public class Adapter
    {
        public static void Main1()
        {
            IPlayer player1 = new Forwards("Kobe");
            IPlayer player2 = new Translator("姚明");
            player2.Attack();
            player1.Defense();

            Console.Read();
        }
    }

    public interface IPlayer
    {
        void Attack();
        void Defense();
    }

    public class Forwards : IPlayer
    {
        private string _name;

        public Forwards(string name)
        {
            _name = name;
        }

        public void Attack()
        {
            Console.WriteLine("{0}开始进攻", _name);
        }

        public void Defense()
        {
            Console.WriteLine("{0}开始防守", _name);
        }
    }

    public class Center
    {
        private string _name;

        public Center(string name)
        {
            this._name = name;
        }

        public void 投篮()
        {
            Console.WriteLine(_name+"开始投篮");
        }
    }

    public class Translator : IPlayer
    {
        private Center center;

        public Translator(string name)
        {
            center = new Center(name);
        }

        public void Attack()
        {
            center.投篮();
        }

        public void Defense()
        {
            throw new NotImplementedException();
        }
    }

 

2、代理模式

为其他对象提供一个代理以控制对这个对象的访问

 

 

    /// <summary>
    /// 代理模式和适配器模式的区别
    /// 代理模式使用相同的接口
    /// 适配器模式可能两者之前不一定存在相同的接口
    /// </summary>
    public class Proxy
    {
        public static void Main1()
        {
            ISendMan man = new HelpMan("漂亮MM");
            man.SendFlower();
            man.SendCar();
            Console.Read();
        }
    }

    public interface ISendMan
    {   
        void SendFlower();
        void SendCar();
        string Name{get;}
    }

    public class Gril
    {
        private string _name;

        public Gril(string name)
        {
            this._name = name;
        }

        public string Name
        {
            get { return _name; }
        }
    }

    public class SendMan : ISendMan
    {
        private Gril gril;

        public SendMan(string girlName)
        {
            gril = new Gril(girlName);
        }

        public void SendFlower()
        {
            Console.WriteLine("{0}向{1}送花朵", Name, gril.Name);
        }

        public void SendCar()
        {
            Console.WriteLine("{0}向{1}送汽车", Name, gril.Name);
        }

        public string Name
        {
            get { return "伪人"; }
        }
    }

    public class HelpMan : ISendMan
    {
        private SendMan sendMan;

        public HelpMan(string girlName)
        {
            sendMan = new SendMan(girlName);
        }

        public void SendFlower()
        {
            sendMan.SendFlower();
        }

        public void SendCar()
        {
            sendMan.SendCar();
        }

        public string Name
        {
            get { return sendMan.Name; }
        }
    }

 

3、桥接模式

将抽象部分与它的实现部分分离，使它们都可以独立地变化

 

 

    public class Bridge
    {
        public static void Main1()
        {
            GoodMan man = new GoodMan();
            man.Phone.Call();
            man.Phone.Capture();
            Console.Read();
        }
    }

    public interface IPhone
    {
        void Call();
        void Capture();
    }

    public class HaiweiX86 : IPhone
    {
        public void Call()
        {
            Console.WriteLine("HaiweiX86打电话");
        }

        public void Capture()
        {
            Console.WriteLine("HaiweiX86照相");
        }
    }

    public class GoodMan
    {
        private IPhone _iphone;
        public GoodMan()
        {
            _iphone = new HaiweiX86();
        }

        public IPhone Phone 
        {
            get { return _iphone; }
        }
    }

 

4、组合模式

将对象组合成树型结构以表示“部分－整体”的层次结构。Composite使得客户对单个对象和复合对象的使用具有一致性

 

 public class Composite
    {
        public static void Main1()
        {
            Node devepment = new DepartmentNode("研发部");
            
            //.NET组
            Node netGroup = new DepartmentNode(".NET组");
            netGroup.Add(new EmployeeNode("net1"));
            netGroup.Add(new EmployeeNode("net2"));

            //Java组
            Node javaGroup = new DepartmentNode("Java组");
            javaGroup.Add(new EmployeeNode("java1"));
            javaGroup.Add(new EmployeeNode("java2"));
            javaGroup.Add(new EmployeeNode("java3"));

            devepment.Add(netGroup);
            devepment.Add(javaGroup);
            devepment.Display();

            Console.Read();
        }
    }

    public abstract class Node
    {
        private string _name;

        protected Node(string name)
        {
            _name = name;
        }

        public abstract void Add(Node node);
        public abstract void Remove(Node node);
        public abstract void Display();
        
        public virtual string Name
        {
            get { return _name; }
        }
    }

    public class DepartmentNode : Node
    {
        private List<Node> list = new List<Node>();

        public DepartmentNode(string name)
            : base(name)
        { 
            
        }

        public override void Add(Node node)
        {
            list.Add(node);
        }

        public override void Remove(Node node)
        {
            list.Remove(node);
        }

        public override void Display()
        {
            Console.WriteLine("部门:{0}", this.Name);
            foreach (Node node in list)
            {
                node.Display();
            }
        }
    }

    public class EmployeeNode : Node
    {
        public EmployeeNode(string name)
            : base(name)
        { 
        }

        public override void Add(Node node)
        {
            throw new NotImplementedException();
        }

        public override void Remove(Node node)
        {
            throw new NotImplementedException();
        }

        public override void Display()
        {
            Console.WriteLine("----员工:{0}",this.Name);
        }
    }

5、装饰者模式

动态地给一个对象添加一些额外的职责。就扩展功能而言，Decorator模式比生成子类方式更为灵活

 

 

 /// <summary>
    /// 装饰者模式思想,构造链
    /// 派生一个扩展抽象,包含Next指针,以及本体方法的base实现
    /// </summary>
    public class Decorator
    {
        public static void Main1()
        {
            //INumber A = new A();
            //IAbstractNumber B = new B();
            //IAbstractNumber C = new C();
            //C.Next = B;
            //B.Next = A;
            //C.GetNumber();
            //Console.Read();

            IPrint p1 = new ConsolePrint();
            PrintBase p2 = new FilePrint();
            PrintBase p3 = new PdfPrint();
            p2.Next = p3;
            p3.Next = p1;
            p2.Print("Hello,china");

            Console.Read();
            
        }
    }

    #region 接口案例

    public interface INumber
    {
        void GetNumber();
    }

    public class A:INumber
    {   
        public void GetNumber()
        {
            Console.WriteLine("A"); 
        }
    }

    public interface IAbstractNumber:INumber
    {
        INumber Next { get; set; }
    }

    public class B : IAbstractNumber
    {
        public INumber Next
        {
            get;
            set;
        }

        public void GetNumber()
        {
            Console.WriteLine("B");
            if (Next != null)
            {
                Next.GetNumber();
            }
        }
    }

    public class C : IAbstractNumber
    {
        public INumber Next
        {
            get;
            set;
        }

        public void GetNumber()
        {
            Console.WriteLine("C");
            if (Next != null)
            {
                Next.GetNumber();
            }
        }
    }

#endregion 

    #region 抽象类案例

    public interface IPrint
    {
        void Print(string msg);
    }

    public class ConsolePrint : IPrint
    {
        public void Print(string msg)
        {
            Console.WriteLine("console print:{0}", msg);
        }
    }

    public abstract class PrintBase : IPrint
    {
        public IPrint Next { get; set; }

        public virtual void Print(string msg)
        {
            if (Next != null)
            {
                Next.Print(msg);
            }
        }
    }

    public class FilePrint : PrintBase
    {
        public override void Print(string msg)
        {
            Console.WriteLine("file print:{0}", msg);
            base.Print(msg);
        }
    }

    public class PdfPrint : PrintBase
    {
        public override void Print(string msg)
        {
            Console.WriteLine("pdf print:{0}", msg);
            base.Print(msg);
        }
    }




    
    #endregion 

 

6、享元模式

运用共享技术有效地支持大量细粒度的对象

 

 

 public class Flyweight
    {   
        public static void Main1()
        {
            UserManger _userManager = new UserManger();
            _userManager.Add(1, "1");
            _userManager.Add(2, "2");
            _userManager.Add(3, "3");

            string v = _userManager[2];
            Console.WriteLine(v);

            Console.Read();
        }
    }

    public class UserManger
    {
        private IDictionary<int, string> dictionary = new Dictionary<int, string>();

        public void Add(int key, string value)
        {
            if (dictionary.ContainsKey(key))
            {
                return;
            }
            dictionary.Add(key, value);
        }

        public string this[int index]
        {
            get { return dictionary[index]; }
        }
    }

 

7、享元模式

为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用

{
    public class Facade
    {   
        public static void Main1()
        {
            LogicFacade facade = new LogicFacade();
            
            //Add
            double result = facade.CalcatorMgr.Add(3, 5);
            Console.WriteLine(result);
            
            //WriteMsg
            facade.LogMgr.WriteMsg("Hello,china");
            Console.Read();
        }
    }

    public class LogicFacade
    {
        public LogicFacade()
        {
            CalcatorMgr = new Calculator();
            LogMgr = new Log();
        }

        public ICalculator CalcatorMgr { get; private set; }
        public ILog LogMgr { get; private set; }
    }

    public interface ICalculator
    {
        double Add(double x, double y);
    }

    public class Calculator : ICalculator
    {
        public double Add(double x, double y)
        {
            return x + y;
        }
    }

    public interface ILog
    {
        void WriteMsg(string msg);
    }

    public class Log : ILog
    {
        public void WriteMsg(string msg)
        {
            Console.WriteLine(msg);
        }
    }