SOLID 是面向对象编程和设计的五个基本原则的缩写，旨在使软件更易于维护、扩展和理解。在 Android 开发中，遵循 SOLID 原则有助于构建健壮、可测试和可维护的应用，尤其是在配合 Clean Architecture 时。
SOLID 原则详解
1. S - 单一职责原则 (Single Responsibility Principle)
一个类应该只有一个引起变化的原因
- 每个类/模块只负责一个功能领域
- 降低类的复杂度，提高可读性和可维护性
Android 示例：
kotlin
// ❌ 违反 SRP
class UserManager {
fun saveUser(user: User) { /* 数据库操作 */ }
fun validateUser(user: User) { /* 验证逻辑 */ }
fun sendNotification(user: User) { /* 发送通知 */ }
}
// ✅ 遵循 SRP
class UserRepository {
fun saveUser(user: User) { /* 仅负责数据存储 */ }
}
class UserValidator {
fun validate(user: User) { /* 仅负责验证 */ }
}
class NotificationService {
fun send(user: User) { /* 仅负责通知 */ }
}2. O - 开闭原则 (Open-Closed Principle)
软件实体应对扩展开放，对修改关闭
- 通过添加新代码来扩展功能，而不是修改现有代码
- 常用策略：抽象、接口、继承
Android 示例：
kotlin
// 使用接口实现 OCP
interface Discount {
fun apply(price: Double): Double
}
class RegularDiscount : Discount {
override fun apply(price: Double) = price * 0.9
}
class VIPDiscount : Discount {
override fun apply(price: Double) = price * 0.7
}
class PriceCalculator {
fun calculate(price: Double, discount: Discount) = discount.apply(price)
// 添加新折扣类型时无需修改此方法
}3. L - 里氏替换原则 (Liskov Substitution Principle)
子类应该能够替换其父类而不影响程序的正确性
- 子类不应破坏父类的行为约定
- 保持继承关系的合理性
Android 示例：
kotlin
// ❌ 违反 LSP
open class Rectangle {
open var width: Double = 0.0
open var height: Double = 0.0
}
class Square : Rectangle() {
override var width: Double
get() = super.width
set(value) {
super.width = value
super.height = value // 修改了父类的行为约定
}
}
// ✅ 遵循 LSP
interface Shape {
fun area(): Double
}
class Rectangle : Shape {
var width: Double = 0.0
var height: Double = 0.0
override fun area() = width * height
}
class Square : Shape {
var side: Double = 0.0
override fun area() = side * side
}4. I - 接口隔离原则 (Interface Segregation Principle)
客户端不应被迫依赖其不使用的方法
- 将大接口拆分为更小、更具体的接口
- 避免"胖接口"
Android 示例：
kotlin
// ❌ 违反 ISP
interface Worker {
fun work()
fun eat()
fun sleep()
}
// ✅ 遵循 ISP
interface Workable {
fun work()
}
interface Eatable {
fun eat()
}
class Robot : Workable {
override fun work() { /* 机器人只工作 */ }
}
class Human : Workable, Eatable {
override fun work() { /* 工作 */ }
override fun eat() { /* 吃饭 */ }
}5. D - 依赖倒置原则 (Dependency Inversion Principle)
高层模块不应依赖低层模块，两者都应依赖抽象
- 高层模块不应直接依赖低层模块，两者都应依赖抽象
- 抽象不应依赖细节，细节应依赖抽象
Android 示例：
kotlin
// ❌ 违反 DIP
class LocalDataSource {
fun getData(): String = "Local data"
}
class ViewModel {
private val dataSource = LocalDataSource() // 直接依赖具体实现
fun loadData() = dataSource.getData()
}
// ✅ 遵循 DIP
interface DataSource {
fun getData(): String
}
class LocalDataSource : DataSource {
override fun getData() = "Local data"
}
class RemoteDataSource : DataSource {
override fun getData() = "Remote data"
}
class ViewModel(private val dataSource: DataSource) { // 依赖抽象
fun loadData() = dataSource.getData()
}
// 使用依赖注入
val viewModel = ViewModel(LocalDataSource()) // 或 RemoteDataSource在 Android Clean Architecture 中的应用
在 Clean Architecture 中，SOLID 原则体现在各个层次：
- 数据层：Repository 模式依赖 DataSource 接口
- 领域层：UseCase/Interactor 实现单一职责
- 表现层：ViewModel 依赖 UseCase 接口
kotlin
// Clean Architecture + SOLID 示例
interface UserRepository { // 抽象接口
suspend fun getUser(id: String): User
}
class UserRepositoryImpl @Inject constructor(
private val localDataSource: LocalDataSource,
private val remoteDataSource: RemoteDataSource
) : UserRepository { // 具体实现
override suspend fun getUser(id: String): User {
// 实现细节
}
}
class GetUserUseCase @Inject constructor(
private val repository: UserRepository // 依赖抽象
) {
suspend operator fun invoke(id: String): User {
return repository.getUser(id)
}
}
@HiltViewModel
class UserViewModel @Inject constructor(
private val getUserUseCase: GetUserUseCase
) : ViewModel() {
// ViewModel 依赖 UseCase
}实际应用建议
-
从 SRP 和 DIP 开始：这两个原则对代码质量提升最明显
-
合理使用接口：但不是每个类都需要接口，避免过度设计
-
结合 Android 特性：
- 使用 Dagger/Hilt 实现依赖注入
- 利用 Kotlin 的接口默认实现
- 配合 Jetpack 组件（ViewModel、LiveData）
-
保持平衡：不要为了原则而原则，实用性和可维护性才是最终目标
SOLID 原则在 Android 开发中不是僵化的教条，而是帮助开发者写出更好代码的指导方针。结合 Clean Architecture，可以显著提高应用的可测试性、可维护性和可扩展性。