Scala语法（一）

1.变量的声明和定义
var：可变的
val：不可变的
尽量用val
标准格式 val name:String=“zhangsan”
val:变量声明
name:变量名
:分隔符
String:变量类型
“zhangsan”:变量值
注意：如果说变量的值是默认值的话，那么变量的声明一定是需要可变的，否则就没有声明变量的实际意义了
默认值对应java
2.scala数据类型
同java
跟java相比，scala中任何数据都是对象
scala中存在很多增强数据类型的类，增加了对象的方法
scala中不存在自增，自减，三目运算符
字符串增值操作
var src =“hellow ${name}”
var name =“world”
println(src)
3.循环
最常用的是for循环
1.遍历（range范围，字符串，数组）
val arr = Array(“a”,“b”,“c”)
for(i <- arr){
println(i)
}
2.多重for循环
九九乘法表
for(i <- 1 to 9; j <- 1 to i ){
if(j < i){
print(j+""+i+"="+ij+"\t")
}else{
println(j+""+i+"="+ij)
}
}
3.if守卫
取偶数
for(i <- 1 to 100 if i % 2 == 0) {
println(i)
}
4.for推导式
构造集合(如果for循环的循环体以yield开始，则该循环会构建出一个集合每次迭代生成集合中的一个值)
var v = for(i <- 1 to 10) yield i
println(v)

while循环跟do…while循环
同java
不过scala中没有break，但是可以使用boolean类型变量、return或者Breaks中的break函数来替代使用
跳出循环的三种方式：
1：声明一个外部变量
2：使用breakable
3: 使用嵌套函数
4.面向函数式编程
1.如何定义一个方法
标准格式
def m(x:Int,y:Int):Unit = xy
def:定义方法使用def关键字
m:方法名
(x:Int,y:Int):参数列表以及参数类型
Unit:返回值类型，Unit类似于java中的viod
xy:方法体
忽略返回值类型，根据方法体的最后一句进行自动推导
def m(x:Int,y:Int) = x*y
如果方法中没参数的话，那么小括号是可以省略的，但是调用的时候，不能加括号了
def m = println(“hellow world”)

2.如何定义一个函数
scala> val f = (x:Int,y:Int) => xy
f: (Int,Int) => Int =
val:定义函数的关键字
f:函数名
(Int,Int):参数列表
Int:返回值类型
:函数参数的个数，最多只能有22个参数，如果想使用更多参数的话，使用变长参数(Int)

匿名函数，不指定函数名称
(x:Int,y:Int) => x*y

调用函数的时候一定要加(),不能省略，省略的话会打印函数签名

scala> val f2:(Int,Int) => Int = (x,y) => xy
val:定义函数的关键字
f2:函数名
(Int,Int):参数列表
Int:返回值类型
(xy)参数列表
xy:函数体
完整写法
scala> val f3:(Int,Int) => Int = (x,Int,y,Int) => xy

3.方法转函数，神奇的下划线
scala> def m(x:Int,y:Int)=x*y
m: (x:Int,y:Int) Int

scala> val m2 = m(2,3)
m2: Int = 6

scala>val f = m _ 下划线前面一定要加空格
f:(Int,Int) => Int =

4.函数的求值策略
1.call by value
对函数的实参求值，且只求一次
2.call by name
函数的实参在函数体内部每次用到的时候，会被求值，不用到不会调用该函数

object CallByNameAndCallByValue {

  //钱包总金额
  var money = 100
  /**
    * 刷卡，每次刷5元
    */
  def shuaka():Unit = {
    money = money -5
  }
  /**
    * 数钱， 看看卡里还剩下多少余额
    */
  def shuqian() ={
    println(money)
    shuaka()
    money
  }
  /**
    * call by Value操作
    * @param x
    */
  def printByValue(x:Int) ={
    for (i<- 0 until 3){
      println(s"测试：${x}元")
    }
  }
  /**
    * call by name操作
    * @param x
    */
  def  printByName(x: => Int) ={
    for (i<- 0 until 5){
      println(s"测试：${i}元")
    }
  }

  def main(args: Array[String]): Unit = {
    //1：计算数钱返回值：95
    //2: 将95作为参数传入printByValue
    println("*****************传值调用****************************")
    printByValue(shuqian())

    //1: 将shuqian方法名称传递到方法的内部执行
    println("*****************传名调用****************************")
    printByName(shuqian())

    //总结：传值调用-》先计算再传参
    //      传名调用-》先传参再计算（用到了才计算）
  }
}

5.闭包
就是函数的嵌套，在一个函数的定义中，包含另一个函数的定义：并且在函数中可以访问外函数中的变量

object ClosureDemo {
  //补贴
  val subsidy = 1000
  //年终奖+工资+补贴（每个部门的年终奖是不同的）
  def add(bonus:Double) = (wages:Double) =>wages+bonus+subsidy

  def main(args: Array[String]): Unit = {
    //春节，发年终奖
    //销售部门：10000
    //开发部门：15000
    //测试部门：8000
    val saleDept = add(10000) //销售部门的
    val boduo = saleDept(30000)
    val cang = saleDept(25000)

    println(boduo)

    val develorDept = add(15000)//开发部门的

    val testDept = add(8000)


  }
}