Scala 基础语法代码<转>

来源：互联网发布：软件人才外包编辑：程序博客网时间：2024/06/05 05:39

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

[java] view plaincopy
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  
      
  }  
    
    
}  

[java] view plaincopy
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  
}  

[java] view plaincopy
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  
}  

[java] view plaincopy
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方法  
}  

[java] view plaincopy
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)  
}  

0 0