Scala语言基础（一）

Scala

Scala的Hello World

1. Scala类及方法的定义

object HelloWorld {//object 定义了一个HelloWorld
  /**
   * def用于定义方法main(),
   * 其参数名称是args,参数是一个数组Array
   * 它是一个String类型的数组，String是泛型，
   * Unit代表无返回值，相当于Java的void
   */
  def main(args: Array[String]): Unit = {
    println("hello world")//输出到控制台
}

2. Java类及方法的定义

class helloWorld{// class定义一个helloWorld类
/**
* public定义方法的访问权限
* static定义方法的属性
* void代表方法无返回值
* main()是方法名
* args是方法的参数，该阐述是String数组类型的-String[]
* System.out.println("Hello World");将打印内容输出到控制台
* /
	public static void main(String[] args){
		System.out.println("Hello World");
	}
}

基本语法

1. 变量

Java中定义变量必须使用类型声明，但是Scala中不需要，Scala中只需使用两个关键字声明就行了，即：var和val

A. var

a. 由下图可以看到，可以不指定数据的类型，编译器会自己推断数据的类型；

b. 实际是可以指定类型的，指定类型后赋值的数据必须是指定的类型（Scala定义变量时和Java反过来了，而且变量名和定义类型之间有冒号隔开，和MySQL定义字段顺序相同，也是字段于类型之间多了一个冒号）否则会报错：

c. 在定义b的时候，虽然没有指定类型，但是编译器推断是String类型，这时变量b的数据类型就确定了，不能再赋值其他类型了，否则会报错
但由于b是var声明的变量，所以可以重新赋值，赋的值必须是已经确定好的类型；

当赋值类型不是它定义时指定或编译器推断出来的类型，就会报错

d. 当再次使用var时，就会重新定义变量覆盖之前的定义

B. val

val同样可以像var一样赋值

但是val定义的是常量，不能重新给常量赋新值，否则会报错
相当于Java中final修饰的非引用类型的常量（String类型除外），其值不可变

val所定义的常量可以被lazy修饰，它的作用是延迟初始化，当真真正使用的时候才将值赋给这个常量

C Scala中任何数据都是对象

对象可以调用相应的方法，如下图，可以将String类型的“1”转换为Int或Double类型：

++++++++++++

前面有个$，相当于执行："My name is " + s1

类型总览

简单解释：

1. 在Scala中Any是所有类型的父类，包括两大类型：值类型（AnyVal）和引用类型（AnyRef）；
2. AnyVal是所有值类型的父类，AnyRef是所有引用类型的父类，包括Null；
3. Nothing是所有类型的子类，包括Null，而Null是所有引用类型的子类；
4. Unit类型只有一个实例，是(),相当于Java中的void，没有任何的实际意义；
5. Null也只有一个实例，是null，与Java中的null对应，能复制给任何应用类型变量，不能赋值给值类型变量。

编码规范

1. 在Scala编码中，不强制在代码末尾加分号，但是如果有多句代码写在同一行，必须使用分号进行隔离
2. Scala 编程中，注释的方式和Java中是一样的
   其实，所有编译型语言的注释方式都和Java一样，而所有解释型语言的注释方式都和Python一样
3. 关键字
   

执行流程

1. if 进行分支控制

条件表达式

object Test{//object 定义了一个Test类
  def main(args: Array[String]): Unit = {
    var x = 2
    //判断x的值，将结果赋给y
    val y = if(x>0) 1 else -1
    //打印y的值
    println(y)

    //支持混合类型的表达式
    val z = if(x>1) 1 else "error"
    //打印z的值
    println(z)

    //如果缺失else，相当于if(x>2) 1 else ()
    val m = if(x>2) 1
    println(m)

    //在Scala中每个表达式都有值，Scala中有个Unit类，写作(),相当于Java中的void
    val n = if(x>2) 1 else ()
    println(n)

    //if和else if
    val k = if(x<0) 0
    else if(x>=1) 1 else -1
    println(k)
  }
}

块表达式

object BlockExpressionTest{//object 定义了一个BlockExpressionTest类
  def main(args: Array[String]): Unit = {
    val x = 0
    //在Scala的{}中可以包含一系列表达式，块中表达式判断的最终结果就是块最终返回的值
    val reslut ={
      if(x<0){
        -1
      } else if (x>=1){
        1
      } else{
        "error"
      }
    }
    //result结果就是块的返回值
    println(reslut)
  }
}

for 遍历/迭代

object ForTest{//object 定义了一个HelloWorld
  def main(args: Array[String]): Unit = {
    //定义一个集合
    var array = Array(5,4,3,2,1)

    println("******** for 直接遍历数组 ********")
    //<- 表示Scala中的generator, 即：提取符
    for(a <- array) println(a)

    println("******** for 产生一个新的数组 ********")
    for {a <- array
         a1 = a+1
         } yield(a1)//产生一个新的数组
    
    println("******** for 通过下标遍历数组 ********")
    for(i <- 0 until array.length) {println(array(i))}//通过数组下标遍历数组
  }
}

while 循环

object HelloWorld {//object 定义了一个HelloWorld
  def main(args: Array[String]): Unit = {
    //while 循环
    var array = Array(5,4,3,2,1)
    var i = 0
    while (i < array.length){
      println(array(i))
      i += 1
    }

    // do ... while 循环
    var j = 0
    do {
      println(array(j))
      j += 1
    } while (j < array.length)
  }
}

foreach迭代

object ForeachTest{//object 定义了一个ForeachTest
  def main(args: Array[String]): Unit = {
    var array = Array(5,4,3,2,1)
    array.foreach(println)//foreach接收了一个函数（println）作为值
  }
}