Scala嵌套类

// Network.scala
import scala.collection.mutable.ArrayBuffer

class Network {
  class Member(val name: String) {
    val contacts = new ArrayBuffer[Member]
  }

  private val members = new ArrayBuffer[Member]

  def join(name: String) = {
    val m = new Member(name)
    members += m
    m
  }
}

object Main {
  def main(args: Array[String]): Unit = {
    val chatter1 = new Network
    val chatter2 = new Network

    //Fred 和 Wilma加入局域网1
    val fred = chatter1.join("Fred")
    val wilma = chatter1.join("Wilma")

    //Barney加入局域网2
    val barney = chatter2.join("Barney")

    //Fred将同属于局域网1中的Wilma添加为联系人
    fred.contacts += wilma

    //fred.contacts += barney //这样做是不行的，
    //Fred和Barney不属于同一个局域网，
    //即，Fred和Barney不是同一个class Member实例化出来的对象
  }
}

在Network.scala中，chatter1.Member和chatter2.Member是不同的两个类。

// Network2.scala
import scala.collection.mutable.ArrayBuffer

// 伴生对象
class Network2 {
  private val members = new ArrayBuffer[Network2.Member]
  def join(name: String) = {
    val m = new Network2.Member(name)
    members += m
    m
  }
  def description = "该局域网中的联系人：" +
    (for (m <- members) yield m.description).mkString(", ")
}

object Network2 {
  class Member(val name: String) {
    val contacts = new ArrayBuffer[Member]
    def description = name + "的联系人：" +
      (for (c <- contacts) yield c.name).mkString(" ")
  }
}

object Main2 {
  def main(args: Array[String]): Unit = {
    //创建局域网3
    val chatter3 = new Network2
    //创建局域网四
    val chatter4 = new Network2

    //Fred 和 Wilma加入局域网3
    val fred2 = chatter3.join("Fred")
    val wilma2 = chatter3.join("Wilma")

    //Barney加入局域网4
    val barney2 = chatter4.join("Barney")

    //Fred将同属于局域网3中的Wilma添加为联系人
    fred2.contacts += wilma2

    //Fred将不同属于局域网3中，属于局域网4中的的barney2添加为联系人
    fred2.contacts += barney2

    println(chatter3.description)
    println(chatter4.description)

    println(fred2.description)
    println(wilma2.description)
    println(barney2.description)
  }
}

// Network3.scala
import scala.collection.mutable.ArrayBuffer

//类型投影
class Network3 {
  class Member(val name: String) {
    val contacts = new ArrayBuffer[Network3#Member]
  }

  private val members = new ArrayBuffer[Member]

  def join(name: String) = {
    val m = new Member(name)
    members += m
    m
  }
}

object Main3 {
  def main(args: Array[String]): Unit = {
    //创建局域网5
    val chatter5 = new Network3
    //创建局域网6
    val chatter6 = new Network3

    //Fred 和 Wilma加入局域网5
    val fred3 = chatter5.join("Fred")
    val wilma3 = chatter5.join("Wilma")

    //Barney加入局域网6
    val barney3 = chatter6.join("Barney")

    //Fred3将同属于局域网5中的Wilma3添加为联系人
    fred3.contacts += wilma3

    //Fred将不同属于局域网5中，属于局域网6中的的barney3添加为联系人
    fred3.contacts += barney3
  }
}