Scala基础笔记

变量

声明

声明变量一定要初始化

基本语法

//var|val 变量名 [：变量类型] = 变量值
scala> var a:Int = 2
a: Int = 2

scala> val a:Int = 2
a: Int = 2

//也可以让编译器自动判断类型
scala> var s="123"
s: String = 123

//判断后类型固定
scala> var t1=123
t1: Int = 123

scala> t1=1.1
<console>:12: error: type mismatch;
found   : Double(1.1)
required: Int
t1=1.1

//也可以用下面的方式声明变量
scala> var (a,b,c)=(1,2,"string")
a: Int = 1
b: Int = 2
c: String = string

scala> var t1,t2=10
t1: Int = 10
t2: Int = 10

var和val的区别

var才是真正意义上的变量,其值(指针)可以随意更改

scala> var t1=10
t1: Int = 10

scala> t1=20
t1: Int = 20

但是val不行，它的指针是固定的

scala> val t1=10
t1: Int = 10

scala> t1=20
<console>:12: error: reassignment to val
		t1=20  //报错了  并未修改成功

但是val的地址不能变，地址里面的值却可以变

scala> val arr=Array(1,2,3)
arr: Array[Int] = Array(1, 2, 3)

scala> arr(0)=0

scala> arr
res3: Array[Int] = Array(0, 2, 3)

方法

方法的定义

基础写法

def add(x: Int,y: Int): Int = (x+y)

拆分def 【add】【(x: Int,y: Int)】【: Int 】= 【{x+y}】

• add 方法名

• (x: Int,y: Int) 参数列表

  //一个方法带多个参数列表
  def add(x: Int,y: Int)(z: Int): Int ={x+y+z}
  println(add(1,2)(3))
  
  //可变参数列表，可变参数一定要是最后一个参数
  //同时这个是一个 无返回值方法 的写法
  def show(x: Int*): Unit ={
      for(i <- x){
          println(i)
      }
  }
  show(1,2,3,4,5,6)
  

• : Int 返回类型，返回类型可以省略，编译器会自动判断返回的类型，但是可能会与真是想要的有出入。

  //省去返回类型
  def add(x: Int,y: Int)=(x+y)
  

• {x+y} 方法体

  //方法体里只有一行语句时
  def add(x: Int,y: Int): Int =  x+y
  
  
  //方法体里有多行语句时可以用{}
  def show(x: Int,y: Int) = {
      println(x+y)
      println(x*y)
  }
  

• 方法的返回值默认是方法体中最后一行表达式 的值，当然也可以用return来执行返回值，但不推荐这么做，若使用return来制定函数的返回值，scala的类型推断将会失效，要显式指定返回值类型。

  def add(x: Int,y: Int): Int = {
      x+y
      x*y
  }
  print(add(1,5))  //输出5
  
  def add(x: Int,y: Int): Int = {
      return x+y
      x*y
  }
  print(add(1,5)) //输出6  这时候必须写返回类型
  

• 方法支持重载

  def add(x: Int,y: Int): Int = {
      x+y
  }
  def add(x: Int): Int = (x+x)
  def main(args: Array[String]): Unit = {
      println(add(1)) //2
      println(add(1,2)) //3
  }
  

• 方法的参数可以是个函数，这个在函数的时候会举例

函数

函数可以看做是带有参数的表达式(变量)

函数的定义

//不显示声明返回类型
val f1 = ((a: Int, b: Int) => a + b)
val f2 = (a: Int, b: Int) => a + b
val f3 = (_: Int) + (_: Int)

//显示声明返回类型
val f4: (Int, Int) => Int = (_ + _)
val f1:((Int,Int)=>Int)={
    (x,y)=>x+y
}
val f2:(Int,Int)=>Int =(x,y)=>x+y

val f1=(x: Int,y:Int)=>{if(x>y)x else y}

就是下面语句的简写

val f1 = new Function2[Int, Int, Int] { 
    def apply(x: Int, y: Int): Int = if (x < y) y else x 
}

方法的参数是个函数

def show(x:Int,f:Int =>Unit)={
    for(i<- 0 to 10)
    f(x)
}
def main(args: Array[String]): Unit = {
    val f1=(x: Int)=>(
        println(x)
    )
    show(6,f1);
}

函数和方法的区别

在scala中本质上函数是一种特殊的方法。它们唯一使用上的区别就是函数能当值使用而方法不行

//定义一个方法
scala> def fun()={println("this is a Method")}
fun: ()Unit

scala> fun
this is a Method

//将方法当作值传给一个变量
scala> val f=fun
this is a Method
f: Unit = ()

//发现值并没有成功传输，变量也不能当方法使用
scala> f

scala>

scala> f()
<console>:14: error: Unit does not take parameters
       f()

//第二种方法调用的方式测试
scala> val f2=fun()
this is a Method
f2: Unit = ()

scala> f2()
<console>:14: error: Unit does not take parameters
       f2()

//将方法转换成函数，再传给变量
scala> val f3=fun _
f3: () => Unit = <function0>

scala> f3()
this is a Method