Scala - 嵌套类

本章将带您了解 Scala 编程中的嵌套类概念。嵌套类是在其他类内部定义的类。这些类对于逻辑分组仅在一个地方使用的类非常有用。因此，嵌套类可以提高封装性并减少命名空间污染。

嵌套类

嵌套类是在其他类内部定义的类。这些内部类可以访问外部类的成员。嵌套类用于建模一个类逻辑上属于另一个类内部的关系。

嵌套类是在另一个类内部定义的类。内部类可以访问外部类的成员（包括字段和方法）。

语法

嵌套类的语法如下 -

class OuterClass {
  class InnerClass {
    // 类体
  }
  // 外部类体
}

示例

以下示例展示了 Scala 编程中的一个简单嵌套类。

class Outer {
  val outerValue = "Outer Value"

  class Inner {
    def display(): Unit = {
      println(s"Accessing from Inner Class: $outerValue")
    }
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val outer = new Outer
    val inner = new outer.Inner
    inner.display()
  }
}

将上述程序保存为 Demo.scala。使用以下命令编译和执行该程序。

命令

>scalac Demo.scala
>scala Demo

输出

Accessing from Inner Class: Outer Value

在示例中，Outer 类包含一个嵌套类 Inner。Inner 类有一个方法 display，它访问了 Outer 类的成员。Demo 对象创建了 Outer 和 Inner 类的实例，并调用 display 方法。

内部类与外部类实例

外部类的每个实例都有自己的内部类实例。内部类实例与创建它的外部类实例绑定。

语法

class OuterClass {
  class InnerClass {
    // 类体
  }
  // 外部类体
}

示例

以下示例展示了内部类实例如何与外部类实例绑定。

class Outer(val outerValue: String) {
  class Inner {
    def display(): Unit = {
      println(s"Outer Value: $outerValue")
    }
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val outer1 = new Outer("First Outer")
    val outer2 = new Outer("Second Outer")

    val inner1 = new outer1.Inner
    val inner2 = new outer2.Inner

    inner1.display()
    inner2.display()
  }
}

将上述程序保存为 Demo.scala。使用以下命令编译和执行该程序。

命令

>scalac Demo.scala
>scala Demo

输出

Outer Value: First Outer
Outer Value: Second Outer

在示例中，每个 Outer 类实例都有自己的 Inner 类实例。每个 Inner 类实例的 display 方法访问对应 Outer 类实例的 outerValue。

具有私有成员的嵌套类

嵌套类可以访问外部类的私有成员。因此，具有必要的功能的封装。

语法

class OuterClass {
  private val outerValue = "Outer Value"

  class InnerClass {
    def display(): Unit = {
      println(s"Accessing private member: $outerValue")
    }
  }
}

示例

以下示例展示了一个嵌套类访问外部类私有成员的情况。

class Outer {
  private val outerValue = "Outer Value"

  class Inner {
    def display(): Unit = {
      println(s"Accessing private member: $outerValue")
    }
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val outer = new Outer
    val inner = new outer.Inner
    inner.display()
  }
}

将上述程序保存为 Demo.scala。使用以下命令来编译和执行该程序。

命令

>scalac Demo.scala
>scala Demo

输出

Accessing private member: Outer Value

在示例中，Outer 类有一个私有成员 outerValue。嵌套的 Inner 类可以访问这个私有成员并在它的 display 方法中使用它。Demo 对象创建了 Outer 和 Inner 类的实例，并调用 display 方法。

嵌套对象

你也可以在类中定义对象。嵌套对象可以用来封装相关的功能。这为外部类提供了工厂方法。

语法

class OuterClass {
  object InnerObject {
    // 对象体
  }
  // 外部类体
}

示例

以下示例演示了 Scala 编程中的嵌套对象。

class Outer {
  object Inner {
    def greet(): Unit = {
      println("Hello from Inner Object")
    }
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val outer = new Outer
    outer.Inner.greet()
  }
}

将上述程序保存为 Demo.scala。使用以下命令来编译和执行该程序。

命令

>scalac Demo.scala
>scala Demo

输出

Hello from Inner Object

在示例中，Outer 类包含一个嵌套对象 Inner。Inner 对象有一个方法 greet，它打印一条消息。Demo 对象创建了 Outer 类的实例，并访问嵌套的 Inner 对象来调用它的 greet 方法。

Scala 嵌套类总结

• Scala 中的嵌套类是在其他类内部定义的类。因此，可以实现逻辑分组和增强封装。
• 外部类的每个实例都有其自己的嵌套内部类实例。因此，这两者之间创建了强烈的关联。
• 嵌套类可以访问外部类的私有成员。因此，在保持功能的同时提供了紧密的封装。
• 也可以在类中定义嵌套对象。因此，可以封装相关功能并提供工厂方法。