Scala系列学习三 类、继承、接口（特质）、单例

1、类

//在scala源文件中可以包含很多的类，而且这些类对于外界是可见的
class PersonDemo {
  //  用val修饰的变量:只读，即有getter但没有setter
  val id: String = "1234"
  var age: Int = 18
  private var name: String = "allen"
  private[this] val grade: Int = 1
}

class StudentDemo(val name: String, val age: Int) {
  //  主构造器会执行类定义中的所有语句
  println("主构造器")
  private var gender = "male"

  //  利用this来定义辅助构造器
  def this(name: String, age: Int, gender: String) {
    this(name, age)
    println("执行辅助构造器")
    this.gender = gender
  }
}

//构造器参数可以不带val或者var,这些不带修饰的参数如果被一个方法使用，则就会自动升级为字段
class TeacherDemo(val name: String, age: Int, val gender: Int) {
  //prop被下面的方法使用后，prop就变成了不可变得对象私有字段，等同于private[this] val prop
  //如果没有被方法使用该参数将不被保存为字段，仅仅是一个可以被主构造器中的代码访问的普通参数
  def description = name + " is " + gender + " and " + age
}

object Teacher {
  def main(args: Array[String]): Unit = {
    val p = new TeacherDemo("allen", 18, 1)
    println(p.description)
  }
}

2、单例对象

object SessionFactory {
  var count = 5
  val sessions = new ArrayBuffer[Session]()
  while (count > 0) {
    sessions += new Session
    count -= 1
  }

  def getSession(): Session = {
    sessions.remove(0)
  }
}


object SingletonDemo {
  //对象，在scala中使用单例对象，不需要使用new,直接用类名.方法就可以进行代用其中的对象
  //  在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的
  //  1.存放工具方法和常量
  //  2.高效共享单个不可变的实例
  //  3.单例模式


}

class Session {}


//伴生对象
class PersonDemo {
  val id = 1
  private var name = "allen"

  def printName(): Unit = {
    println(PersonDemo.AGE + name)
  }
}

object PersonDemo {
  private val AGE = 18

  def main(args: Array[String]): Unit = {
    val person = new PersonDemo
    person.name = "tom"
    person.printName()
  }
}

3、继承

//继承
trait Behave {
  def run(): Unit = {
    println("fly")
  }

  def eat(): String

  def speak(): Unit = {
    println("it's ok")
  }
}

class CollegeStudent(name: String, age: Int) extends StudentDemo(name: String, age: Int) with Behave {
  val t1, t2, (a, b, c) = {
    println("ABC")
    (1, 2, 3)
  }
  println(a)
  println(t1._1)

  //在Scala中重写一个非抽象方法必须用override修饰
  override def eat() = {
    println("eat in college")
    "ok"
  }

  //在子类中重写超类的抽象方法时，不需要使用override关键字
  override def run(): Unit = {
    println("10 km/h")
  }

}

object ClassDemoRun extends App {
  private val p = new CollegeStudent("allen", 20)
  p.eat()
  p.run()
}