Scala_类

一、类的基本元素

  class Counter{
    private var value = 0   // 定义私有属性
    def increment() { value += 1}   // 定义方法，默认是共有的
    def current() = value
  }

二、私有变量
Scala生成面向JVM的类，其中有一个私有的age字段以及相应的getter和setter方法。
这两个方法是公有的，因为没有将age声明为private（对私有字段而言， getter和setter方法也是私有）。
getter和setter分别叫做age和age_= 。在任何时候都可以自己重新定义getter和setter方法。
如果字段是val，则只有getter方法被生成。
如果不需要任何getter或setter，可以将字段声明为private[this]

  class Person{
    private var privateAge = 0   // 变成私有并改名
    def age= privateAge
    def age_= (newValue: Int): Unit ={
      if (newValue > privateAge) privateAge = newValue
    }
    val timeStamp = new java.util.Date    // 只有getter方法被生成
    private[this] var value= 0  // 类似某个对象.value 这样的访问将不被允许
  }
  val person = new Person
  person.age_=(24)
  println(person.age)   // 24
  person.age_=(13)
  println(person.age)   // 24

三、用@BeanProperty 修饰时，将自动生成以下四个方法：
name: String
name_ = (newValue: String): Unit
getName(): String
setName(newValue: String): Unit

  class Person2{
    @BeanProperty var name:String = _
  }

四、主构造器
与类定义交织在一起。
如果类名之后没有参数，则该类具备一个无参主构造器。这样一个构造器器仅仅是简单地执行类体中的所有语句而已。
通常可以通过在主构造器中使用默认参数来避免过多地使用辅助构造

  class Person4 (val name: String, val age: Int){
    //class Person4 private (val name: String, val age: Int){   private 关键字的使用将使得主构造器变成私有的，这时用户只能通过辅助构造器构造对象
    printf("My name is %s, And my age is %d", name, age)     // 主构造器中的内容在初始化对象时被立即执行
    private var value = 0   // 定义私有属性
    def increment() { value += 1}   // 定义方法，默认是共有的
    def current() = value
  }
  val person4 = new Person4("regan", 24)   // 此时会打印一句话
  println(person4.current)

五、辅助构造器
辅助构造器的名称为this。
每一个辅助构造器都必须以一个对先前已定义的其他辅助构造器或主构造器的调用开始

  class Person3{

    private var name = ""
    private var age = 0

    def this(name: String){     // 一个辅助构造器
      this    // 调用主构造器
      this.name = name
    }
    def this(name:String, age:Int){   // 另一个辅助构造器
      this
      this.name = name
      this.age = age
    }
  }
  val person3_1 = new Person3    // 主构造器
  val person3_2 = new Person3("regan")   // 第一个辅助构造器
  val person3_3 = new Person3("regan", 24)   //第二个辅助构造器

六、嵌套类

  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
    }
  }
  val chatter = new Network
  // 要构建一个新的内部对象，只需要简单的new这个类名：new chatter.Member。而在Java中，你需要使用一个特殊语法：chatter.new Member（）。
  val fred = chatter.join("Fred")
  val wilma = chatter.join("Wilma")
  fred.contacts += wilma // OK

七、枚举
定义一个扩展Enumeration类的对象并以value方法调用初始化枚举中的所有可选值。
每次调用Value方法都返回内部类的新实例，该内部类也叫做Value，或者，你也可以向Value方法传入ID、名称，或两个参数都传
如果不指定，则ID在将前一个枚举值基础上加一，从零开始。缺省名称为字段名。
枚举值的ID可通过id方法返回， 名称通过toString方法返回。

  object TrafficLightColor extends Enumeration {
    val Yellow, Green= Value
    val Red= Value(0, "Stop")
  }

八、扩展类：extends
可以将类声明为final ，这样它就不能被扩展。还可以将单个方法或字段声明为final。
在Scala中重写一个非抽象方法必须使用override修饰符
在Scala中调用超类的方法和Java完全一样，使用super关键字

 class Employee extends App{
    final val age:Int = 1
  }
  //类型检查和转换：测试某个对象是否属于某个给定的类，可以用islnstanceOf方法。 如果测试成功，就可以用aslnstanceOf方法将引用转换为子类的引用

可以将字段或方法声明为protected。这样的成员可以被任何子类访问，但不能从其他位置看到。
Scala还提供了一个protected[this］的变体，将访问权限定在当前的对象
可以用abstract关键字来标记不能被实例化的类，通常这是因为它的某个或某几个方法没有被完整定义
除了抽象方法外．类还可以拥有抽象字段。抽象字段就是一个没有初始值的字段。