系统设计入门：停车场面向对象设计方案解析

引言

停车场系统是系统设计面试中常见的题目，也是面向对象设计原则的绝佳实践案例。本文将深入分析一个多层级停车场系统的设计方案，探讨如何运用面向对象思想解决实际问题。

系统需求分析

车辆类型支持

系统需要支持三种主要车辆类型：

• 摩托车（Motorcycle）
• 轿车（Car）
• 巴士（Bus）

停车位占用规则

不同车辆类型占用停车位的规则不同：

• 摩托车：可停放在摩托车专用位
• 轿车：可停放在紧凑车位或大车位
• 巴士：需要连续5个大车位才能停放

停车场结构

系统设计为多层结构，每层包含多个停车位。

核心类设计

1. 车辆基类(Vehicle)

作为所有车辆类型的基类，采用抽象基类(ABC)设计：

class Vehicle(metaclass=ABCMeta):
    def __init__(self, vehicle_size, license_plate, spot_size):
        self.vehicle_size = vehicle_size  # 车辆尺寸类型
        self.license_plate = license_plate  # 车牌号
        self.spot_size = spot_size  # 需要占用的车位数量
        self.spots_taken = []  # 已占用的车位列表

    def clear_spots(self):
        # 释放所有占用的车位
        pass

    def take_spot(self, spot):
        # 占用一个车位
        pass

    @abstractmethod
    def can_fit_in_spot(self, spot):
        # 抽象方法：判断是否能停入指定车位
        pass

2. 具体车辆类

摩托车类(Motorcycle)

class Motorcycle(Vehicle):
    def __init__(self, license_plate):
        super().__init__(VehicleSize.MOTORCYCLE, license_plate, spot_size=1)
    
    def can_fit_in_spot(self, spot):
        return True  # 摩托车可停在任何类型的车位

轿车类(Car)

class Car(Vehicle):
    def __init__(self, license_plate):
        super().__init__(VehicleSize.COMPACT, license_plate, spot_size=1)
    
    def can_fit_in_spot(self, spot):
        # 轿车只能停在紧凑车位或大车位
        return spot.size in (VehicleSize.LARGE, VehicleSize.COMPACT)

巴士类(Bus)

class Bus(Vehicle):
    def __init__(self, license_plate):
        super().__init__(VehicleSize.LARGE, license_plate, spot_size=5)
    
    def can_fit_in_spot(self, spot):
        # 巴士只能停在大车位，且需要连续5个
        return spot.size == VehicleSize.LARGE

3. 停车场类(ParkingLot)

管理整个停车场系统，包含多个层级：

class ParkingLot:
    def __init__(self, num_levels):
        self.num_levels = num_levels
        self.levels = []  # 停车场层级列表
    
    def park_vehicle(self, vehicle):
        # 尝试在每一层停放车辆
        for level in self.levels:
            if level.park_vehicle(vehicle):
                return True
        return False

4. 层级类(Level)

管理单个楼层的停车位：

class Level:
    SPOTS_PER_ROW = 10  # 每行停车位数量
    
    def __init__(self, floor, total_spots):
        self.floor = floor  # 楼层号
        self.num_spots = total_spots  # 总车位数量
        self.available_spots = 0  # 可用车位数量
        self.parking_spots = []  # 车位列表
    
    def park_vehicle(self, vehicle):
        # 查找并停放车辆
        spot = self._find_available_spot(vehicle)
        if spot:
            spot.park_vehicle(vehicle)
            return spot
        return None
    
    def _find_available_spot(self, vehicle):
        # 查找可用车位的实现逻辑
        pass

5. 停车位类(ParkingSpot)

表示单个停车位：

class ParkingSpot:
    def __init__(self, level, row, spot_number, spot_size, vehicle_size):
        self.level = level  # 所属层级
        self.row = row  # 所在行
        self.spot_number = spot_number  # 车位编号
        self.spot_size = spot_size  # 车位大小
        self.vehicle_size = vehicle_size  # 允许停放的车辆大小
        self.vehicle = None  # 当前停放的车辆
    
    def is_available(self):
        return self.vehicle is None
    
    def can_fit_vehicle(self, vehicle):
        if not self.is_available():
            return False
        return vehicle.can_fit_in_spot(self)
    
    def park_vehicle(self, vehicle):
        # 停放车辆的具体实现
        pass
    
    def remove_vehicle(self):
        # 移除车辆的具体实现
        pass

设计模式应用

1. 抽象工厂模式

通过Vehicle基类和具体子类的设计，实现了车辆类型的扩展性。新增车辆类型只需继承Vehicle并实现相应方法。

2. 组合模式

ParkingLot由多个Level组成，每个Level又包含多个ParkingSpot，形成了树形结构，便于整体管理。

3. 策略模式

不同车辆类型通过实现各自的can_fit_in_spot方法，定义了不同的停车策略。

关键问题解决方案

1. 巴士需要连续5个大车位

在Level类的_find_available_spot方法中需要实现连续车位的查找逻辑：

1. 遍历所有大车位
2. 检查是否有连续5个可用的大车位
3. 如果有，返回第一个车位的位置

2. 多层级停车管理

ParkingLot类负责协调多个Level，当一辆车进入时：

1. 从第一层开始尝试停放
2. 如果当前层没有合适车位，尝试下一层
3. 如果所有层都尝试失败，返回停车失败

扩展思考

1. 性能优化

对于大型停车场，可以考虑：

• 使用空间索引加速车位查找
• 为每层维护不同类型车位的可用数量计数器

2. 功能扩展

系统可以轻松扩展以下功能：

• 残疾人专用车位
• 电动车充电车位
• VIP预留车位
• 停车计时和收费系统

总结

这个停车场系统设计展示了面向对象设计的核心原则：

1. 封装：将数据和操作封装在类中
2. 继承：通过继承实现代码复用
3. 多态：不同车辆类型实现各自的停车逻辑
4. 组合：通过对象组合构建复杂系统

通过合理的类划分和职责分配，系统具有良好的扩展性和维护性，能够适应各种需求变化。