Scala中类如何使用

# Scala中类如何使用

## 一、类的定义基础

在Scala中，类是面向对象编程的核心构建块。定义一个类的基本语法如下：

```scala
class ClassName {
  // 类成员（字段、方法等）
}

1.1 简单类示例

class Person {
  var name: String = ""  // 可变字段
  val age: Int = 0       // 不可变字段
  
  def greet(): Unit = {
    println(s"Hello, my name is $name")
  }
}

二、构造函数

2.1 主构造函数

Scala的主构造函数与类定义交织在一起：

class Person(var name: String, val age: Int) {
  def greet(): Unit = println(s"Hi, I'm $name, $age years old")
}

• var 参数生成可变字段
• val 参数生成不可变字段
• 无修饰符的参数是构造函数局部变量

2.2 辅助构造函数

使用this关键字定义：

class Person(var name: String, val age: Int) {
  def this(name: String) = this(name, 0)  // 必须调用主构造器
  def this() = this("Anonymous")
}

三、类成员

3.1 字段

class Account {
  private var _balance = 0.0  // 私有字段
  
  // Getter
  def balance = _balance
  
  // Setter
  def balance_=(value: Double): Unit = {
    require(value >= 0)
    _balance = value
  }
}

3.2 方法

class Calculator {
  def add(a: Int, b: Int): Int = a + b
  
  // 方法重载
  def add(a: Int, b: Int, c: Int): Int = a + b + c
}

四、继承与多态

4.1 继承基础

class Animal(val name: String) {
  def makeSound(): Unit = println("Some generic sound")
}

class Dog(name: String) extends Animal(name) {
  override def makeSound(): Unit = println("Woof!")
}

4.2 抽象类

abstract class Shape {
  def area: Double
  def perimeter: Double
}

class Circle(radius: Double) extends Shape {
  override def area: Double = math.Pi * radius * radius
  override def perimeter: Double = 2 * math.Pi * radius
}

五、伴生对象

Scala中的类可以有一个同名的伴生对象：

class Student(val id: Int, var name: String)

object Student {
  def apply(name: String): Student = new Student(0, name)
  
  def unapply(s: Student): Option[(Int, String)] = Some((s.id, s.name))
}

// 使用
val s = Student("Alice")  // 调用apply方法

六、案例类（Case Class）

特殊的类，自动提供功能：

case class Point(x: Int, y: Int) {
  def +(p: Point): Point = Point(x + p.x, y + p.y)
}

// 自动获得：
// 1. 不可变字段
// 2. toString实现
// 3. equals/hashCode
// 4. copy方法
// 5. 伴生对象与apply

val p1 = Point(1, 2)
val p2 = p1.copy(x = 3)

七、高级特性

7.1 类型参数（泛型类）

class Box[T](var content: T) {
  def replace(newContent: T): T = {
    val old = content
    content = newContent
    old
  }
}

val intBox = new Box[Int](42)

7.2 特质混入

trait Logging {
  def log(msg: String): Unit = println(s"LOG: $msg")
}

class Service extends Logging {
  def execute(): Unit = {
    log("Service started")
    // ...
  }
}

八、最佳实践

1. 优先使用不可变字段（val）
2. 考虑使用案例类代替普通类（当适用时）
3. 将逻辑操作定义为方法而非过程
4. 使用伴生对象作为工厂方法
5. 合理使用访问修饰符（private/protected）

通过合理使用Scala的类特性，可以构建出既安全又富有表达力的面向对象设计。 “`