一 Scala概述

1.1 什么是Scala

1）Scala是一门完整的软件编程语言，那么连在一起就表示Scala是一门可伸缩的软件编程语言。之所以说它是可伸缩，是因为这门语言体现了面向对象，函数式编程等多种不同的语言范式，且融合了不同语言新的特性。
2）Scala编程语言是由联邦理工学院洛桑（EPFL）的Martin Odersky于2001年基于Funnel的工作开始设计并开发的。
3）由于Martin Odersky之前的工作是开发通用Java和Javac（Sun公司的Java编译器），所以基于Java平台的Scala语言于2003年底/2004年初发布。
4）Scala是一门完全面向对象编程的语言。

1.2 特点

1）Scala是一门以Java虚拟机为运行环境，并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言。
2）Scala代码会被编译成class字节码文件，然后运行于Java虚拟机之上，并且还可以调用现有的Java类库，实现两种语言的无缝对接。

1.3 案例

1）HaloWorld实例
注意：Scala是一个完全面向对象的编程语言，而Java语言并不是一个完全面向对象的编程语言。

object HaloWorld {
    /**
     * Scala是一门完全面向对象的编程语言
     * Java不是一门完全面向对象的编程语言，因为包含了静态语法
     * Object：scala语言没有静态语法，采用了object的方式模仿Java中的静态语法，这样就可以通过类名来访问方法
     * def：关键字，define的缩写，表示声明方法
     */
    def main(args: Array[String]): Unit = {
        System.out.println("halo Scala")
        println("Halo Java")
    }
}

①Object：Scala语言中没有静态的语法，采用的是Object的方式来模仿Java中的静态语法，通过类名来访问方法
②def：define缩写，表示声明方法的一个关键字
③args: Array[String]：参数声明==> 参数名：参数类型
④Array：Scala中的数组，类似于Java的中括号 [ ]
⑤[String]：表示泛型
⑥Unit：表示无返回值，不同于Java的void，Unit是一个类型，而Java中的void仅是一个关键字
⑦=：赋值，和Java一样。但是scala中方法也是对象，可以给变量赋值。在Scala中万物皆对象！！谨记！
⑧Scala语言是基于Java语言开发的，所以可以直接嵌入Java代码来执行的。而且Scala是可以导入一些对象，可以直接调用这个对象的方法，如 print()方法，可以在任何的对象中直接调用

二 变量和数据类型

2.1 注释

Scala的注释和Java的注释完全一样

• 单行注释

  object Comment {
    def main(args: Array[String]): Unit = {
        // print("halo world")
    }
  }

• 多行注释

  object Comment {
    def main(args: Array[String]): Unit = {
        /*
         * 多行注释
         */
    }
  }

