Scala 基础语法代码

下面的代码包含了基本的Scala的语法内容。包括：判断，循环代码片段，方法定义，调用。 虚拟类，继承，接口，case，package，单例模式

package org.exinglo.scala

class LearnScala {

}

object Test{
  val variable1 = "this is my first scala variable"
    
  def func1(): String = "hello world" //不带参数的函数被调用时，可以不加括号
    
  def func2(who : String): String = { return "hello world " + who}
  
  def func3 = (x : Int, y : Int) => x + y //这是个匿名函数的写法，调用的时候，func3(1,2)
  
  //这里给了y一个默认值，如果用户传过来，那就用用户的
  def func4(x: Int)(y : Int = 1): Int = x + y //加脂法的写法，调用时， func4(1)(2)
  
  // * 代表多个参数的意思，比如 printEveryChar("c","b", "a"),可以传递多个string
  def printEveryChar(c : String*) = {
    c.foreach(x => println(x))
  }
    
  def main(args : Array[String]) {
    println(variable1)
    
    for(i <- 0 to 10 if i%2 == 0){
    println("i is a even number: " + i)
    }
    
    for(i <- 0 until 10){
      println("")
    }
    
    var (n, r) = (10, 0)
    while(n > 0){
      n = n - 1
    }
    
    val p = new Person //这里可以省略括号
    println("information about person:" + p.name + " " + p.age) //如果p.name没有赋值的话，这里会显示为null
    
  }
  
  
}

package org.exinglo.scala

class Person{ //类默认是public类型的
  var name : String = _ //会生成setter和getter方法
  val age = 10 //只会生成getter方法
  private[this] val gender = "male" //无法在下面的main方法访问gender，这个属性只能在对象内部访问
    
}


//生成对象时 val p = new Person2("Java", 10)
//如果参数声明时不带val或者var，那么这个变量相当于内部变量，比如 class Person(name: String) 这里的name就无法在外部被访问到了
class Person2(val name : String, val age : Int){//括号中的内容属于主构造器，其中的参数会作为类的属性存在
  println("this is the person2's constructor")//这里属于默认构造器，生成对象时，会执行这句话
  
  var gender : String = _ //这里要求初始化
  
  //附属构造器必须叫做this，必须首先调用已经存在的子构造器或者其他附属构造器
  def this(name : String, age : Int, gender : String){
    this(name, age)//必须调用默认的构造器，=
    this.gender = gender
  }
}

//成成Student对象的时候，会先打印父类构造器的打印语句，然后但因student类的语句
class Student(val grade : Int, name : String, age : Int) extends Person2(name, age) {
  println("this is the subclass of Person, grade is:" + grade)
  
  override def toString() : String =  {""} //覆盖父类的方法，一定要加上override关键字，其实不仅仅是父类的方法，覆盖父类的var val都要加上override
}

package org.exinglo.abstractandtrait

class ABstractAndTrait {

}

//抽象类（abstract class）
//• 类的⼀一个或者多个⽅方法没有没完整的定义, 当然也可以没有任何抽象方法。
//  对于子类覆盖父类的非抽象方法，一定要override关键字
//• 声明抽象⽅方法不需要加abstract关键字,只需要不写⽅方法体
//• ⼦子类重写⽗父类的抽象⽅方法时不需要加override
//• ⽗父类可以声明抽象字段(没有初始值的字段)
//• ⼦子类重写⽗父类的抽象字段时不需要加override
abstract class PersonX{
  def speak
  val name:String
  val age:Int
}

class Student extends PersonX{
  
  //必须要实现抽象方法，像这种不写等于号的情况，表示返回类型是Unit类型
  def speak{
    println("speak")
  }
  
  val name:String = ""
  val age:Int = 3
}

trait Logger{
  def log(msg:String)
}

//这里的trait consoleLogger可以不实现父类的方法，也可以覆盖父类的方法实现，也可以实现父类的虚方法
trait ConsoleLogger extends Logger{
  def log(msg:String){
    println("save money:" + msg)
  }
}

//因为是覆盖上级的方法，必须使用override关键字
trait MessageLogger extends ConsoleLogger{
  override def log(msg:String){
    println("save money to account:" + msg)
  }
}
//如果一个类没有继承其他的类，实现的第一个trait只能用extends，其他的用with关键字
class Test extends ConsoleLogger{
  def test{
    log("hellp")
  }
}

abstract class Account{
  def save
}

class MyAccount extends Account with ConsoleLogger{
  def save{
    log("100")
  }
}
  
object Run extends App{
  
  //这里是一个很好玩的地方，单独给一个对象混入了一个特质trait，并且这个特质与类的定义继承的特质有冲突
  //打印出来的是MessageLogger中的log方法
  val acc = new MyAccount with MessageLogger
  acc.save
}

package org.exinglo.abstractandtrait

class ApplyTest(val msg:String) {
  def apply() = msg
  def test{
    println(msg)
  }
}

object ApplyTest{
  //下面是apply方法的最常用的方式
  def apply() = new ApplyTest("object calls new")
  
  //object的方法相当于java中的静态方法
  def static{
    println("I am a static method")
  }
}

object Basic extends App{
  
  //类似于下面，嗲用object的方法
  ApplyTest.static
  
  val t = new ApplyTest("new")
  println(t())
  
  //据说下面这样可以调用object ApplyTest中的apply方法，但是我的编译器总是报错
  //后来发现是object的apply方法一开始声明没有加上小括号造成的，如def apply = xxxx
  val tt = ApplyTest()
  println(tt())
  
  // ApplyTest()是调用object的apply方法
  // val t = new ApplyTest(); t() 调用的是class ApplyTest的apply方法
}

package org.exinglo.abstractandtrait
/*
 * package com.xyz{
 * //-------------
 *  package spark
 *  }
 * }
 * 
 * { //这里只在程序块中可见
 *   import com.yyy
 *   
 * }
 * 
 * import java.util.{HashMap =>JavaHashMap} //定义一个别名
 * 
 * 
 * package aa.bb.cc.dd
 * 
 * class Xxx{
 *   private[dd] def variable = {} //根据private[]中指定的不同，可见范围不同
 * }
 * 
 * */
class PackageAndCase {

}

object BasicT extends App{
  val value = 3
  
  val result = value match{
    case 1 => "one"
    case 2 => "two"
    case _ => "some other number"
  }
  
  val result2 = value match{
    case i if i == 1 => "one"
    case i if i == 2 => "two"
    case _ => "other number"
  }
  
  def t(obj : Any) = obj match{
    case x:Int => println("Int")
    case s:String => println("String")
    case _ => println("unkonwn type")
  }
  
  t(2)
}