编辑“︁Kotlin嵌套类”︁

= Kotlin嵌套类 =

== 介绍 ==
在Kotlin中，'''嵌套类（Nested Class）'''是指定义在另一个类内部的类。嵌套类提供了一种逻辑分组的方式，可以将紧密相关的类组织在一起，同时控制其访问范围。Kotlin中的嵌套类默认是静态的（与Java不同），这意味着它不能直接访问外部类的成员变量和方法，除非明确标记为'''inner'''。

Kotlin支持两种主要的嵌套类：
* '''普通嵌套类'''（静态嵌套类）
* '''内部类'''（使用`inner`关键字，可以访问外部类成员）

== 普通嵌套类 ==
普通嵌套类在Kotlin中默认是静态的，它不能直接访问外部类的实例成员。

=== 语法 ===
<syntaxhighlight lang="kotlin">
class Outer {
    private val outerProperty = "Outer Property"
    
    class Nested {
        fun printMessage() {
            println("This is a nested class")
            // 不能访问 outerProperty
        }
    }
}
</syntaxhighlight>

=== 使用示例 ===
<syntaxhighlight lang="kotlin">
fun main() {
    val nested = Outer.Nested()
    nested.printMessage()
}
</syntaxhighlight>

'''输出：'''
<pre>
This is a nested class
</pre>

== 内部类 ==
使用`inner`关键字声明的嵌套类可以访问外部类的成员，因为它持有外部类的引用。

=== 语法 ===
<syntaxhighlight lang="kotlin">
class Outer {
    private val outerProperty = "Outer Property"
    
    inner class Inner {
        fun printMessage() {
            println("Inner class accessing: $outerProperty")
        }
    }
}
</syntaxhighlight>

=== 使用示例 ===
<syntaxhighlight lang="kotlin">
fun main() {
    val outer = Outer()
    val inner = outer.Inner()
    inner.printMessage()
}
</syntaxhighlight>

'''输出：'''
<pre>
Inner class accessing: Outer Property
</pre>

== 嵌套类 vs 内部类 ==
以下是两者的主要区别：

<mermaid>
classDiagram
    class Outer {
        +outerProperty
        class Nested
        class Inner
    }
    note for Outer "Nested: 不能访问outerProperty\nInner: 可以访问outerProperty"
</mermaid>

{| class="wikitable"
|-
! 特性 !! 普通嵌套类 !! 内部类
|-
| 关键字 | 无（默认） | `inner`
|-
| 访问外部类成员 | 否 | 是
|-
| 内存占用 | 无外部类引用 | 持有外部类引用
|-
| 实例化方式 | `Outer.Nested()` | `outer.Inner()`
|}

== 实际应用场景 ==
=== 场景1：UI组件中的嵌套结构 ===
在Android开发中，`RecyclerView`的`Adapter`通常使用嵌套类来组织`ViewHolder`：

<syntaxhighlight lang="kotlin">
class MyAdapter : RecyclerView.Adapter<MyAdapter.ViewHolder>() {
    
    class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
        // ViewHolder实现
    }

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {
        // 创建ViewHolder
    }
}
</syntaxhighlight>

=== 场景2：构建器模式 ===
嵌套类常用于实现构建器模式：

<syntaxhighlight lang="kotlin">
class Dialog {
    private var title: String = ""
    private var message: String = ""
    
    class Builder {
        private val dialog = Dialog()
        
        fun setTitle(title: String): Builder {
            dialog.title = title
            return this
        }
        
        fun build(): Dialog = dialog
    }
}
</syntaxhighlight>

== 高级主题 ==
=== 匿名内部类 ===
Kotlin使用'''对象表达式'''创建匿名内部类：

<syntaxhighlight lang="kotlin">
interface OnClickListener {
    fun onClick()
}

fun setOnClickListener(listener: OnClickListener) {
    listener.onClick()
}

fun main() {
    setOnClickListener(object : OnClickListener {
        override fun onClick() {
            println("Button clicked!")
        }
    })
}
</syntaxhighlight>

=== 嵌套类中的访问限制 ===
嵌套类可以访问外部类的私有成员，但需要遵循可见性规则：

<syntaxhighlight lang="kotlin">
class Outer {
    private val secret = 42
    
    inner class Inner {
        fun revealSecret() = secret
    }
    
    class Nested {
        // fun revealSecret() = secret // 编译错误：不能访问
    }
}
</syntaxhighlight>

== 数学表示 ==
从作用域角度来看，嵌套类的作用域可以表示为：

<math>
\text{Scope}_{\text{Nested}} \subseteq \text{Scope}_{\text{Outer}}
</math>

对于内部类，还存在一个隐式引用：

<math>
\text{Inner} \rightarrow \text{Outer}
</math>

== 最佳实践 ==
* 当不需要访问外部类成员时，使用普通嵌套类（更高效）
* 需要访问外部状态时使用`inner`类
* 避免过度嵌套（一般不超过2层）
* 考虑使用包级函数或单独类替代深层嵌套

== 常见问题 ==
'''Q: Kotlin的嵌套类与Java有何不同？'''
A: 主要区别在于：
* Kotlin的普通嵌套类默认是静态的（相当于Java的static nested class）
* 需要显式使用`inner`关键字创建非静态嵌套类（相当于Java的普通内部类）

'''Q: 嵌套类会影响性能吗？'''
A: 
* 普通嵌套类几乎没有额外开销
* 内部类会持有外部类引用，可能影响内存管理

== 总结 ==
Kotlin的嵌套类提供了良好的封装机制，通过：
* 普通嵌套类实现逻辑分组
* 内部类访问外部状态
* 清晰的语法区分两种类型

正确使用嵌套类可以使代码更加模块化和可维护，但需要注意选择适当的类型以避免不必要的内存开销。

[[Category:编程语言]]
[[Category:Kotlin]]
[[Category:Kotlin面向对象编程]]