适配器模式

7种结构型模式：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。其中对象的适配器模式是各种模式的起源。

适配器模式，将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。适配器模式又分三类，类的适配器，对象的适配器，接口的适配器。

1.类的适配器

class Program
    {
        static void Main(string[] args)
        {
            ITaget adapter = new Adapter();
            adapter.Method1();
            adapter.Method2();
            Console.Read();
        }
    }

    public class Source {
        public void Method1() {
            Console.WriteLine("原始方法");
        }
    }

    public interface ITaget {
        //与原类种的方法相同
        void Method1();
        //新的方法
        void Method2();
    }
    /// <summary>
    /// ITaget 的实现类就具有了Source 的功能
    /// </summary>
    public class Adapter : Source,ITaget
    {
        public void Method2()
        {
            Console.WriteLine("接口中的方法");
        }
    }

　　

2.对象适配器

基本思想和类的适配器相同，只是Adapter不再继承Source 类，而是持有Source 类的实例。

class Program
    {
        static void Main(string[] args)
        {
            Source source = new Source();
            ITaget adapter = new Adapter(source);
            adapter.Method1();
            adapter.Method2();
            Console.Read();
        }
    }

    public class Source {
        public void Method1() {
            Console.WriteLine("原始方法");
        }
    }

    public interface ITaget {
        //与原类种的方法相同
        void Method1();
        //新的方法
        void Method2();
    }
    /// <summary>
    /// ITaget 的实现类就具有了Source 的功能
    /// </summary>
    public class Adapter :ITaget
    {
        private Source source;
        public Adapter(Source source) {
            this.source = source;
        }

        public void Method1()
        {
            source.Method1();
        }

        public void Method2()
        {
            Console.WriteLine("接口中的方法");
        }
    }

3.接口的适配器

有时候一个接口有多个方法，如果要实现这个几口必须实现所有的方法，有点浪费。并不是所有的方法都是需要的，有时只需要其中一部分。这时，可以用一个抽象类实现该接口的所有方法，再继承这个类，重写需要的方法即可。

class Program
    {
        static void Main(string[] args)
        {
            ITaget source1 = new Source1();
            ITaget source2 = new Source2();
            source1.Method1();
            source2.Method2();
            Console.Read();
        }
    }

    public interface ITaget {
        void Method1();
        void Method2();
    }

    public abstract class Warapper : ITaget
    {
        public virtual void Method1()
        {
        }

        public virtual void Method2()
        {
        }
    }

    public class Source1: Warapper
    {
        public override void Method1()
        {
            Console.WriteLine("方法1");
        }
    }

    public class Source2 : Warapper {
        public override void Method2() {
            Console.WriteLine("方法2");
        }
    }

 总结下3中适配器模式的应用场景：

类的适配器：当希望将一个类转换成满足另一个新接口的类时，可以用类的适配器。创建一个新类，继承原有的类，实现新的接口。

对象的适配器：当希望将一个对象转换成满足另一个新接口的对象是，可以创建一个新类，持有原类的一个实例，在新类的方法中调用实例的方法。

接口的适配器：当不希望实现接口中的所有方法是，可以创建一个抽象类，用虚方法实现所有方法。写特别的类时继承这个抽象类override 需要的方法即可。