Scala学习笔记6: 类

第六章 类

在Scala中, 类用于创建对象的蓝图;

类可以包含方法、值、变量、类型、对象和特质等成员;

类名应该以大写字母开头, 可以包含构造函数、主题和方法等

可以使用class关键字定义类, 并使用new关键字实例化类;

1- 简单类和无参方法

1. 定义简单类: 使用关键字class 定义一个简单类:

  // 定义一个简单的类
  class Person {
    // 类体
    def greet(): Unit = {
      println("Hello, world!")
    }
  }

  // 创建类的实例
  val person = new Person()
  person.greet() // 调用类中的方法 输出 "Hello, world!"

  // 定义一个简单的Point类
  class Point(val x: Int, val y: Int) {
    // 类体: 定义一个方法，返回一个Point对象
    def move(dx: Int, dy: Int): Point = {
      new Point(x + dx, y + dy)
    }

    override def toString: String = {
      s"($x, $y)"
    }
  }

    // 创建一个Point类的实例
    val p = new Point(1, 2)
    println(p) // 输出: (1,2)
    println(p.x) // 输出: 1
    println(p.move(2, 3)) // 输出: (3,5)
    println(p.move(2, 3).move(1, 2)) // 输出: (4,7)

2. 无参方法: 在Scala中, 你可以定义不带参数的方法; 方法可以包含方法体和返回类型;

  // 无参方法
  class Calculator {
    def add(): Int = {
      val a = 10
      val b = 20
      a + b
    }
  }
	
	// 创建类的实例
    val calculator = new Calculator()
    val result = calculator.add()
    println(result) // 输出: 30

2- 带有getter和setter的属性

在Scala中, 你可以使用带有getter 和 setter 的属性来定义类的成员变量;

这些属性允许你控制对类成员的访问和修改;

  class Person {
  // 私有成员变量, 带有 getter 和 setter 方法
    private var _name: String = "Alice"

    // getter方法
    def name: String = _name

    // setter方法
    def name_=(newName: String): Unit = {
      if (newName.nonEmpty) {
        _name = newName
      }
    }
  }

    // 创建Person类的示例 对象
    val person = new Person()

    // 使用getter获取属性值
    println(person.name) // 输出: Alice

    // 使用setter设置属性值
    person.name = "Bob"
    println(person.name) // 输出: Bob

    // 尝试设置空字符串, 不会修改属性值
    person.name = ""
    println(person.name) // 输出: Bob

上面示例中, 定义了一个 Person 类, 其中 _name 是一个私有的成员变量;

通过定义name 和 name_= 方法, 实现了属性 name 的 getter 和 setter ;

在示例化 Person 类后, 我们可以使用getter 获取属性值, 使用 setter 设置新的属性值;

在 setter中, 添加了条件来确保新值非空 ;

通过使用带有 getter 和 setter 的属性, 可以更灵活地控制类成员的访问和修改;

3- 只带getter的属性

在Scala中, 你可以创建只带getter而没有setter的属性, 这意味着这些属性只能被读取而无法被修改;

这种属性通常用于表示只读数据或计算得出的值;

示例:

  class Person {
    // 私有成员变量, 只带getter
    private var _age: Int = 26

    // 只带getter的属性
    def age: Int = _age
  }

    // 创建Person类的实例 对象
    val p = new Person

    // 使用getter获取属性值
    println(p.age) // 输出: 26

    // 尝试修改 只带 getter的属性, 会导致编译错误
    // p.age = 27 // 编译错误: Reassignment to val

在上面的示例中, 我们定义了一个 Person 类, 其中 _age 是一个私有的成员变量;

通过定义age 方法, 我们实现了只带 getter 的属性;

在实例化Person类后, 我们无法使用 setter 来修改 age 属性, 只能使用 getter 来获取属性值;

通过创建只带 getter 的属性, 您可以确保某些属性在对象创建后不会被意外修改, 从而增加代码的安全性和可靠性;

4- 对象私有化

在Scala中, 你可以使用 private[this] 来定义对象私有化的成员变量或方法;

对象私有化意味着只有同一个对象内部的其他成员才能访问这些私有成员, 而其它对象无法访问;

这种私有化级别比普通的私有化更严格, 确保了数据的封装性和安全性 .

示例:

  class Person {
    private[this] var secret: String = "I have a secret!"

    def revealSecret(anotherPerson: Person): Unit = {
      // 无法访问另一个 Person 对象的私有成员
      //println(anotherPerson.secret) // 这行代码会导致编译错误
      println(s"My secret is: $secret")
    }
  }

    // 创建两个 Person 对象
    val p1 = new Person
    val p2 = new Person

    // 尝试访问对象私有化的成员
    // println(p1.secret) // 这行代码会导致编译错误

    // 调用revealSecret方法
    p1.revealSecret(p2) // 这行代码不会导致编译错误 // 输出：My secret is: I have a secret!

在上面的示例中, 我们定义了一个 Person 类, 其中 secret 被声明为对象私有化的成员变量;

