1.Scala概述

• scala是一门多范式编程语言，集成了面向对象编程和函数式编程等多种特性。
• scala运行在虚拟机上，并兼容现有的Java程序。
• scala源代码被编译成java字节码，所以运行在JVM上，并可以调用现有的Java类库。

2.第一个Scala程序

HelloScala.scala

object HelloScala{
    def main(args:Array[String]){
        println("HelloScala,I love you!")
    }
}

cmd --->e:--->scalac HelloScala.scala
运行过程需要先编译，再执行。

image.png

编译后生成2个文件

编译后生成的文件.png

image.png

3.Scala的基本语法

3.1 基本概述

  *Scala基本语法：
  * 区分大小写
  * 类名首字母大写（MyFirstScalaClass）
  * 方法名称第一个字母小写（myMethodName()）
  * 程序文件名应该与对象名称完全匹配
  *
  * def main(args:Array[String]):scala 程序从main方法开始执行，程序的入口
  *
  * Scala注释：分为单行注释 // 和多行注释 /*  */
  *
  * 引入:import java.util.HashMap
  * 如果想要引入包中的几个成员，可以使用selector(选取器)：
  * import java.awt.{color,Font}
  *
  * //重命名成员
  * import java.util.{HashMap => JavaHashMap}
  * //隐藏成员
  * 默认情况下，Scala总归引入 java.lang._、scala._和Predef._ 所以在使用的时候都是省去了scala.的
  *
  */

3.2 常用数据类型

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

3.3 变量声明

object VariableDemo {
  def main(args: Array[String]): Unit = {
    //使用val定义的变量值是不可变的，相当于java里用final修饰
    val i =1
    //使用var定义的变量是可变的，在Scala中鼓励使用val 方便垃圾回收
    val j =1
    //Scala编译器会自动推断变量的类型，必要的时候可以指定类型
    val str : String = "hello world"
    
  }

}

3.3 条件表达式

Scala的条件表达式比较简洁

object ConditionDemo {
  def main(args: Array[String]): Unit = {
    //赋 初值 x
    val x = 1
    //判断x的值，并将结果赋值给y
    val y = if(x>0) 1 else -1
    //打印y值
    println(y)


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

    //在Scala中 每一个表达式都有值，scala中有一个Unit类，写作（）,相当于Java中的void
    //如果缺失else 相当于 val m = if(x >2) 1  else ()
    val m = if(x >2) 1
    println(m)

    //if 和 else if 的混用
    //如果x<0 返回0
    //如果0<=x<1,返回-1
    //如果x>=1返回1
    val k = if(x <0 ) 0 else if (x>=1) 1 else -1
    println(k)

  }

}

运行结果

image.png

3.4 访问修饰符

Scala访问修饰符和Java基本一样，分别有private、protected、public。
默认情况下，Scala对象的访问级别是public
(1) 私有对象
用private关键字修饰的成员仅在包含了成员定义的类或对象内部可见。

object Outer {
  class Inner{
    def start() = println("start")
    def end()=println("end")
   //将pause方法用private修饰
    private def pause() = println("pause")
  }

  def main(args: Array[String]): Unit = {
    new Inner().start()
    new Inner().
    new Inner().end()
  }

}

image.png

(2) protected
和私有成员类似，Scala的访问控制比Java来说稍显严格，在Scala中，由protected定义的成员只能由定义该成员和其派生类型访问。而在Java中，由protected定义的成员可以由同一个包中的其他类型访问。在Scala中，可以通过该其他方式来实现这种功能。

class Super {
  protected def f() = println("f")

}

class Sub extends Super{
  //可以直接调用父类f()
  f() 
}
class Other{
  (new Super).f()//Error:f不可以访问到
}

(3) public
public访问控制为Scala定义的缺省方法，所以没有使用private和protected修饰的成员（定义的类和方法）都是”公开的“，这样的成员可以在任何地方被访问。Scala不需要使用public来指定”公开访问“修饰符。

