Class

带构造函数的类

/**
 * 带构造函数的类
 */
class Robot(val name: String) {
    fun greetHuman() {
        println("Hello human, my name is $name")
    }

    fun walk() {
        println("I'm walking")
    }
}

// 类对象使用
val aiRobot: Robot = Robot("AiRobot")
aiRobot.greetHuman()
aiRobot.walk()

主构造函数

主构造函数是定义和初始化类属性的主要方式。

/**
 * class classname(parameter1: Type, parameter2: Type) {}
 */
class Robot(val name: String) {
    fun greetHuman() {
        println("Hello human, my name is $name")
    }

    fun walk() {
        println("I'm walking")
    }
}

继承

open 关键字

在 Kotlin 中，类和方法默认都是 final 的，类不能被继承，方法不能被重写 override。

为了让类或方法可以被继承、被重写，必须加上 open 关键字。

代码示例

// 基类
open class GeneralRobot(val name: String) {
    fun greetHuman() {
        println("Hello human, my name is $name")
    }
    fun walk() {
        println("I'm walking")
    }
}

// FiringRobot 继承 GeneralRobot
class FiringRobot(name: String): GeneralRobot(name) {
    fun fire() {
        println("Pew pew pew")
    }
}

init

init 是 初始化代码块。当 类被创建（实例化）时，会自动执行里面的代码。主要用途：

• 初始化属性
• 做对象创建时需要执行的逻辑
• 检查参数
• 打印日志
• 配置初始状态

基本用法

class GeneralRobot(val name: String, val modelYear: String) {
    // init 代码块
    init {
        println("A new robot named $name has been created")
    }

    fun greetHuman() {
        println("Hello human, my name is $name")
    }

    fun walk() {
        println("I'm walking")
    }
}

// 创建实例
val p = GeneralRobot("Tom", "2222")
// 输出内容
// A new robot named Tom has been created

次要构造器

次要构造器使用 constructor 关键字声明。如果类已经定义了主构造器，那么 所有次要构造器都必须使用 this(...) 调用主构造器。

无主要构造器

在 Kotlin 中，可以定义一个有次要构造器而没有主要构造器的类，如下所示

open class GeneralRobot {
    var name: String
    var modelYear: String

    // 次要构造器
    constructor(name: String, modelYear: String) {
        this.name = name
        this.modelYear = modelYear
    }

    fun greetHuman() {
        println("Hello human, my name is $name")
    }
    fun walk() {
        println("I'm walking")
    }
}

含有主要构造器

含有主要构造器时，必须创建次要构造器，切次要构造器最终必须调用主要构造器。

open class GeneralRobot() {
    var name: String
    var modelYear: String

    // 初始化代码
    init {
        name = ""
        modelYear = ""
    }

    // 次要构造器
    constructor(name: String, modelYear: String): this() {
        this.name = name
        this.modelYear = modelYear
    }
    // 次要构造器
//    constructor(name: String): this() {
//        this.name = name
//        this.modelYear = "Unknown"
//
//    }
    // 等价于
    constructor(name: String): this(name, "Unknown")
}

class FiringRobot: GeneralRobot {
    constructor(name: String, modelYear: String): super(name, modelYear)

    fun fire() {
        println("Firing ......")
    }
}

// 代码的实例
var firingRobot = FiringRobot("hero")
var firingRobot2 = FiringRobot("hero2", "2024")
firingRobot.fire()
firingRobot2.fire()
// 输出内容
// Firing ......
// Firing ......

super 关键字

super 关键字将调用超类或者父类的构造函数来初始化父类的属性。

class FiringRobot: GeneralRobot {
    // 子类调用 Super 方法
    constructor(name: String, modelYear: String): super(name, modelYear)

    fun fire() {
        println("Firing ......")
    }
}

getter & setter

在 Kotlin 中，所有属性都会自动生成 getter 和 setter：

• val 属性：只有 getter（只读）
• var 属性：有 getter 也有 setter

自定义 getter 和 setter

示例代码，如下所示

open class GeneralRobot() {
    var name: String = ""

    var modelYear: String = ""
        get() { // 自定义getter
            println("Getting model year")
            return field // field 是 Kotlin 提供的 幕后字段（backing field）
        }
        set(value) { // 自定义 setter
            println("Setting model year")
            field = value
        }



    // 次要构造器
    constructor(name: String, modelYear: String): this() {
        this.name = name
        this.modelYear = modelYear
    }
    // 次要构造器
    constructor(name: String): this(name, "Unknown")
}

Kotlin 提供 4 种可见性修饰符，用来控制类、方法、属性等的 访问范围：

1. public（默认）: 所有地方可见
2. private: 只有自己可见
3. protected: 自己 + 子类可见
4. internal: 模块内部可见

public

任何地方都可以访问，适用于 类、属性/方法以及顶级函数。

class Person   // 等同于 public class Person

private

用在类的成员上，只能在本类中访问。

class Person {
    private val id = 123   // 只能在本类访问
}

用在顶级函数/属性，仅在当前文件内访问。

// File: A.kt 
// test() 只能在 A.kt 文件中使用。
private fun test() {} 

protected

protected = private + 子类可访问，只能用于类成员。

open class Animal {
    protected fun makeSound() {}
}

class Dog : Animal() {
    fun bark() {
        makeSound() // 子类可以访问
    }
}

internal

同一模块(module)内可访问，不同模块不可访问。

internal class Car

在同一个 module 内都能用，在 module 外不可用。

抽象类

Abstract Class（抽象类） 是 Kotlin 中一种不能被直接实例化、只能被继承的类。它用来描述一类事物的“公共特性”和“抽象行为”，具体的实现由子类完成。

// 使用 abstract 关键字定义
abstract class Animal {
    abstract fun makeSound() // 抽象方法，没有方法体
}
// val a = Animal() // ❌ 错误：抽象类不能被实例化

示例代码

abstract class Animal(val name: String) {
    // 抽象函数（必须重写）
    abstract fun makeSound()

    // 普通函数（子类可以直接用）
    fun introduce() {
        println("I am $name")
    }
}

// 子类
class Dog(name: String) : Animal(name) {
    override fun makeSound() {
        println("Bark")
    }
}

// 使用方法
val dog = Dog("Buddy")
dog.introduce()   // I am Buddy
dog.makeSound()   // Bark

抽象属性的代码示例

abstract class Shape {
    abstract val area: Double
}

class Circle(val radius: Double) : Shape() {
    override val area = 3.14 * radius * radius
}

接口

在 Kotlin 中，interface（接口）是一种用来定义行为规范的结构，它只描述“类应该做什么”，不关心“怎么实现”。类可以实现一个或多个接口。

interface Drivable {
    // 抽象方法
    fun drive()    

    // 默认实现
    fun stop() {    
        println("Stopping the vehicle.")
    }
}

类实现接口

class Car: Drivable {
    override fun drive() {
        println("Car is driving.")
    }
}

接口中的属性

interface Animal {
    val name: String       // 抽象属性（必须由实现类提供）
}

实现类

class Dog(override val name: String) : Animal