在 revealSecret 方法中, 我们尝试访问领一个 Person 对象的私有成员, 但是由于对象私有化的限制, 这会导致编译错误;

5- 辅助构造器

在Scala中, 辅助构造器(Auxiliary Constructor) 是用于创建类的实例的额外构造函数 ;

辅助构造器允许你以不同的方式初始化对象, 为类的使用者提供更多的灵活性 ;

在Scala中, 辅助构造器使用 def this(...) 语法定义, 可以有多个辅助构造器;

辅助构造器必须以调用主构造器或其他辅助构造器的方式开始 ;

  class Student(val name: String, val age: Int) {
    def this(name: String) {
      this(name, 18) // 调用主构造器
    }

    def this() {
      this("Unknown") // 调用另一个辅助构造器
    }
  }

    // 创建 Student 类的实例
    val student1 = new Student()
    val student2 = new Student("Tom")
    val student3 = new Student("Bob", 20)
    println(student1.name, student1.age) // 输出：(Unknown,18)
    println(student2.name, student2.age) // 输出：(Tom,18)
    println(student3.name, student3.age) // 输出：(Bob,20)

• 在上面的示例中, Student 类有一个主构造器和两个辅助构造器 ;
• 第一个辅助构造器接受一个参数 name 参数, 调用主构造器并将 age 设置为默认值 18 ;
• 第二个辅助构造器没有参数, 调用另一个辅助构造器并将 name 设置为 “Unknown” ;

创建类的实例时, Scala会根据提供的参数自动选择调用合适的构造器 ;

你可以根据需要选择不同的辅助构造器来初始化对象, 提供更多的构造选项 ;

辅助构造器为Scala中面向对象编程带来了更多的遍历性和可定制性 .

6- 主构造器

在Scala中, 主构造器(Primary Constructor) 是类定义中的一部分, 用于初始化类的实例;

主构造器可以接受参数, 并在类实例化时执行初始化操作 ;

1. 定义主构造器
   • 主构造器直接放在类名后面, 可以接受参数并在类实例化时执行初始化
   • 主构造器可以包含参数列表, 这些参数可以在类的其他地方方法中使用
2. 示例代码

  // 主构造器
  class Person(val name: String, val age: Int) {
    println(s"Creating a Person with name: $name and age: $age")

    def displayInfo(): Unit = {
      println(s"Name: $name, Age: $age")
    }
  }

    // 创建 Person 实例对象
    val person1 = new Person("John", 30) // Output: Creating a Person with name: John and age: 30
    val person2 = new Person("Jane", 28) // Output: Creating a Person with name: Jane and age: 28

    // 调用 displayInfo 方法显示信息
    person1.displayInfo() // Output: Name: John, Age: 30
    person2.displayInfo() // Output: Name: Jane, Age: 28

3. 示例解释
   • 在上面的示例中, Person 类有一个主构造器, 接受name 和 age 两个参数
   • 在类实例化时, 主构造器会被调用, 打印初始化信息
   • displayInfo 方法用于显示Person 对象的信息, 包括姓名和年龄
4. 主构造器的特点
   • 主构造器可以在类的定义中直接使用, 无需额外的def this() 语法
   • 主构造器可以初始化类的成员变量, 并在类实例化时执行初始化逻辑

通过主构造器, 你可以定义类的初始化方式, 并在实例化类时执行必要的初始化操作 ;

主构造器是Scala中类的重要组成部分, 用于初始化类的实例 .

7- 嵌套类

在Scala中, 嵌套类(Nested Class) 是指一个类定义在另外一个类的内部 ;

与 Java等语言不同, Scala中的嵌套类是与外部对象绑定的, 而不是与外部类绑定 ;

这意味着每个外部对象都有自己的嵌套类实例 ;

1. 定义嵌套类
   • 在Scala中, 可以在一个类的内部定义另一个类, 这就是嵌套类
   • 嵌套类可以访问外部类的成员, 但是外部类无法直接访问嵌套类的成员
2. 示例代码

  // 嵌套类
  class Outer {
    class Inner {
      def display(): Unit = {
        println("Inner class method;")
      }
    }
  }

    // 创建 Outer 类的实例
    val outer = new Outer()
    // 创建 Inner 类的实例
    val inner = new outer.Inner()
    inner.display() // Inner class method;

3. 示例解释
   • 在上面的示例中, Inner 类是 Outer 类的嵌套类
   • 在创建 Inner 类的实例时, 需要使用外部对象 Outer 的示例来访问嵌套类
   • Inner 类的示例可以访问 Outer 类的成员, 但是 Outer 类的实例无法直接访问 Inner 类的成员
4. 嵌套类的特点
   • 嵌套类可以帮助组织和封装相关的类, 使代码更具可读性和模块化
   • 每个外部对象都有自己的嵌套类实例, 不同外部对象的嵌套类实例时相互独立的

通过嵌套类, 你可以在Scala中创建更加结构化和模块化的代码, 将相关的类组织在一起, 提高代码的可维护性和可读性 .

end