scala学习笔记(二):基本语法和流程控制

1.基本语法

1.1.数据类型

scala的数据类型和java的数据类型最大的区别在于 scala中的数据类型都是对象,scala中没有原生的数据类型
scala中的数据类型分为两大类 AnyVal(数值类型)和AnyRef)(引用类型),两种对象都是属于Any,都是对象,因此scala中的数据类型都有各自的方法
所有数据类型

数据类型树状图

• Any : 所有的类型的父类,类似于java中的object
• AnyVal : 数值类型(简单类型)
• AnyRef : 引用的数据类型
• Null : 应用类型的子类,类似于java中的null,是所有的引用类型的子类
• Nothing : 所有类型的子类,可以返回给任意的变量或函数.通常异常时使用,表示此处有错误

1.1.1变量的定义
var 可变的变量
val 不可变的变量(后期不可以再次赋值,在一般情况下使用val)
使用 格式 var | val 变量名称 : 变量类型 = 变量值
注意:

• 数据类型可以指定,也可以不指定,如果不指定,会进行数据类型的推断
• 如果指定数据类型，数据类型的执行 方式是 在变量名后面写一个冒号，然后写上数据类型
• 我们的scala里面变量的修饰符一共有两个，一个是var 一个是val，如果是var修饰的变量，那么这个变量的值是可以修改的。如果是val修饰的变量，那么这个变量的值是不可以修改的。
• val 是线程安全的,使用时效率更高
• 优先使用val 但当以后的变量需要变化时,就要使用var

1.1.2类型转换

• 类型转换遵守的原则和java中的一致,高精度的数据的类型转换为低精度的数据类型会有精度损失问题,低精度的数据类型可以直接隐式转换为高精度的数据类型.
• 类型转换时,数据类型对象会有方法toXxx 强制类型转换时 使用

val a = "10"
 a.asInstanceOf[]

1.2运算符

1.2.1算数运算符

例子:

object Test {
  def main(args: Array[String]) {
    var a = 10;
    var b = 20;
    var c = 25;
    var d = 25;
    println("a + b = " + (a + b) );
    println("a - b = " + (a - b) );
    println("a * b = " + (a * b) );
    println("b / a = " + (b / a) );
    println("b % a = " + (b % a) );
    println("c % a = " + (c % a) );
}
}

1.2.2关系运算符

例子:

