Scala面向对象编程

### 6.1 类和对象

在Scala中，类和对象是实现面向对象编程的核心构造。

#### 类定义

Scala中的类定义使用`class`关键字，并且可以包含字段（属性）、方法和构造器。

```scala
class Person(var name: String, var age: Int) {
  def this(name: String) = this(name, 0) // 主构造器的辅助构造器

def this() = this("John Doe") // 另一个辅助构造器

def greet(): Unit = println(s"Hello, my name is $name and I am $age years old.")
}

val person = new Person("Alice", 30)
person.greet()
```

#### 对象定义

Scala中的对象是单例，即它们只能被实例化一次。对象定义使用`object`关键字。

```scala
object Greeting {
  def greet(name: String): Unit = println(s"Hello, $name!")
}

Greeting.greet("Scala")
```

### 6.2 继承和多态

Scala支持类之间的继承，允许多态行为。

#### 继承

子类可以使用`extends`关键字继承父类。

```scala
class Employee(name: String, age: Int) extends Person(name, age) {
  def this(name: String) = this(name, 0)

def work(): Unit = println(s"$name is working.")
}

val employee = new Employee("Bob", 25)
employee.greet() // 继承自Person类
employee.work()
```

#### 多态

Scala中的多态允许将子类对象视为父类类型。

```scala
val people: List[Person] = List(new Person("Alice", 30), new Employee("Bob", 25))
people.foreach(_.greet())
```

### 6.3 特质（Traits）和混入（Mixins）

特质（Traits）是Scala中实现代码复用和多继承的一种机制。

#### 特质定义

特质定义使用`trait`关键字，可以包含字段、方法和构造器。

```scala
trait CanFly {
  def fly(): Unit = println("This can fly.")
}

trait CanSwim {
  def swim(): Unit = println("This can swim.")
}
```

#### 混入特质

类或特质可以使用`extends`关键字混入一个或多个特质。

```scala
class Bird extends Person with CanFly {
  def this(name: String) = this()
}

class Fish extends Person with CanSwim {
  def this(name: String) = this()
}

val bird = new Bird("Tweety")
bird.greet()
bird.fly()

val fish = new Fish("Nemo")
fish.greet()
fish.swim()
```

在这个例子中，`Bird`类混入了`CanFly`特质，而`Fish`类混入了`CanSwim`特质。这允许`Bird`和`Fish`类分别拥有飞行和游泳的能力。

Scala的类和对象、继承和多态、以及特质和混入提供了强大的工具，使得面向对象编程和代码复用变得更加灵活和强大。