scala编程07：面向对象：成员变量、内部类、单例、Apply（重点）、枚举

1、getter与setter

• 定义不带private的var field，此时scala生成的面向JVM的类时，会定义为private的name字段，并提供public的getter和setter方法
•  而如果使用private修饰field，则生成的getter和setter也是private的，只能在伴生对象内部使用
•  如果定义val field，则只会生成getter方法
•  如果不希望生成setter和getter方法，则将field声明为private[this]，则只可以在类内部使用

class Student {
  //不加任何修饰，直接为private并提供相应的public的getter与setter
  var name =  "ryan"
  private var age = 10
  //除了本类内部，其它地方都不可以用
  private [this] var sex = "male"
  def setSex(sex:String){this.sex = sex}
  def showSex = this.sex
}

object Student{
  def main(args: Array[String]): Unit = {
    val stu1 = new Student
    println(stu1.name)

    //赋值
    stu1.name = "zhangsan"
    println(stu1.name)
    //访问age
    println(stu1.age)
    //设置age
    stu1.age = 30
    println(stu1.age)
    //无法进行访问sex,只能通过方法来访问
    stu1.setSex("other")
    println(stu1.showSex)

  }
}

//输出：

ryan
zhangsan
10
30
other

2、 内部类

scala的内部类使用起来比java的更简单且方便，没有太多的语法模板限制，比较灵活易用

import scala.collection.mutable.ArrayBuffer

class Department {
  class Employee(val name:String)
  val employees = new ArrayBuffer[Employee]
  def addEmployee(name:String): ArrayBuffer[Employee] ={
    val employee = new Employee(name)
    employees += employee
  }
}

object Department{
  def main(args: Array[String]): Unit = {
    val department = new Department
    department.addEmployee("ryan")
    department.addEmployee("zhansan")
    department.addEmployee("lisi")

    for(emp<-department.employees) println(emp.name)
  }
}

ryan
zhansan
lisi

import scala.collection.mutable.ArrayBuffer

class Department {
  class Employee(val name:String, val age:Int)
  val employees = new ArrayBuffer[Employee]
  def addEmployee(name:String, age:Int)={
      new Employee(name, age)
  }
}

object Department{
  def main(args: Array[String]): Unit = {
    val department = new Department
    val ryan = department.addEmployee("ryan11", 32)
    val ryan2 = department.addEmployee("ryan22", 35)
    val zhansan = department.addEmployee("zhansan", 26)
    val lisi = department.addEmployee("lisi", 51)

    //第一种加法
    department.employees += ryan += ryan2 += zhansan += lisi
    //第二种加法
    department.employees +=(ryan,ryan2, zhansan, lisi)

    for(emp<-department.employees) println(emp.name + "->" + emp.age)
  }
}

 ryan11->32
ryan22->35
zhansan->26
lisi->51
ryan11->32
ryan22->35
zhansan->26
lisi->51

3、单例：object

•  object，相当于class的单个实例，通常在里面放一些静态的field或者method
• 第一次调用object的方法时，就会执行object的constructor，也就是object内部不在method中的代码；但是object不能定义接受参数的constructor
• 注意，object的constructor只会在其第一次被调用时执行一次，以后再次调用就不会再次执行constructor了
• object通常用于作为单例模式的实现，或者放class的静态成员，比如工具方法

注意：当作为伴生对象与class互相访问时，如果要从class中访问到object中的成员时，此时的object是作为静态单便存在，所以访问成员时要加上object的名称

object Car{
  private [this] val wheels = 4
  def getWheel = wheels
}

class Car(brand:String, price:Double){
  override def toString: String = "品牌：" + brand + ", 轮子：" + Car.getWheel + ", 价格(万)：" + price
}

object Test{
  def main(args: Array[String]): Unit = {
    println(new Car("cayee", 200))
  }
}

品牌：cayee, 轮子：4, 价格(万)：200.0

4、Apply方法提升类使用的简洁性

将new实例放到伴生对象内部完成，让scala自动调用我们定义的apply方法

object Car{
  private val wheels = 4
  def apply(brand:String, price:Double) = new Car(brand, price)
}

class Car(brand:String, price:Double){
  override def toString: String = "品牌：" + brand + ", 轮子：" + Car.wheels + ", 价格(万)：" + price
}

object Test{
  def main(args: Array[String]): Unit = {
    //利用apply实现直接用类名生成实例，如同Map\Array等系统内部类的使用一样简洁高效，不需要new，由apply直接new
    println(Car("cayee", 200))
  }
}

5、用object来实现枚举

最简单的枚举：使用Valu从0开始依次递增

object EnumerationDemo extends Enumeration {
  var SPRING,SUMMER,AUTUM,WINTER = Value
}

object Test{
  def main(args: Array[String]): Unit = {
    for(season<-EnumerationDemo.values) println(season + "->" + season.id)
  }
}

SPRING->0
SUMMER->1
AUTUM->2
WINTER->3

自定义值的枚举：利用Value（值， “字符”）

object WeekDays extends Enumeration{
  var MONDAY = Value(1,"MONDAY")
  var TUESDAY = Value(2,"TUESDAY")
  var WESDAY = Value(3,"WESDAY")
}

object Test1{
  def main(args: Array[String]): Unit = {
    for(wd<-WeekDays.values) println(wd + "->" + wd.id)
    //根据字符找到值
    println(WeekDays.MONDAY.id)
    //根据数值或定义的名称找到字符
    println(WeekDays(1))
    println(WeekDays.MONDAY)
  }
}

MONDAY->1
TUESDAY->2
WESDAY->3
1
MONDAY
MONDAY