scala语法

1:双重for循环（相当于j是i的内存循环）：for (i <-0 to n; j <-10 to 20){ println(i);println(j)}

2:单层for循环：for (i <-0 to n) print(i)

3:单层for循环（不包含上限）：for (i <-0 until n) print(i)

4:break需要借助breakable：

　　

import scala.util.control.Break._
n=10
breakable {

  for (i <- 0 until n) {
    if (i==5) break; //退出breakable块
    print(i)
  }
}

 5:函数：（列表参数和普通参数）

def test(a:Int=123,b:String="zzq"):Int={//参数：参数类型=参数默认值）：函数返回值

 if(a>123){
    print("年龄："+a)
 }else{
    print("年龄："+a+"  姓名："+b)
 }
 var sum=100;
 sum //返回值
}

//调用 test1(1 to 5:_*) 这样就形成了1~5的集合
def test1(c:Int*)={
 var sum=0;
 for(item <- c){
    sum+=item
 }
 sum //返回值
}

 6:类的定义

class Test1{//类定义
private var t1=0

def getT1=t1

def getT1_=(newV:Int){
    t1=newV
}
}

//主构造函数需要在类外部声明（如果构造函数传递的参数在内部其它方法中使用，则会变成private[this]这样的绝对私有变量）
class Test1(new1:Int=123,new2:String="abc"){ print(new1+"   --   "+new2)}

 7:伴生类和伴生对象在同一个文件中可以相互访问private field变量

object Test2{//一般用作静态方法访问的静态类，可理解为单例
private var _i=10
print("执行一次")
def getI=_i
def apply=new Test2("cba")//spark中大量使用伴生类重写apply方法来进行class对象的隐式创建方式
}

class Test2(a:String="abc"){
   print(a+"  --   "+Test2._i)
}

//执行结果

scala> Test2.getI
执行一次res10: Int = 10

scala> Test2.getI
res11: Int = 10

scala> var yy=new Test2("kkk")
kkk  --   10yy: Test2 = Test2@2fe88a09

 8:枚举值

//scala中的枚举值

object Em extends Enumeration{
 val or= Value(0,"or")
 val and= Value(1,"and")
 val where= Value(2,"where")
}

//按索引标记取值：Em(0)

//按枚举名称标记取值：Em.withName("where")

//遍历：for(ele<- Em.values) print(ele)

 9：继承：

class T1{

final def abc(){
println("这是abc")
}

def abc1(){
println("这是abc1")
}

final var abc2=123
val abc3=1234//只有这种val才能被覆盖

}



class T2 extends T1{
override val abc3=990

override def abc1(){
println("这是重写的abc1  ")    
}
}

 10:类型判断

//模糊判断类型
scala> t2.isInstanceOf[T1]
res14: Boolean = true

scala> t2.isInstanceOf[T2]
res15: Boolean = true

//精确判断类型
scala> t2.getClass==classOf[T2]
res17: Boolean = true

scala> t2.getClass==classOf[T1]
res18: Boolean = false

 11:scala中的模式匹配

//传入的参数，但判断类型时实际使用的是isInstanceOf[xxx]
def getNum(item:Any)={
 item match{
     case x:String => print("String")
     case i:Int => print("Int")
     case c:Char => print("Char")
     case _=>0//这个是完全没有匹配上的情况
 }
}

def testMatch(i:Int,s:String="default"):Unit={
 i match {
  case 1 => print("数字："+1)
  case 2 => print("数字："+2)
  case 3 => print("数字："+3)
  case 5 if(s equals "mz") => print("数字："+3+"mz")//匹配后仍可添加判断
  case tmp1 => print("tmp1的赋值数字："+tmp1)//会将i赋值给tmp1变量
  case _ => print("其它喽")
 }
}

12:triat可以多继承，其中可以有实现方法和未实现的抽象方法，但一般triat用于书写工具方法，在不同级别的实现类中去override，而且多重继承后会有责任链的特性

trait Log{
 var t:Int
 def wlog(name:String){}
}

trait MyLog extends Log{
 override var t=100//继承了Log的traint则必须要初始化
 override def wlog(name:String){
        print("MyLog ->"+name)
    super.wlog(name)
 }
}

trait MyLog1 extends Log {
 override def wlog(name:String){
    print("MyLog1 ->"+name)
    super.wlog(name)
 }
}

class P extends MyLog with MyLog1 {//调用链按照继承顺序，构造函数的调用也是按照继承顺序，以此类推（如果有同一父trait被多次继承则构造函数仅仅调用1次）
 def get(){
    wlog("开始调用 ")
 }
}