Kotlin Academy · 课时

内部类

Q: 「内部类」这节课中我会学到什么？

访问外部作用域 你通过在浏览器中直接运行的动手代码来练习 Kotlin Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

访问外部作用域

内部类 是 CoddyKit 上的免费 Kotlin Academy 课时。这是第 2 节课，共 4 节。你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。这是 Kotlin Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Kotlin Academy 课程共包含 4 节课。

inner 关键字

将嵌套类标记为 inner 后，它会获得一个指向外部实例的引用，因此可以访问外部类的成员。

class Outer {
    val msg = "Hello"
    inner class Inner {
        fun show() = msg
    }
}

fun main() {
    println(Outer().Inner().show())
}

创建内部类实例

由于内部类需要外部实例，因此您要从某个外部实例创建它：Outer().Inner()。

class Engine {
    val power = 100
    inner class Turbo {
        fun boosted() = power * 2
    }
}

fun main() {
    println(Engine().Turbo().boosted())
}

访问外部属性

内部类可以直接读取和使用外部属性，就像这些属性属于它自己一样。

class Counter {
    var count = 0
    inner class Stepper {
        fun step() { count++ }
    }
}

fun main() {
    val c = Counter()
    c.Stepper().step()
    println(c.count)
}

调用外部方法

内部类也可以调用封装它的实例上的方法。

class Printer {
    fun line(s: String) = println(s)
    inner class Job {
        fun run() = line("printing")
    }
}

fun main() {
    Printer().Job().run()
}

this@Outer 语法

若要显式引用外部实例（例如名称发生冲突时），请使用 this@Outer。

class Outer {
    val value = 10
    inner class Inner {
        val value = 20
        fun outerValue() = this@Outer.value
    }
}

fun main() {
    println(Outer().Inner().outerValue())
}

为什么使用 inner？

当嵌套类型确实需要与某个特定的外部实例协作并共享其状态时，请使用 inner。

class Wallet {
    var balance = 50
    inner class Transaction(val amount: Int) {
        fun apply() { balance += amount }
    }
}

fun main() {
    val w = Wallet()
    w.Transaction(25).apply()
    println(w.balance)
}

每个内部类实例都绑定到一个外部实例

内部类实例会绑定到创建它的那个确切外部实例；对该对象所做的更改也会反映到内部类实例中。

class Box(var size: Int) {
    inner class Resizer {
        fun grow() { size += 1 }
    }
}

fun main() {
    val b = Box(3)
    b.Resizer().grow()
    println(b.size)
}

内部类与嵌套类

没有 inner 时，嵌套类是相互隔离的；有了 inner 后，它会捕获外部实例。这一关键字带来的就是全部区别。

class Outer {
    val tag = "X"
    inner class A { fun get() = tag }
}

fun main() {
    println(Outer().A().get())
}

内存提示

由于内部类实例会让外部实例保持存活，请谨慎处理长期存在的内部类对象，以免无意中一直持有外部对象。

class Service {
    val id = 1
    inner class Worker { fun who() = id }
}

fun main() {
    println(Service().Worker().who())
}

一个实际的迭代器

内部类非常适合用于遍历其封装集合状态的迭代器。

class Stack {
    private val items = mutableListOf(1, 2, 3)
    inner class Reader {
        fun all() = items.joinToString()
    }
}

fun main() {
    println(Stack().Reader().all())
}

组合这些概念

内部类可以使用外部状态，并通过 this@Outer 消除歧义。

class Outer {
    val n = 5
    inner class Inner {
        fun doubled() = this@Outer.n * 2
    }
}

fun main() {
    println(Outer().Inner().doubled())
}

快速检查

请测试您对内部类的理解。

回顾

您了解了内部类：

inner 授予对外部实例及其成员的访问权限。
通过外部实例创建：Outer().Inner()。
使用 this@Outer 引用封装它的实例。
内部类实例会让外部实例保持存活。

class Outer {
    val v = 1
    inner class Inner { fun get() = v }
}

fun main() {
    println(Outer().Inner().get())
}

常见问题解答

「内部类」课时是免费的吗？

是的 — 「内部类」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Kotlin Academy 课程的其余内容，请升级到 CoddyKit PRO。 Kotlin Academy 课程共包含 4 节课。

「内部类」这节课中我会学到什么？

访问外部作用域你通过在浏览器中直接运行的动手代码来练习 Kotlin Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Kotlin Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Kotlin Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。这是第 2 节课，共 4 节。

「内部类」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Kotlin Academy 课中编写并运行代码吗？

能。每节 Kotlin Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

← 返回 Kotlin Academy