Scala 跟 Java 一样，是一门面向对象编程的语言，有类和对象的概念。

1 类与对象

与 Java 一样，Scala 也是通过关键字 class 来定义类，使用关键字 new 创建对象。

要运行我们编写的代码，同样像 Java 一样，需要一个 main 方法作为程序启动的入口。

我们知道，在 Java 中，main 方法是一个静态方法，但在 Scala 中，並沒有静态方法和静态属性。在 Scala 中，定义在单例对象 object 中的方法和属性就等价于 Java 中的静态方法和静态属性。

下面定义一个没有任何方法与属性的球员信息类，并在创建该类对象。

class FootballPlayer { }

object App {
  def main(args: Array[String]): Unit = {
    print(new FootballPlayer())
  }
}

运行后，控制台打印 FootballPlayer@4cf777e8

2 成员变量

在定义类时，可以通过 val 和 var 定义类的成员变量。

val 和 var 的区别在于，val 定义的变量在初始化后就不能被改变，这类似于 Java 中的 final。

下面例子，创建一个球员类，包含姓名、年龄、所在俱乐部，最后在 main 方法中打印球员对象信息：

class PlayerInfo {
  var playerName: String = "沙拿"
  var age: Int = 31
  var club: String = "利物浦"
}

object App {
  def main(args: Array[String]): Unit = {
    val playerInfo = new PlayerInfo
    println(s"初始化球员是在${playerInfo.club}的${playerInfo.playerName}，今年${playerInfo.age}岁")

    playerInfo.playerName = "孙兴慜"
    playerInfo.age = 30
    playerInfo.club = "热刺"
    println(s"您选择的球员是在${playerInfo.club}的${playerInfo.playerName}，今年${playerInfo.age}岁")
  }
}

运行后，在控制台打印：

初始化球员是在利物浦的沙拿，今年31岁
您选择的球员是在热刺的孙兴慜，今年30岁

3 成员变量初始化值

在编写 Java 类时，如果我们不给成员变量指定默认值，那么对于基本类型，如 int、long、short、float、long 则初始化值为 0，引用类型为 null。

但在 Scala 中，如果不给成员变量指定默认值，就会出现编译错误：

编译器告诉我们，有3个未初始化的成员变量。

我们可以使用下划线 _ 初始化成员变量，例如：

class PlayerInfo {
  var playerName: String = _
  var age: Int = _
  var club: String = _
}

object App {
  def main(args: Array[String]): Unit = {
    val playerInfo = new PlayerInfo
    println(s"初始化球员是在${playerInfo.club}的${playerInfo.playerName}，今年${playerInfo.age}岁")
  }
}

运行程序，控制台打印：

初始化球员是在null的null，今年0岁

可以得出这样的结论：定义成员变量时，需要使用 _ 初始化成员变量，初始化规则跟 Java 一致，int、long、short、float、long 则初始化值为 0，引用类型为 null。

4 成员方法

我们可以使用关键字 def 为类定义方法。例如，我们为球员类添加一个 hello 方法：

class PlayerInfo {
  var playerName: String = _
  var age: Int = _
  var club: String = _

  def hello(): String = {
    s"Hey buddy, I am ${this.playerName} of ${this.club}, ${this.age} years old!"
  }
}

object App {
  def main(args: Array[String]): Unit = {
    val playerInfo = new PlayerInfo
    playerInfo.playerName = "Cristiano Ronaldo"
    playerInfo.age = 39
    playerInfo.club = "Al-Nassr FC"
    println(playerInfo.hello())
  }
}

运行程序，控制台输出：

Hey buddy, I am Cristiano Ronaldo of Al-Nassr FC, 39 years old!

5 访问修饰符

Scala 也可以使用访问修饰符对成员变量、方法的访问进行控制：

5.1 public

Scala 没有 public 修饰符，因为，不加修饰符的属性和方法就是 public，即，在任何地方，类、属性、方法都可以被访问

5.2 private

5.2.1 修饰类

private 修饰的类可在当前包、共生对象 被访问：

5.2.2 修饰成员变量或方法

被 private 修饰的成员变量、方法，只能在当前类、共生对象 中访问：

5.2.3 private[this]

被 private[this] 修饰的属性和方法，只能在本类中被引用，共生对象也不能引用。

5.2.4 private[包名]

默认情况下，子包是无法访问被 private 修饰的 属性和方法的：

当我们需要在当前包及子包中共享类的属性和方法时，我们可以使用 private[包名]，其中包名为当前类所在的包，表示，被修饰的目标可以在当前包和子包中被访问：

5.3 protected

与 Java 的 protect 不同，在 Scala 中被 protected 修饰的属性、方法，只能被当前类，子类访问。

在 Java 中，被 protect 修饰的属性和方法可以被同包下的类访问，但在 Scala 中，被 protected 修饰的属性和方法不能被同包类访问。