菜单
Apply SOLID principles to write maintainable, extensible object-oriented code. Outputs principle-by-principle analysis, refactoring examples, and design decision guidelines.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/kalilurrahman/kr-claudiator-skills --skill solid-principles命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
基于 SOC 职业分类
正在显示 SKILL.md
| name | solid-principles |
| description | Apply SOLID principles to write maintainable, extensible object-oriented code. Outputs principle-by-principle analysis, refactoring examples, and design decision guidelines. |
| argument-hint | ["codebase language","identified violations","team OOP experience level"] |
| allowed-tools | Read, Write |
SOLID is five design principles that make object-oriented code easier to understand, extend, and maintain. Each principle targets a specific category of design rot: rigidity, fragility, immobility, viscosity, and needless complexity.
A class should have one reason to change. One responsibility, one axis of change.
# BAD — UserService has too many responsibilities
class UserService:
def create_user(self, data): ...
def send_welcome_email(self, user): ... # Email concern
def generate_report(self, users): ... # Reporting concern
(): ...
(): ...
:
():
._repo = user_repo
._email = email_service
() -> User:
user = User(**data)
._repo.save(user)
._email.send_welcome(user)
user
:
(): ...
:
() -> Report: ...
:
() -> : ...
Open for extension, closed for modification. Add new behaviour without changing existing code.
# BAD — must modify existing code to add new discount types
class OrderPricer:
def calculate(self, order, discount_type: str) -> float:
if discount_type == "percentage":
return order.total * 0.9
elif discount_type == "fixed":
return order.total - 10
elif discount_type == "bogo": # Must modify class each time
return order.total * 0.5
# GOOD — add new discount types without touching OrderPricer
from abc import ABC, abstractmethod
class DiscountStrategy(ABC):
@abstractmethod
def apply(self, total: float) -> float: ...
class PercentageDiscount(DiscountStrategy):
def __init__(self, pct: float): self._pct = pct
def apply(self, total: float) -> float: return total * (1 - self._pct)
class FixedDiscount(DiscountStrategy):
def __init__(self, amount: float): self._amount = amount
def apply(self, total: float) -> float: return total - self._amount
class BuyOneGetOne(DiscountStrategy):
def apply(self, total: float) -> float: return total * 0.5
class OrderPricer:
def calculate(self, order, discount: DiscountStrategy) -> float:
return discount.apply(order.total) # Never changes
Subtypes must be substitutable for their base types without altering program correctness.
# BAD — Square breaks Rectangle contract (classic violation)
class Rectangle:
def set_width(self, w): self.width = w
def set_height(self, h): self.height = h
def area(self) -> float: return self.width * self.height
class Square(Rectangle):
def set_width(self, w):
self.width = w
self.height = w # Breaks: caller expects independent dimensions
def resize(rect: Rectangle):
rect.set_width(5)
rect.set_height(10)
assert rect.area() == 50 # Fails for Square!
# GOOD — separate abstractions
from abc import ABC, abstractmethod
class Shape(ABC):
@abstractmethod
def area(self) -> float: ...
class Rectangle(Shape):
def __init__(self, w, h): self.width = w; self.height = h
def area(self): return self.width * self.height
class Square(Shape):
def __init__(self, side): self.side = side
def area(self): return self.side ** 2
Clients should not depend on interfaces they don't use. Prefer small, focused interfaces.
# BAD — fat interface forces all implementors to implement unused methods
class Worker(ABC):
@abstractmethod
def work(self): ...
@abstractmethod
def eat(self): ... # Robots don't eat!
@abstractmethod
def sleep(self): ... # Robots don't sleep!
class Robot(Worker):
def work(self): ...
def eat(self): raise NotImplementedError # Forced to implement nonsense
def sleep(self): raise NotImplementedError
# GOOD — segregated interfaces
class Workable(ABC):
@abstractmethod
def work(self): ...
class Eatable(ABC):
@abstractmethod
def eat(self): ...
class HumanWorker(Workable, Eatable):
def work(self): ...
def eat(self): ...
class RobotWorker(Workable):
def work(self): ... # Only implements what it needs
High-level modules should not depend on low-level modules. Both should depend on abstractions.
# BAD — high-level OrderProcessor depends on concrete MySQLRepository
class OrderProcessor:
def __init__(self):
self._repo = MySQLOrderRepository() # Concrete dependency — hard to test, swap
def process(self, order_id: str):
order = self._repo.get(order_id) # Tied to MySQL forever
# GOOD — depend on abstraction
class OrderRepository(ABC):
@abstractmethod
def get(self, order_id: str) -> Order: ...
@abstractmethod
def save(self, order: Order): ...
class OrderProcessor:
def __init__(self, repo: OrderRepository): # Depends on abstraction
self._repo = repo
def process(self, order_id: str):
order = self._repo.get(order_id)
# Inject any implementation
class MySQLOrderRepository(OrderRepository):
def get(self, order_id): ...
class InMemoryOrderRepository(OrderRepository): # For tests
def get(self, order_id): ...
# Production
processor = OrderProcessor(MySQLOrderRepository())
# Test
processor = OrderProcessor(InMemoryOrderRepository())
| Principle | Violation | Fix |
|---|---|---|
| SRP | God class with 20+ methods | Extract into focused collaborators |
| OCP | Long if/elif chains for type dispatch | Strategy or visitor pattern |
| LSP | Subclass throws NotImplementedError | Restructure hierarchy; use composition |
| ISP | Interface with 10+ methods | Split into role-specific interfaces |
| DIP | new ConcreteClass() inside business logic | Constructor injection; depend on ABC |
isinstance(x, SubClass) in the base class logic, LSP is broken.