Scala语法（二）

（1）类，对象

• //定义类（属性、方法）,实例化对象

class counter{                                                                        *//主构造器  class counter(name:String,mode:Int){ ... }  实例化：val mycoun = new counter("mycoun",3)
    private var privatevalue = 0
    private var name = " "
    private var mode = 1
    def value = privatevalue
    def value_ = (newvalue:Int){
    if(newvalue >0)  privatevalue = newvalue
}                                                                                                 *//value、value_方法定义了getter,setter
    def this(name:String){
        this()
        this.name = name
}                                                                                            *//第一个辅助构造器(用于实例化时参数的个数)
    def this(name:String,mode:Int){
        this(name)
        this.mode = mode
}                                                                                             *//第二个辅助构造器

    def increment(step:Int): Unit = {value+=step}                     *//函数参数step
    def current(): Int = { value}
}
object Mycounter{                                                              * //声明放在对象中进行编译 (不编译运行不用放入）
    def main (args:Array[String]){
        val mycounter = new counter()     //实例化对象

        val coun1 = new counter("coun1")                                * //第一个辅助构造器实例化
        val coun2 = new counter("coun2",2)                            * //第二个辅助构造器实例化
        print(mycounter.value)        //getter
        mycounter.value = 3           //setter
        mycouter.increment(1)  // 调用函数
        println(mycounter.currrent())
 }

文件名Test.scala

运行：scalac Test.scala // 编译

scala -classpath .Mycounter

单例对象：(类似java静态方法)

class person{                                                                            *//编译后类, 里面的成员变为实例成员
    private var id = person.newpersonid()                                 *//类和它的伴生对象的私有字段和方法可以相互调用（必须存在于同一个文件中）
    private var name = " "
    def this(name:String){
        this()
        this.name = name
}
    def info()  {
         println(id,name)
}
}
object person{                 * //单例对象object，构造类似class           //编译后伴生对象，成为静态成员  public static int newpersonid()*
    private var lastid = 0
    def newpersonid() = {
        lastid+=1
        lastid
}
def main(args:Array[String]){                                                   * //应用程序对象（程序从此运行）
    val person1 = new person("大刘")   *//调用了person类的apply方法
    val person2 = new person("小刘")
    person1.info()
    person2.info()
}
}

对象的apply,update方法

var myarr = Array("hadoop","spark") *//调用了Array类的apply方法
var myarr = new Array[String](3)
myarr(0) = "me" myarr(1)= "you" myarr(2) = "they"  *//调用了Array类的update方法（使用了括号，实际上执行了myarr.update(0,"me")）

(2) 继承

抽象类

abstrate class Car{               * //抽象类
    val carband:String          *  //抽象字段
    def info()                         *  //抽象方法
    def greeting() {
        println("welcome")
}
}

class BWM extends Car{
    override val carband = "BWM"                  *  //重写超类的字段需要使用override
    def info() {printf("this is a %s car",carband)}                       *   //重写超类的抽象函数，不必使用override
    override def greeting() {
        println("welcome to BWM")                                                            *    //重写超类的非抽象函数，不必使用override
}
object Mycar{
    def main(args:Array[String]){
        val car = new BWM()
        car.info()
        car.greeting()
}
}

特质（trait）类似java中的接口，可实现多重继承

trait Car{
    var id:Int            *    //抽象字段
    def currid():Int    *   // 抽象方法
}
trait Greet{
    def greeting(para:String){
        println("welcome to "+para)
}                                             *   //非抽象方法

class BWM entends Car with Greet{   * //多重继承
       override var id = 1000
       def currid():Int = {
            id+=1;id
}
}
object Mycar{
    def main(args:Array[String]){
        val car1 = new BWM()
        car1.currid()
        car1.greeting("BWM")
}
}