Scala：(二) 语言基础-数据结构、表达式(判断、循环、块表达式)

变量和常量

定义变量和常量

变量：用var修饰，其值可修改
常量：用val修饰，其值不可修改

/**
     * 定义变量和常量
     * 变量 :用 var 定义 ，可修改
     * 常量 :用 val 定义，不可修改
     */
    val a = "张三"
    var b = "李四"

类和对象

类的定义
创建类

class Person{
  val name = "zhangsan"
  val age = 18
  def sayName() = {
    println("my name is "+ name)
  }
}

创建对象
对象的定义

object Lesson_Class {
   def main(args: Array[String]): Unit = {
    val person = new Person()
    println(person.age);
    println(person.sayName())
  }
}

1、建议类名首字母大写 ，方法首字母小写，类和方法命名建议符合驼峰命名法。
2、scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类。object不可以传参数。另：Trait不可以传参数
3、scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。
重写构造函数的时候，必须要调用默认的构造函数。
4、class 类属性自带getter ，setter方法。
5、使用object时，不用new,使用class时要new ,并且new的时候，class中除了方法不执行，其他都执行。
6、如果在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类。可以互相访问私有变量。

伴生类和伴生对象
两者可以互相访问对方的私有变量和属性

class Person(xname :String , xage :Int){
  var name = Person.name
  val age = xage
  var gender = "m"
  def this(name:String,age:Int,g:String){
    this(name,age)
    gender = g
  }
  
  def sayName() = {
    "my name is "+ name
  }

}

object Person {
  val name = "zhangsanfeng"
  
  def main(args: Array[String]): Unit = {
    val person = new Person("wagnwu",10,"f")
    println(person.age);
    println(person.sayName())
    println(person.gender)
  }
}

数据类型

Scala全部数据类型

Scala和Java一样，有着相同的数据类型，其上所有数据类型的关系为：

Null : Trait,其唯一实例为null，是AnyRef的子类，不是AnyVal的子类
Nothing： Trait，所有类型（包括AnyRef和AnyVal）的子类，没有实例
None：Option的两个子类之一，另一个是Some，用于安全的函数返回值
Unit: 无返回值的函数类型，和java的void对应
Nil: 长度为0的List
为何如此设计，补全

Scala常用数据类型

Scala和Java一样，有7种数值类型Byte、Char、Short、Int、Long、Float和Double（无包装类型）和一个Boolean类型

补充其使用方式

表达式

条件表达式

判断

if(布尔表达式 1){
   // 如果布尔表达式 1 为 true 则执行该语句块
}else if(布尔表达式 2){
   // 如果布尔表达式 2 为 true 则执行该语句块
}else {
   // 如果以上条件都为 false 执行该语句块
}
eg:
    val age =18 
    if (age < 18 ){
    	println("no allow")
    }else if (18<=age&&age<=20){
    	println("allow with other")
    }else{
    	println("allow self")
    }

循环

for循环和for推导式

依据yield是否存在，for表达式可以归结为两种基本形式。

1. for推导式(for comprehension)
2. for循环(for loop)

for循环
for循环语法结构：for (i <- 表达式/数组/集合)
**to 和 util的用法

to: 1 to 10 返回1到10的Range数组，包含10
util: 1 until 10 返回1到10的Range数组 ，不包含10

println(1 to 10 )      //打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
println(1.to(10))      //与上面等价，打印 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
    
println(1 to (10 ,2))  //步长为2，从1开始打印 ，1,3,5,7,9
println(1.to(10, 2)) 
    
println(1 until 10 )  //不包含最后一个数，打印 1,2,3,4,5,6,7,8,9
println(1.until(10))  //与上面等价
    
println(1 until (10 ,3 ))//步长为2，从1开始打印，打印1,4,7
# for循环示例：
for( i <- 1 to 10 ){
      println(i)
    }

for循环实例：打印九九乘法表

def main(args: Array[String]): Unit = {
    for(i <- 1 until 10 ;j <- 1 until 10){
      if(i>=j){
        print(i +" * " + j + " = "+ i*j+"	")
      }
      if(i==j ){
        println()
      }
    }
  }

多层for循环与java不同，可以分号隔开，写入多个list赋值的变量，构成多层for循环
scala中不能使用count++，count—只能使用count = count+1 ，count += 1

for循环中也可添加条件判断,在括号中用分号隔开即可

for(i<- 1 to 10 ;if (i%2) == 0 ;if (i == 4) ){
      println(i)
}

for推导式
如果for表达式存在yield子句，则称该for表达式为for推导式。它最终将使用yield子句收集结果，并将其作为for表达式的值。

将for中的符合条件的元素通过yield关键字返回成一个集合
每次迭代生成集合中的一个值

    val v = for (i <- 1 to 10) yield i * 10
    println("v:" + v)

    val list = for(i <- 1 to 5  ; if(i > 2 )) yield i
    println(list)
    for( w <- list ){
      println(w)
    }

while和do...while

while（）{}，
do {}while()

    var index = 0 
    while(index < 100 ){
    	println("第"+index+"次while 循环")
      index += 1 
    }
    index = 0 
    do{
    	index +=1 
    	println("第"+index+"次do while 循环")
}while(index <100 )

Scala 不支持 break 或 continue 语句，但是你在 Scala 2.8 版本后可以使用另外一种方式来实现 break 语句。当在循环中使用 break 语句，在执行到该语句时，就会中断循环并执行循环体之后的代码块。
待完善

块表达式

在scala中{}中可包含一系列表达式，块中最后一个表达式的值就是块的值，如下是一个示例：

    val x = 0
    val result = {
      if (x < 0){
        -1
      }  else {
        "error"
      }
    }
    //result的值就是块表达式的结果
    println(result) // 此处输出 error