```scala
def main(args: Array[String]) {
  var a = 10;
  var b = 20;
  println("a == b = " + (a == b) );
  println("a != b = " + (a != b) );
  println("a > b = " + (a > b) );
  println("a < b = " + (a < b) );
  println("b >= a = " + (b >= a) );
  println("b <= a = " + (b <= a) );
}

1.2.3逻辑运算符

例子:

val a = true
val b = false

println("a && b = " + (a && b))

println("a || b = " + (a || b))

println("!(a && b) = " + !(a && b))

1.2.4赋值运算符

1.2.5位运算符

1.2.6优先级

2. 流程控制

2.1if…else 语句

2.1.1单一if…else语句

val k = if (x < 0) 0
  else if (x >= 1) 1 else -1
  println("k=" + k)

2.1.2if…else语句嵌套

 var x = 30;
  var y = 10;
  if( x == 30 ){
    if( y == 10 ){
      println("X = 30 , Y = 10");
    }
  }

总结:
1）if条件表达式它是有返回值的
2）返回值会根据条件表达式的情况会进行自动的数据类型的推断。

2.2块表达式

val x = 0
val result = {
  if(x < 0)
    1
  else if(x >= 1)
    -1
  else
    "error"
}
println(result)

2.3for循环

普通for循环

 for (i <- 1 to 12 ; j <- 1 to i){
      print(s"$j * $i = " + j * i + "\t")
      if (j == i) {
        println()
      }
    }

增强for

val arr = Array( 1 , 2 , 3 , 4 , 5 )
    //遍历方式 1
    for (elem <- arr) {
      println(elem)
    }

总结：
　　1）在scala里面没有运算符，所有的符号其实都是方法。
　　2）在scala里面没有++ – 的用法
　　3）for( i <- 表达式/数组/集合)
　　4）在for循环里面我们是可以添加if表达式
　　5）有两个特殊表达式需要了解：
　　 To 1 to 3 ( 1 2 3 )
　　 Until 1 until 3 (1 2)
　　6）如果在使用for循环的时候，for循环的时候我们需要获取，我们可以是使用yield关键字。

2.4while 和 do while

var  n = 10
while(n<20){
  println(n)
  n+=1
}
do{
  println("I first do")
  n-=1
}while(n<10 && n>0)

1）while使用跟java一模一样
2）注意点：在scala里面不支持 i++ i-- 等操作
统一写成 i-=1

3方法和函数

• 方法和函数的作用几乎是一样的,但是函数在使用的过程中更加灵活和多样化
• scala中函数是头等公民 . 可以作为方法的返回值和参数使用
• scala是一个集面向对象和面向函数于一身的多范式编程语言 , 灵活的函数是函数式编程的一种体现
• 函数的使用使代码更加的简介和灵活

3.1函数

scala中一种函数式编程语言 ,函数是scala中的头等公民,建议优先使用函数 , 函数实现的功能和方法一样 ,但是我们可以把函数理解成一种特殊的业务逻辑对象 ,所以函数可以作为参数和返回值… 函数也是用来处理数据的代码封装

普通函数

• 方式一
  val| var 函数名称=（函数的参数列表） => 函数体

val add = (x: Int, y: Int) => {
  x + y
}
//  函数体中的内容只有一行代码可以省略大括号
 var product = (x:Double) => x*x

• 方式二

val | var 函数名称：（输入参数类型）=> 返回值类型 = （参数的引用）=> 函数体

val add2:(Int,Int)=>Int=(x,y)=>{
  x+y
}

没有参数的特殊函数

 val show:()=>Unit=()=>{
   println("show.....")
 }

总结:

• 函数中的参数;列表可以有多个,也可以没有参数 ,没有参数的函数调用的时候不用写()
• 函数的参数和返回值可以是值类型,也可以是引用类型, 方法的参数和返回值有一个是函数的方法就是高阶函数(方法)
• 函数的最后一行为推断函数返回值的重要依据 , 可以省略return 函数中可以在声明函数

3.2方法

方法是逻辑片段的封装 ,可以处理一个或者多个数据 , 可以有返回值也可以没有没有返回值 ,提高了代码的复用性
方法的定义

没有等号和方法体的方法称为抽象方法,抽象方法定义在抽象类和特质中

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

方法的调用

• 方法的调用和java中的调用方式不太一样
• 如果方法定义在object中 在本类直接方法名调用 在其他类中调用 object 对象名调用
• 如果方法定义在普通的class 类中 , 本类之间直接调用! 其他类中new 类 .方法调用

方法的嵌套
嵌套的方法必须指定返回值类型

def  factorial(x:Int):Int={
  def fact(x:Int ,y:Int):Int={
    if(x<=1) y
    else fact(x-1 , x*y)
  }
  fact(x,1)
}

方法总结
1，定义方法的关键字，def
2，方法的返回值，最后一行的内容，如果是循环，那么返回值是 Unit
3，如果空参方法，定义的时候有（），调用的时候可以省略（），但是如果定义的时候没有（），调用方法的时候，不能加（）
4，方法的返回值类型，可以省略，但是特殊情况下，必须加上：
4.1,方法有 return 关键字
4.2，递归调用的方法。
5，方法不能最为最终的表达式存在，（空参的方法调用除外）

函数和方法的互相转换

def add(x: Int, y: Int) = {
  x + y
}
// 将方法转换成函数
val f = add _

当我们将方法作为参传递的时候 ,其实底层是将方法自动转换成函数

方法和函数的区别和联系

1，方法用 def 关键字定义，函数的标识 =>
2，方法不能作为最终的表达式存在，但是函数可以，返回函数的签名信息
3，方法和函数调用的时候都需要显示的传入参数
4，函数可以作为方法的参数，和返回值类型。