金九银十面试题之《设计模式》

**金九银十面试题之《设计模式》**

在软件开发领域，设计模式是一套被反复使用、多数已知的、经过实践证明良好模式。这些模式已经被应用于各种类型的项目中，包括企业级应用程序、系统集成和网络应用等。在本文中，我们将讨论一些常见的设计模式及其在面试中的应用。

###1. 单例模式**定义：**

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供全局访问点。

**示例代码：**

class Singleton:
 _instance = None def __new__(cls):
 if cls._instance is None:
 cls._instance = super(Singleton, cls).__new__(cls)
 return cls._instance# 使用示例obj1 = Singleton()
obj2 = Singleton()

print(obj1 is obj2) # True

**注释：**

在上面的代码中，我们定义了一个类 `Singleton`，它使用元编程来确保只有一个实例。我们通过覆盖 `__new__` 方法来实现这一点。在 `__new__` 方法中，我们检查是否已经有一个实例，如果没有，则创建一个新的实例并返回它。如果已经有一个实例，则直接返回该实例。

###2. 工厂模式**定义：**

工厂模式是一种创建型设计模式，它提供了创建对象的接口，而不需要暴露具体类的实现细节。

**示例代码：**

class AnimalFactory:
 def create_animal(self, animal_type):
 if animal_type == "dog":
 return Dog()
 elif animal_type == "cat":
 return Cat()
 else:
 raise ValueError("Invalid animal type")

class Dog:
 passclass Cat:
 pass# 使用示例factory = AnimalFactory()
dog = factory.create_animal("dog")
print(dog.__class__) # 

**注释：**

在上面的代码中，我们定义了一个工厂类 `AnimalFactory`，它提供了创建动物的接口。我们通过使用一个字典来实现这一点。在 `create_animal` 方法中，我们检查动物类型，如果是 "dog" 则返回一个 `Dog` 实例，如果是 "cat" 则返回一个 `Cat` 实例。如果输入的动物类型无效，则抛出一个异常。

###3. 观察者模式**定义：**

观察者模式是一种行为型设计模式，它允许对象之间建立一种一对多的依赖关系，使得当一个对象改变状态时，其他依赖于该对象的对象都会受到通知并自动更新。

**示例代码：**

class Subject:
 def __init__(self):
 self.observers = []

 def attach(self, observer):
 self.observers.append(observer)

 def detach(self, observer):
 self.observers.remove(observer)

 def notify(self, modifier=None):
 for observer in self.observers:
 if modifier != observer:
 observer.update(self)

class Observer:
 def update(self, subject):
 print(f"Received notification from {subject}")

# 使用示例subject = Subject()
observer1 = Observer()
observer2 = Observer()

subject.attach(observer1)
subject.attach(observer2)

subject.notify() # Received notification from <__main__.Subject object at0x...>

**注释：**

在上面的代码中，我们定义了一个主题类 `Subject` 和一个观察者类 `Observer`。我们通过使用一个列表来实现主题和观察者的关系。在 `attach` 方法中，我们将观察者添加到列表中，在 `detach` 方法中，我们从列表中移除观察者。在 `notify` 方法中，我们遍历列表并调用每个观察者的 `update` 方法。

###4. 策略模式**定义：**

策略模式是一种行为型设计模式，它允许在一个类中定义一系列算法或策略，并使得这些策略可以被交换和使用。

**示例代码：**

class Strategy:
 def algorithm(self, data):
 passclass ConcreteStrategyA(Strategy):
 def algorithm(self, data):
 return data *2class ConcreteStrategyB(Strategy):
 def algorithm(self, data):
 return data +1class Context:
 def __init__(self, strategy):
 self._strategy = strategy @property def strategy(self):
 return self._strategy @strategy.setter def strategy(self, strategy):
 if not isinstance(strategy, Strategy):
 raise ValueError("Invalid strategy")
 self._strategy = strategy# 使用示例context = Context(ConcreteStrategyA())
print(context.strategy.algorithm(5)) #10context.strategy = ConcreteStrategyB()
print(context.strategy.algorithm(5)) #6

**注释：**

在上面的代码中，我们定义了一个策略类 `Strategy` 和两个具体策略类 `ConcreteStrategyA` 和 `ConcreteStrategyB`。我们通过使用一个属性来实现策略的切换。在 `Context` 类中，我们有一个 `_strategy` 属性，它可以被设置为不同的策略实例。在 `algorithm` 方法中，我们调用当前策略的 `algorithm` 方法。

###5. 模板方法模式**定义：**

模板方法模式是一种行为型设计模式，它允许在一个类中定义一个算法或流程，并使得子类可以重写某些步骤，而不改变算法的结构。

**示例代码：**

class AbstractClass:
 def template_method(self):
 self.step1()
 self.step2()
 self.step3()

 def step1(self):
 print("Step1")

 def step2(self):
 print("Step2")

 def step3(self):
 print("Step3")

class ConcreteClass(AbstractClass):
 def step2(self):
 print("Concrete Step2")

# 使用示例abstract_class = AbstractClass()
print(abstract_class.template_method()) # Step1, Step2, Step3concrete_class = ConcreteClass()
print(concrete_class.template_method()) # Step1, Concrete Step2, Step3

**注释：**

在上面的代码中，我们定义了一个抽象类 `AbstractClass` 和一个具体类 `ConcreteClass`。我们通过使用一个模板方法 `template_method` 来实现算法的流程。在 `step1`、`step2` 和 `step3` 方法中，我们分别执行不同的步骤。在 `ConcreteClass` 中，我们重写了 `step2` 方法。

###6. 适配器模式**定义：**

适配器模式是一种结构型设计模式，它允许两个不兼容的接口之间建立一个适配器，从而使得它们可以一起工作。

**示例代码：**

class Target:
 def request(self):
 return "Target Request"

class Adaptee:
 def specific_request(self):
 return "Adaptee Specific Request"

class Adapter(Target, Adaptee):
 def request(self):
 return self.specific_request()

# 使用示例target = Target()
print(target.request()) # Target Requestadapter = Adapter()
print(adapter.request()) # Adaptee Specific Request

**注释：**

在上面的代码中，我们定义了一个目标类 `Target` 和一个被适配者类 `Adaptee`。我们通过使用一个适配器类 `Adapter` 来实现两个接口之间的适配。在 `Adapter` 类中，我们重写了 `request` 方法，使得它可以调用 `specific_request` 方法。

###7. 装饰器模式**定义：**

装饰器模式是一种结构型设计模式，它允许在不改变原有类的基础上，动态地添加新的行为或功能。

**示例代码：**

def decorator(func):
 def wrapper(*args, **kwargs):
 print("Before calling the function")
 func(*args, **kwargs)
 print("After calling the function")
 return wrapper@decoratordef add(a, b):
 return a + bprint(add(2,3)) # Before calling the function,5, After calling the function

**注释：**

在上面的代码中，我们定义了一个装饰器函数 `decorator` 和一个被装饰的函数 `add`。我们通过使用装饰器语法来实现装饰器的应用。在 `decorator` 函数中，我们定义了一个新函数 `wrapper`，它可以包裹原有的函数 `add`。

###8. 外观模式**定义：**

外观模式是一种结构型设计模式，它允许在不暴露内部实现细节的情况下，提供一个统一的接口来访问多个子系统。

**示例代码：**

class Subsystem1:
 def operation1(self):
 return "Subsystem1: Ready!"

class Subsystem2:
 def operation2(self):
 return "Subsystem2: