关于开发岗位面试题常用到的7种设计模式知识点代码例子用法简要说明

站长作为一名动手党，一般对这些理论性的东西向来不屑一顾（说白了就是懒看不进书），动手能力方面还行但遇上理论性的东西就抓瞎了，还记得前几年的一次面试，被问到了关于设计模式的事情，听过工厂模式但也不甚了解，支支吾吾半天没憋出一句有用的回答，反而显得自己几年的工作经验就像是假的一样的，最终结局就是“此处不留爷自有留爷处”告终，最近有点空闲就看了看常用的几种设计模式和用法，这里作一下留存记录：

以下是每个设计模式的简单示例代码，并附有相应的说明性文字描述：

1.单例模式（Singleton Pattern）：

说明：单例模式确保一个类只有一个实例，并提供全局访问点。代码中的 Singleton 类通过一个私有的构造函数和一个静态的 Instance 属性来控制对象的创建和访问。

public class Singleton
{
    private static Singleton instance;
    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                instance = new Singleton();
            }
            return instance;
        }
    }
}

2.工厂模式（Factory Pattern）：

说明：工厂模式通过工厂类创建对象，隐藏具体对象的创建逻辑。代码中的 Factory 类根据传入的类型参数，在 CreateProduct 方法中创建对应的具体产品对象。

public abstract class Product
{
    public abstract void Use();
}

public class ConcreteProductA : Product
{
    public override void Use()
    {
        Console.WriteLine("Using ConcreteProductA");
    }
}

public class ConcreteProductB : Product
{
    public override void Use()
    {
        Console.WriteLine("Using ConcreteProductB");
    }
}

public class Factory
{
    public static Product CreateProduct(string type)
    {
        switch (type)
        {
            case "A":
                return new ConcreteProductA();
            case "B":
                return new ConcreteProductB();
            default:
                throw new ArgumentException("Invalid type");
        }
    }
}

3.观察者模式（Observer Pattern）：

说明：观察者模式定义了对象之间的一对多依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都会收到通知并进行相应的更新。代码中的 ConcreteSubject 类实现了 ISubject 接口，并在 Notify 方法中通知所有注册的观察者对象。

public interface IObserver
{
    void Update();
}

public class ConcreteObserver : IObserver
{
    public void Update()
    {
        Console.WriteLine("Observer is updated");
    }
}

public interface ISubject
{
    void Attach(IObserver observer);
    void Detach(IObserver observer);
    void Notify();
}

public class ConcreteSubject : ISubject
{
    private List<IObserver> observers = new List<IObserver>();

    public void Attach(IObserver observer)
    {
        observers.Add(observer);
    }

    public void Detach(IObserver observer)
    {
        observers.Remove(observer);
    }

    public void Notify()
    {
        foreach (var observer in observers)
        {
            observer.Update();
        }
    }
}

4.适配器模式（Adapter Pattern）：

说明：适配器模式将一个类的接口转换成客户端期望的接口，使得原本由于接口不兼容而无法在一起工作的类可以协同工作。代码中的 Adapter 类实现了 ITarget 接口，并在 Request 方法中适配调用了 Adaptee 类的 SpecificRequest 方法。

public interface ITarget
{
    void Request();
}

public class Adaptee
{
    public void SpecificRequest()
    {
        Console.WriteLine("Adaptee's SpecificRequest");
    }
}

public class Adapter : ITarget
{
    private Adaptee adaptee;

    public Adapter(Adaptee adaptee)
    {
        this.adaptee = adaptee;
    }

    public void Request()
    {
        adaptee.SpecificRequest();
    }
}

5.装饰器模式（Decorator Pattern）：

说明：装饰器模式动态地将责任附加到对象上，扩展对象的功能而不修改其原始代码。代码中的 ConcreteDecorator 类通过继承 Decorator 类，并在 Operation 方法中添加了额外的操作。

public interface IComponent
{
    void Operation();
}

public class ConcreteComponent : IComponent
{
    public void Operation()
    {
        Console.WriteLine("ConcreteComponent operation");
    }
}

public abstract class Decorator : IComponent
{
    protected IComponent component;

    public Decorator(IComponent component)
    {
        this.component = component;
    }

    public virtual void Operation()
    {
        component.Operation();
    }
}

public class ConcreteDecorator : Decorator
{
    public ConcreteDecorator(IComponent component) : base(component)
    {
    }

    public override void Operation()
    {
        base.Operation();
        Console.WriteLine("Additional operation from ConcreteDecorator");
    }
}

6.策略模式（Strategy Pattern）：

说明：策略模式定义了算法族，将每个算法都封装起来，并使它们之间可以互相替换。代码中的 Context 类根据传入的策略对象，在 ExecuteStrategy 方法中执行相应的算法。

public interface IStrategy
{
    void Execute();
}

public class ConcreteStrategyA : IStrategy
{
    public void Execute()
    {
        Console.WriteLine("Executing strategy A");
    }
}

public class ConcreteStrategyB : IStrategy
{
    public void Execute()
    {
        Console.WriteLine("Executing strategy B");
    }
}

public class Context
{
    private IStrategy strategy;

    public Context(IStrategy strategy)
    {
        this.strategy = strategy;
    }

    public void ExecuteStrategy()
    {
        strategy.Execute();
    }
}

7.迭代器模式（Iterator Pattern）：

说明：迭代器模式提供了一种顺序访问聚合对象元素的方法，而无需暴露其内部表示。代码中的 ConcreteAggregate 类实现了 IAggregate 接口，并在 CreateIterator 方法中返回了一个迭代器对象，该迭代器可以用于遍历聚合对象中的元素。

public interface IIterator
{
    bool HasNext();
    object Next();
}

public interface IAggregate
{
    IIterator CreateIterator();
}

public class ConcreteIterator : IIterator
{
    private List<object> items = new List<object>();
    private int position = 0;

    public ConcreteIterator(List<object> items)
    {
        this.items = items;
    }

    public bool HasNext()
    {
        return position < items.Count;
    }

    public object Next()
    {
        object item = items[position];
        position++;
        return item;
    }
}

public class ConcreteAggregate : IAggregate
{
    private List<object> items = new List<object>();

    public void AddItem(object item)
    {
        items.Add(item);
    }

    public IIterator CreateIterator()
    {
        return new ConcreteIterator(items);
    }
}