面向对象 - 《Kotlin基础》 - 严富坤的知识库专栏(yanfukun.com)

基本概念
- 类与对象
类与构造函数
- 主构造函数
- 次构造函数
类的成员
- 属性
- 方法
继承与多态
- 继承
- 多态
接口与抽象类
- 接口
- 抽象类
数据类
密封类
扩展函数
对象表达式与对象声明
- 对象表达式
- 对象声明
委托属性
伴生对象
枚举类
实践示例与应用
面向对象编程的最佳实践
总结

面向对象编程（OOP）是一种广泛使用的编程范式，通过类和对象来组织代码。Kotlin 作为一门现代编程语言，充分支持面向对象编程，并且在传统 OOP 的基础上进行了改进和扩展。本文将详细介绍 Kotlin 中的面向对象编程，包括其基本概念、类与对象、继承与多态、接口与抽象类、数据类、密封类、扩展函数、对象表达式与对象声明、委托属性、伴生对象和枚举类。通过丰富的示例和深入的解释，帮助读者全面掌握 Kotlin 中的面向对象编程技术。

基本概念

面向对象编程的核心概念包括类、对象、封装、继承和多态。

类与对象

类是面向对象编程的基本构造，定义了对象的属性和行为。对象是类的实例，表示具体的实体。

class Person(val name: String, var age: Int) {
    fun introduce() {
        println("Hello, my name is $name and I am $age years old.")
    }
}
val person = Person("Alice", 30)
person.introduce() // 输出: Hello, my name is Alice and I am 30 years old.

类与构造函数

主构造函数

Kotlin 类可以有一个主构造函数，用于初始化类的属性。

class Person(val name: String, var age: Int) {
    init {
        println("Person created: $name, $age")
    }
}
val person = Person("Bob", 25) // 输出: Person created: Bob, 25

次构造函数

类可以有一个或多个次构造函数，用于提供不同的初始化方式。

class Person(val name: String) {
    var age: Int = 0
    constructor(name: String, age: Int) : this(name) {
        this.age = age
    }
}
val person = Person("Charlie", 20)
println(person.age) // 输出: 20

类的成员

类的成员包括属性、方法、嵌套类和对象声明。

属性

类的属性可以是可变（var）或不可变（val）。

class Car(val brand: String, var speed: Int)
val car = Car("Toyota", 100)
println(car.brand) // 输出: Toyota
car.speed = 120
println(car.speed) // 输出: 120

方法

类的方法定义了类的行为。

class Calculator {
    fun add(a: Int, b: Int): Int {
        return a + b
    }
}
val calculator = Calculator()
println(calculator.add(3, 4)) // 输出: 7

继承与多态

继承

Kotlin 使用 open 关键字标记可以被继承的类，使用 override 关键字标记重写的方法。

open class Animal {
    open fun sound() {
        println("Animal sound")
    }
}
class Dog : Animal() {
    override fun sound() {
        println("Bark")
    }
}
val dog = Dog()
dog.sound() // 输出: Bark

多态

多态是指同一个函数在不同的上下文中表现出不同的行为。

fun makeSound(animal: Animal) {
    animal.sound()
}
makeSound(Dog()) // 输出: Bark

接口与抽象类

接口

接口定义了一组方法，但不提供实现。类可以实现多个接口。

interface Drivable {
    fun drive()
}
class Car : Drivable {
    override fun drive() {
        println("Driving a car")
    }
}
val car = Car()
car.drive() // 输出: Driving a car

抽象类

抽象类可以包含抽象方法和非抽象方法。抽象类不能被实例化。

abstract class Shape {
    abstract fun area(): Double
}
class Circle(val radius: Double) : Shape() {
    override fun area(): Double {
        return Math.PI * radius * radius
    }
}
val circle = Circle(5.0)
println(circle.area()) // 输出: 78.53981633974483

数据类

数据类用于存储数据，Kotlin 自动为数据类提供 equals、hashCode、toString、copy 和 componentN 方法。

data class User(val name: String, val age: Int)
val user1 = User("Alice", 30)
val user2 = user1.copy(name = "Bob")
println(user1) // 输出: User(name=Alice, age=30)
println(user2) // 输出: User(name=Bob, age=30)

密封类

密封类用于表示受限的类层次结构，可以有多个子类，但所有子类必须在密封类的内部定义。

sealed class Expr
data class Const(val number: Double) : Expr()
data class Sum(val e1: Expr, val e2: Expr) : Expr()
object NotANumber : Expr()
fun eval(expr: Expr): Double = when (expr) {
    is Const -> expr.number
    is Sum -> eval(expr.e1) + eval(expr.e2)
    NotANumber -> Double.NaN
}
println(eval(Sum(Const(1.0), Const(2.0)))) // 输出: 3.0

扩展函数

扩展函数允许我们为已有类添加新的函数，而无需继承该类或使用装饰器模式。

fun String.isPalindrome(): Boolean {
    return this == this.reversed()
}
println("madam".isPalindrome()) // 输出: true

对象表达式与对象声明

对象表达式

对象表达式用于创建匿名对象。

val obj = object {
    val x = 10
    val y = 20
}
println(obj.x + obj.y) // 输出: 30

对象声明

对象声明用于创建单例对象。

object Singleton {
    fun show() {
        println("This is a singleton object")
    }
}
Singleton.show() // 输出: This is a singleton object

委托属性

Kotlin 提供了委托属性，用于将属性的 get 和 set 操作委托给另一个对象。

