关于开发岗位面试题常用到的7种设计模式

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

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

$67acd1d1-0c2b-c538-007c-a0087052f956

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

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);
    }
}

关于开发岗位面试题常用到的7种设计模式

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

随机推荐