PHP 面试考点之设计模式全面解析

今天 9692阅读

在 PHP 面试中，设计模式是一个重要的考点。掌握常见的设计模式，不仅能体现开发者的编程能力和经验，也能让代码更具可维护性和扩展性。下面就来详细介绍几种常见的 PHP 设计模式。

单例模式

单例模式是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点。这种模式在需要全局访问某个对象，且该对象只需要一个实例时非常有用，比如数据库连接对象。

class DatabaseConnection {
    // 保存单例实例的静态属性
    private static $instance;
    // 数据库连接属性
    private $connection;

    // 私有构造函数，防止外部实例化
    private function __construct() {
        // 模拟数据库连接
        $this->connection = new PDO('mysql:host=localhost;dbname=test', 'username', 'password');
    }

    // 防止对象被克隆
    private function __clone() {}

    // 防止对象被反序列化
    private function __wakeup() {}

    // 获取单例实例的静态方法
    public static function getInstance() {
        if (!self::$instance) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    // 获取数据库连接的方法
    public function getConnection() {
        return $this->connection;
    }
}

// 使用单例模式获取数据库连接实例
$db = DatabaseConnection::getInstance();
$connection = $db->getConnection();

代码解释

构造函数被声明为私有，防止外部直接实例化该类。
__clone 和 __wakeup 方法被声明为私有，防止对象被克隆和反序列化。
getInstance 方法用于获取单例实例，如果实例不存在则创建一个新的实例。

工厂模式

工厂模式是一种创建型设计模式，它提供了一种创建对象的方式，将对象的创建和使用分离。通过工厂类来创建对象，而不是在代码中直接实例化对象，这样可以提高代码的可维护性和可扩展性。

// 定义一个产品接口
interface Product {
    public function operation();
}

// 具体产品类
class ConcreteProductA implements Product {
    public function operation() {
        return "ConcreteProductA operation";
    }
}

class ConcreteProductB implements Product {
    public function operation() {
        return "ConcreteProductB operation";
    }
}

// 工厂类
class ProductFactory {
    public static function createProduct($type) {
        switch ($type) {
            case 'A':
                return new ConcreteProductA();
            case 'B':
                return new ConcreteProductB();
            default:
                throw new InvalidArgumentException("Invalid product type");
        }
    }
}

// 使用工厂类创建产品
$productA = ProductFactory::createProduct('A');
echo $productA->operation();

代码解释

Product 接口定义了产品的操作方法。
ConcreteProductA 和 ConcreteProductB 是具体的产品类，实现了 Product 接口。
ProductFactory 是工厂类，根据传入的类型创建相应的产品对象。

观察者模式

观察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知并自动更新。这种模式常用于实现事件驱动系统。

// 主题接口
interface Subject {
    public function attach(Observer $observer);
    public function detach(Observer $observer);
    public function notify();
}

// 观察者接口
interface Observer {
    public function update(Subject $subject);
}

// 具体主题类
class ConcreteSubject implements Subject {
    private $observers = [];
    private $state;

    public function attach(Observer $observer) {
        $this->observers[] = $observer;
    }

    public function detach(Observer $observer) {
        $key = array_search($observer, $this->observers, true);
        if ($key!== false) {
            unset($this->observers[$key]);
        }
    }

    public function notify() {
        foreach ($this->observers as $observer) {
            $observer->update($this);
        }
    }

    public function setState($state) {
        $this->state = $state;
        $this->notify();
    }

    public function getState() {
        return $this->state;
    }
}

// 具体观察者类
class ConcreteObserver implements Observer {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function update(Subject $subject) {
        echo $this->name. " received update: ". $subject->getState(). "\n";
    }
}

// 使用观察者模式
$subject = new ConcreteSubject();
$observer1 = new ConcreteObserver('Observer 1');
$observer2 = new ConcreteObserver('Observer 2');

$subject->attach($observer1);
$subject->attach($observer2);

$subject->setState("New state");

代码解释

Subject 接口定义了主题的基本操作，包括添加观察者、移除观察者和通知观察者。
Observer 接口定义了观察者的更新方法。
ConcreteSubject 是具体的主题类，实现了 Subject 接口。
ConcreteObserver 是具体的观察者类，实现了 Observer 接口。

策略模式

策略模式是一种行为型设计模式，它定义了一系列的算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户端。

// 策略接口
interface Strategy {
    public function execute($a, $b);
}

// 具体策略类：加法
class AddStrategy implements Strategy {
    public function execute($a, $b) {
        return $a + $b;
    }
}

// 具体策略类：减法
class SubtractStrategy implements Strategy {
    public function execute($a, $b) {
        return $a - $b;
    }
}

// 上下文类
class Context {
    private $strategy;

    public function __construct(Strategy $strategy) {
        $this->strategy = $strategy;
    }

    public function setStrategy(Strategy $strategy) {
        $this->strategy = $strategy;
    }

    public function executeStrategy($a, $b) {
        return $this->strategy->execute($a, $b);
    }
}

// 使用策略模式
$addStrategy = new AddStrategy();
$context = new Context($addStrategy);
$result = $context->executeStrategy(5, 3);
echo "Addition result: ". $result. "\n";

$subtractStrategy = new SubtractStrategy();
$context->setStrategy($subtractStrategy);
$result = $context->executeStrategy(5, 3);
echo "Subtraction result: ". $result. "\n";