Scala面向对象编程：内部类、私有成员和对象

1. 内部类和私有成员访问

类名：Student1 和 Book

知识点：

• 内部类的定义：在外部类中定义内部类。
• 内部类实例化：通过外部类实例来创建内部类实例。

参考点：

• 如何定义一个内部类并实例化它。

文章：

在Scala中，内部类可以访问外部类的成员，包括私有成员。这使得内部类成为操作外部类私有成员的理想选择。

class Student1 {
  val age = 18

  def say(): Unit = {}

  // 内部类Book定义
  class Book {
    var bookName = "Scala程序设计"
  }
}

object Test20_1 {
  def main(args: Array[String]): Unit = {
    val s1 = new Student1()
    val book1 = new s1.Book() // 实例化内部类Book
    println(book1.bookName) // 输出：Scala程序设计
  }
}

2. 私有成员和内部类操作

类名：Car1 和 Engine

知识点：

• 私有成员的定义：使用private关键字定义私有成员。
• 内部类操作私有成员：内部类可以访问和操作外部类的私有成员。

参考点：

• 如何定义私有成员以及如何通过内部类操作这些私有成员。

文章：

在Scala中，私有成员只能在定义它们的类内部访问。通过定义内部类，我们可以在类的封闭范围内操作这些私有成员。

class Car1 {
  private var speed = 0 // 私有成员，表示速度
  val color = "red"

  // 内部类Engine定义
  class Engine(var maxSpeed: Int) {
    def acc(): Unit = {
      speed += 10
      if (speed > maxSpeed) {
        speed = maxSpeed
      }
      println(s"speed: $speed")
    }

    def sub(): Unit = {
      speed -= 10
    }
  }

  override def toString: String = {
    s"当前的速度是 $speed"
  }
}

object Test20_2 {
  def main(args: Array[String]): Unit = {
    val c1 = new Car1()
    val engine = new c1.Engine(120) // 实例化内部类Engine
    engine.sub()
    engine.sub()
    engine.sub()
    println(c1) // 输出：当前的速度是 70
    engine.sub()
    println(c1) // 输出：当前的速度是 40
  }
}

3. 对象和方法

类名：Car3 和 util

知识点：

• 对象的定义：使用object关键字定义单例对象。
• 对象中的方法：在对象中定义方法。

参考点：

• 如何定义一个对象并其中的方法。

文章：

在Scala中，对象是一种单例类型，它可以包含方法和属性。对象的方法可以访问类的成员。

class Car3(var r: Double) {

  // 对象util定义
  object util {
    val PI = 3.14

    def getArea(): Unit = {
      PI * r * r
    }

    def getL(): Double = {
      2 * PI * r
    }
  }
}

object Test20_3 {
  def main(args: Array[String]): Unit = {
    val car = new Car3(12)
    val res = car.util.getL() // 调用对象util中的方法
    println(res) // 输出：75.36
  }
}

完成代码的注释!!!

// Student1类定义
class Student1 {
  val age = 18
  def say(): Unit = {}

  // 内部类Book定义，可以访问外部类的成员
  class Book {
    var bookName = "Scala程序设计"
  }
}

// Test20_1对象定义，用于测试Student1类的内部类
object Test20_1 {
  def main(args: Array[String]): Unit = {
    val s1 = new Student1()
    val book1 = new s1.Book() // 实例化Student1的内部类Book
    println(book1.bookName) // 输出：Scala程序设计
  }
}

// Car1类定义，包含私有成员和内部类Engine
class Car1 {
  // 私有成员speed，表示速度
  private var speed = 0
  val color = "red"

  // 内部类Engine定义，可以访问和操作外部类的私有成员
  class Engine(var maxSpeed: Int) {
    def acc(): Unit = {
      speed += 10
      if (speed > maxSpeed) {
        speed = maxSpeed
      }
      println(s"speed: $speed")
    }

    def sub(): Unit = {
      speed -= 10
    }
  }

  override def toString: String = {
    s"当前的速度是 $speed"
  }
}

// Test20_2对象定义，用于测试Car1类的内部类Engine
object Test20_2 {
  def main(args: Array[String]): Unit = {
    val c1 = new Car1()
    val engine = new c1.Engine(120) // 实例化Car1的内部类Engine
    engine.sub()
    engine.sub()
    engine.sub()
    println(c1) // 输出：当前的速度是 70
    engine.sub()
    println(c1) // 输出：当前的速度是 40
  }
}

// Car3类定义，包含对象util
class Car3(var r: Double) {
  // 对象util定义，包含方法和属性
  object util {
    val PI = 3.14

    def getArea(): Unit = {
      PI * r * r
    }

    def getL(): Double = {
      2 * PI * r
    }
  }
}

// Test20_3对象定义，用于测试Car3类的对象util
object Test20_3 {
  def main(args: Array[String]): Unit = {
    val car = new Car3(12)
    val res = car.util.getL() // 调用对象util中的方法
    println(res) // 输出：75.36
  }
}

通过以上示例，我们可以看到Scala中内部类、私有成员和对象的定义和使用。这些概念是面向对象编程的重要组成部分，有助于组织代码和封装数据。