• DOC文档注释

  object Comment {
    def main(args: Array[String]): Unit = {
        /**
         * 文档注释
         */
    }
  }

  2.2 变量

  2.2.1 语法

  1丶var 变量名称：变量类型 = 变量值
  2丶var 变量名称 = 变量值
  如果可以通过语法来推断出变量的类型，那么变量在声明时可以省略类型。但是需要注意，Scala和Java一样，是强类型语言，在编译时是必须要确定好变量的类型的。在声明变量时不指定变量的类型，前提条件就是从语法中必须可以推断出变量的类型来。

  object Comment {
    def main(args: Array[String]): Unit = {
        // 1 var 变量：类型 = 值
        var username: String = "lz"
        println(username)
        // 2 var 变量 = 值 (如果可以通过语法来推断出变量的类型，那么变量在声明的时候可以省略类型)
        var name = "kl"
        println(name)
    }
  }

  2.2.2 可变和不可变的变量

  概述：在Scala中，final不能直接修饰变量，为了让声明的变量不能发生改变，产生了新的关键字 val，它声明后的变量是无法被改变的。但是注意，Scala中的不可变变量并不是常量，这是本质区别，在本质上，不可变变量的本质还是变量。
  ①var 变量 ：变量类型 = 变量值
  ②val 变量：变量类型 = 变量值

  val lisi = "lisi"

  1）那么在Scala中，var和val哪一个更推荐使用呢？
  答案是val更推荐使用，因为来开发中，一般声明出的变量的值都不会改变了，改变的是变量的内容而已。
  2）Java中的字符串为什么被称为不可变字符串？
  答案是字符串变量指向的地址值不可变。String类一旦初始化了，他的底层数组也就固定了长度，存储的字符也就固定了，它并没有提供任何方法来改变字符串的内容，它提供的方法只是产生的新的字符串返回给方法的调用者。

  2.2.3 变量初始化

  在Java中，变量只要在使用前进行初始化即可，但是scala必须进行显式初始化，在声明的时候就就应该初始化。

  val name = "lz" //ok
  val age //Error

  2.3 标识符

  Scala可以使用两种形式的标识符：字符数字和符号
  1）字符数字就是以字母和或下划线开头，后面可以是字母或数字。$ 在scala中被看作是字母，然而以”$”开头的标识符为保留的 Scala 编译器产生的标志符使用，应用程序应该避免使用”$”开始的标识符，以免造成冲突。
  2）符号就是常用的符号，如：+，-，，/，#，@等的，没有规律，这些符号都可以作为标识符，但是注意只要idea不报错就可以使用。
  注意：
  ①Scala在起名的时候，随便起，报错就不用了
  ②常用于语法操作的符号不能用，如[]，{}，()，””，’’。
  ③Scala的标识符也不能是关键字和保留字
  问题：
  ->*如何在Java语言中访问Scala对象？

  // Scala代码
  object Variables {
  def :->(): Unit = {
    println("aaaa")
  }
  }
  // Java代码，访问scala中的:->() 方法
  public class Test1 {
    public static void main(String[] args) {
        Variables.$colon$minus$greater();//访问方式一
        Variables$.MODULE$.$colon$minus$greater();//访问方式二
    }
  }

  ->如果变量就想使用特定含义的关键字怎么办？
  可以在声明时给标识符加上 ``（给关键字加上飘号）

  def a(): Unit = {
  val `private`: Int = 10;
  println(`private`)
  }

  2.4 字符串

  Scala没有字符串类型，它的字符串来自于Java。因为Scala是基于Java开发的语言。
  所以在Scala中，字符串的操作和Java一样

  object StringTest {
    def main(args: Array[String]): Unit = {
        val name = "lz"
        println(name + "ll")
    }
  }

  2.5 Scala的数据类型

  概述：Scala是完全面向对象的语言，所以不存在基本数据类型的概念，有的只是任意值对象类型（AnyVal）和任意引用对象类型(AnyRef)
  
  
  Unit：是Scala的一个类型，对象只有一个：()。隶属于AnyVal的一个子类类型
  无论给它赋值什么，它都是：()
  作为函数的返回值类型时表示无返回值，可以看作是代替Java的void。

  object DataType {
  def main(args: Array[String]): Unit = {
    val a: Unit = 289 + 1
    println(a) //()
  }
  }

  Null：Scala将null作为一个特殊的对象进行处理，类型就是Null，Null和AnyVal类型无相关，不能被赋值给AnyVal变量

  val bb:Int= null //报错，null不能给AnyVal类型的变量进行赋值

  Nothing：无值
  ①没有意义，一般使用在抛异常的时候
  ②属于Scala中最底层的类型，是任何类型的子类型
  ③它的存在是为了满足Scala是完全面向对象的设计需求而存在
  字符串：
  scala是完全面向对象的语言，所有的类型都提供了toString方法，可以直接转换为字符串

  lon.toString

  任意类型都提供了和字符串进行拼接的方法

  val i = 10 val s = "hello " + i

  Scala中的 == 实际上就是equals()方法

  val a = new String("aaa") val b = new String("aaa")
  println(a == b)
  println(a.equals(b))

  eq()方法就是比较对象在内存中的地址

  println(a.eq(b))

  Any：表示任意类型，类似于Java的Object
  在Java中，Object类也是引用类型的父类，基本类与其也基本无关
  而Any则是满足了可以代表任意类，即数值类型和引用类型都可以指向

  三 运算符

  Scala中没有Java中的++，—，但是有使用 +=1，-=1来代替
  运算符本质
  本质：在Scala中其实是没有运算符的，所有运算符都是方法。
  ①数字其实是数值类型的对象
  ②运算符其实是对象的方法
  当方法的参数只有一个或者没有的时候，括号和点是可以省略的，用空格代替，这样也可以调用方法

  println(3.+(4)) //3+4
  println(3+4)
  println(3 toString) //调用数值类型的toString()方法

  四 流程控制

  4.1 分支控制

  和Java差不多，但是Scala的表达式是有返回值的，可以赋值给变量

  val b = if (a < 20) {
  18
  } else if (a < 50) {
  45
  } else if (a < 75) {
  65
  } else {
  87
  }

  4.2 循环控制

  4.2.1 for循环

  for ( 循环变量 <- 数据集 ) {
    循环体
  }

  for循环的三种使用方式： to，util，ange

  object ScalaLoop {
  def main(args: Array[String]): Unit = {
    for (i <- Range(1, 5)) { // 范围集合：1-4，4个元素
      println("i = " + i)
    }
    println("====================")
    for (i <- 1 to 5) { // 包含5
      println("i = " + i)
    }
    println("====================")
    for (i <- 1 until 5) { // 不包含5
      println("i = " + i)
    }
  }
  }

  循环守卫
  循环时可以增加条件来决定是否继续循环体的执行，这里的判断条件我们称之为循环守卫，当判断结果为true就执行循环体，false则跳过当前循环。

  for (i <- 1 until 5 if i % 2 != 0) {
  print(i)
  }

  循环步长
  Scala的集合也可以设定循环的增长幅度，也就是所谓的步长step，使用关键字by

  object ScalaLoop {
    def main(args: Array[String]): Unit = {
        for ( i <- Range(1,5,2) ) {
            println("i = " + i )
        }
        println("====================")
        for ( i <- 1 to 5 by 2 ) {
            println("i = " + i )
        }
    }
  }

  4.2.2 while循环

  语法 ```scala //方式1： while (循环条件表达式) { //循环体 }

//方式2： do { //循环体 }while (循环条件表达式)

**循环中断**：<br />在Java中，有使用continue，break两个关键字来中止循环，但是在Scala没有，所以一般在实现的方式都是使用抛异常的方式来终止循环，但是可以使用**Breaks.breakable**和**Breaks.break()**来优化操作<br />breakable是一个方法，{}大括号其实是一个参数列表，将一段代码的执行结果作为参数传递给一个方法。
```scala
object WhileTest {
    def main(args: Array[String]): Unit = {
        var a = 10
        Breaks.breakable{
            while (a > 0) {
                if (a == 5) {
                    Breaks.break()
                }
                println(a)
                a -= 1
            }
        }
    }
}