class Delegate {
    operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
        return "$thisRef, thank you for delegating '${property.name}' to me!"
    }
    operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
        println("$value has been assigned to '${property.name}' in $thisRef.")
    }
}
class Example {
    var p: String by Delegate()
}
val example = Example()
example.p = "Hello"
println(example.p) // 输出: Hello has been assigned to 'p' in Example@1f32e575. Example@1f32e575, thank you for delegating 'p' to me!

伴生对象

伴生对象是与类关联的单例对象，可以包含工厂方法或静态成员。

class MyClass {
    companion object {
        fun create(): MyClass = MyClass()
    }
}
val myClass = MyClass.create()

枚举类

枚举类用于表示固定集合的常量。

enum class Direction {
    NORTH, SOUTH, EAST, WEST
}
val direction = Direction.NORTH
println(direction) // 输出: NORTH

实践示例与应用

示例一：图书管理系统

class Book(val title: String, val author: String, var available: Boolean)
class Library {
    private val books = mutableListOf<Book>()
    fun addBook(book: Book) {
        books.add(book)
    }
    fun borrowBook(title: String): Book? {
        val book = books.find { it.title == title && it.available }
        book?.available = false
        return book
    }
    fun returnBook(book: Book) {
        book.available = true
    }
    fun listAvailableBooks() {
        books.filter { it.available }.forEach { println("${it.title} by ${it.author}") }
    }
}
fun main() {
    val library = Library()
    library.addBook(Book("Kotlin Programming", "John Doe", true))
    library.addBook(Book("Effective Java", "Joshua Bloch", true))
    println("Available books:")
    library.listAvailableBooks()
    val borrowedBook = library.borrowBook("Kotlin Programming")
    println("Borrowed book: ${borrowedBook?.title}")
    println("Available books after borrowing:")
    library.listAvailableBooks()
    borrowedBook?.let { library.returnBook(it) }
    println("Available books after returning:")
    library.listAvailableBooks()
}

示例二：员工管理系统

open class Employee(val name: String, val id: Int) {
    open fun work() {
        println("$name is working")
    }
}
class Manager(name
: String, id: Int) : Employee(name, id) {
    override fun work() {
        println("$name is managing")
    }
}
class Developer(name: String, id: Int) : Employee(name, id) {
    override fun work() {
        println("$name is developing")
    }
}
class Company {
    private val employees = mutableListOf<Employee>()
    fun addEmployee(employee: Employee) {
        employees.add(employee)
    }
    fun showEmployees() {
        employees.forEach { it.work() }
    }
}
fun main() {
    val company = Company()
    company.addEmployee(Manager("Alice", 1))
    company.addEmployee(Developer("Bob", 2))
    company.showEmployees()
}

示例三：在线购物系统

abstract class Product(val name: String, val price: Double)
class Electronics(name: String, price: Double) : Product(name, price)
class Clothing(name: String, price: Double, val size: String) : Product(name, price)
class Cart {
    private val items = mutableListOf<Product>()
    fun addItem(product: Product) {
        items.add(product)
    }
    fun removeItem(product: Product) {
        items.remove(product)
    }
    fun calculateTotal(): Double {
        return items.sumOf { it.price }
    }
    fun showItems() {
        items.forEach { println("${it.name}: $${it.price}") }
    }
}
fun main() {
    val cart = Cart()
    cart.addItem(Electronics("Laptop", 1200.0))
    cart.addItem(Clothing("T-Shirt", 25.0, "M"))
    println("Items in cart:")
    cart.showItems()
    println("Total price: $${cart.calculateTotal()}")
}

面向对象编程的最佳实践

1. 遵循单一责任原则（SRP）

每个类应该只有一个责任，确保类的高内聚和低耦合。

class Book(val title: String, val author: String)
class Library {
    private val books = mutableListOf<Book>()
    fun addBook(book: Book) {
        books.add(book)
    }
    fun listBooks() {
        books.forEach { println(it.title) }
    }
}

2. 使用接口和抽象类定义契约

通过接口和抽象类定义行为契约，提高代码的可扩展性和灵活性。

interface Drivable {
    fun drive()
}
abstract class Vehicle : Drivable {
    abstract val speed: Int
}
class Car(override val speed: Int) : Vehicle() {
    override fun drive() {
        println("Driving at $speed km/h")
    }
}

3. 优先使用数据类

数据类用于表示纯粹的数据结构，Kotlin 自动提供 equals、hashCode、toString 和 copy 方法。

data class User(val name: String, val age: Int)

4. 使用扩展函数

扩展函数可以为已有类添加新功能，而无需修改类的源码或使用继承。

fun String.isPalindrome(): Boolean {
    return this == this.reversed()
}

5. 使用对象声明实现单例模式

对象声明用于创建单例对象，确保只有一个实例。

object Singleton {
    fun show() {
        println("This is a singleton object")
    }
}

总结

Kotlin 提供了强大的面向对象编程支持，通过类和对象的定义与使用，可以组织和管理复杂的代码结构。本文详细介绍了 Kotlin 中面向对象编程的基本概念、类与对象、构造函数、类的成员、继承与多态、接口与抽象类、数据类、密封类、扩展函数、对象表达式与对象声明、委托属性、伴生对象和枚举类，并通过多个实践示例展示了如何在实际项目中应用这些概念。

通过对 Kotlin 中面向对象编程的全面掌握，开发者可以编写出高质量、易维护、可扩展的代码。希望本文能够帮助读者深入理解 Kotlin 的面向对象编程技术，并在实际开发中灵活运用这一强大的工具。