注意：Scala中定义的类和方法默认都是public的，但在类中声明的属性默认是private的

(4) 作用保护域
作用域保护：Scala中，访问修饰符可以通过使用限定词强调
private[x] 或者protected[x]
private[x]：这个成员除了对[...]中的类或[...]中的包中的类及他么的伴生对象可见外，对其他的类都是private

3.5 Scala运算符

与Java一样，不过Scala的运算符实际上是一种方法。

3.6块表达式

object BlockExpressionDemo {
  def main(args: Array[String]): Unit = {
    val x=0
    //在Scala中{}中包括一系列的表达式，块中最后一个表达式的值就是块的值
    var result = {
      if(x <0){
        -1
      }else if(x >=1){
        1
      }else{
        "error"
      }

    }
    //result的值就是块表达式的值
    println(result)
  }

}

运行结果： error

3.7 循环

在Scala中有for循环和while循环，用for循环比较多
for循环语法结构： for( i < - 表达式/数组/集合)

object forDemo {
  def main(args: Array[String]): Unit = {

    //for (1 <- 表达式),表达式 1 to 10返回一个Range(区间)
    //每次循环将区间中的一个赋给i
    for (i <- 1 to 10)
      println(i)


    //for(i <- 数组)
    val  arr = Array("a","b","c")
    for (i <- arr)
      println(i)

    //高级for循环
    //每个生成器都可以带一个条件，注意：if前面没有分号

    for(i <- 1 to 3;j <- 1 to 3 if i !=j)
      print(10*i+j+"  ")
    println()
  /*运行结果：
    12 13  21 23  31 32
  */
    //for推导式：如果for循环的循环体以yield开始，则该循环会构造出一个集合
    //每次迭代生成集合中的一个值
    val v = for (i <- 1 to 10) yield i*10
    println(v)
    /*
    运行结果：Vector (10, 20, 30 ... 100)
     */
    
    //表示从1 到 2 不包括3  
    for (i<- 1 until(3))
      print(i+"  ") // 运行结果： 1  2 
  }

}

总结：
1）在scala里没有运算符，+-*/%等操作符实际上都是方法，例如：a+b 是如下方法调用的简写： a+(b)

2. 在scala中没有++ --的用法
   3）for(i <- 表达式/数组/集合)
   4）在for循环里面可以添加if表达式
   5）有两个特殊的表达式需要了解：
   To 1 to 3 1 2 3 包括3
   Until 1 Until 3 1 2 不包括3
3. 如果在使用for循环的时候，可以伴随使用yield关键字对结果进行收集。

4.方法和函数

4.1 定义方法

image.png

方法的返回值类型可以不写，编译器可以自动推断出来。但是对于递归函数，必须指定返回类型

4.2 定义函数

image.png

4.3 方法和函数的区别

在函数式编程语言中，函数是“头等公民”，它可以像任何其他数据类型一样被传递和操作
案例：首先定义一个方法，在定义一个函数，然后将函数传递到方法里面。

image.png

object TestScala {
  //定义一个方法
  //方法m1参数要求是一个函数，函数的参数必须是两个Int类型
  def m1(f:(Int,Int) => Int):Int = {
    f(2,6)
  }
  //定义一个函数f1,参数是两个Int类型。返回值是一个Int类型
  val f1 = (x:Int,y:Int) =>x+y

  //定义一个函数f2
  val f2 =(m:Int,n:Int)=> m * n

  //main方法
  def main(args: Array[String]): Unit = {
    //调用m1方法，并传入f1函数
    val r1 = m1(f1)
    println("r1="+r1) //运行结果：r1 = 8

    //调用m1方法，并传入f2函数
    val r2 = m1(f2) //运行结果： r2 = 12

    println("r2 ="+r2)

  }

}

4.4 将方法转换为函数

image.png