Scala--基础语法★★★★★

变量

• 声明变量
• 1.var&val
  • var：可以重新赋值
  • val：不可变变量/只读变量，相当于java中final修饰的变量
• 2.为减少可变性引起的bug，尽可能使用不可变变量
• 3.type关键字可以声明一个类型别名
  • String底层是 type String= java.lang.String
• 4.懒值lazy适合初始化开销大的场景，只有这个变量真正被使用，变量的赋值代码才会真正执行
  

package cn.hanjiaxiaozhi.basic

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 11:19
 * Desc 演示Scala变量定义
 */
object _01_VariableDemo {
  def main(args: Array[String]): Unit = {
    //1.变量的定义格式
    //val或var 变量名:类型 = 变量值
    //:类型可以省略,但是初学建议加上,更加清晰

    val name:String = "jack"
    var age:Int = 18

    //name = "jack ma" //错误,val修饰的变量不能被重新赋值,类似Java中final修饰的
    age = 20 //正确,var修饰的变量可以被重新赋值

    //开发中优先使用val修饰,如果不满足需求再使用var修饰
    //因为scala更多使用场景在大数据分布式领域,使用val修饰变量,更加安全

    println(name)
    println(age)
    
    
    //2.扩展-type关键字
    type myS = String
    val myname:myS = "tom"
    //表示tom是myS类型,而myS类型在上面使用type关键字定义了是String类型
    //而String底层是 type String= java.lang.String


    //3.扩展-lazy-懒值
    lazy val msg = init()//lazy修饰的变量会被懒执行,就是用到的才执行
    println("init方法调用了,但是没有真正的执行")//1
    println("直到真正使用到msg的时候init方法才执行"+msg)//3

  }
  def init():Unit ={
    println("init方法真正执行了")//2
    "success"
  }
  }
}

数据类型

• Scala中的数值类型和Java中的基本数据类型类似,但是都是对象类型,也就是说Scala才是真正的万物皆对象!
• Any是根节点,包括:
  • 数值类型–AnyVal是所有值类型的基类

Boolean	true 或者 false
Byte	8位, 有符号
Short	16位, 有符号
Int	32位, 有符号
Long	64位, 有符号
Char	16位, 无符号
Float	32位, 单精度浮点数
Double	64位, 双精度浮点数
String	其实就是由Char数组组成

• 引用类型–AnyRef是所有引用类型的基类(除了值类型，所有其他类型都继承自AnyRef)
• 比较特殊的几个类型
  • Null：只有一个实例对象,null（只能赋值给引用类型，而不能赋值给值类型）
  • Nothing：没有实例（可以作为没有正常返回值的方法的返回类型）
  • Unit：类似java中的void,只有一个对象实例（）
    

package cn.hanjiaxiaozhi.basic

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 11:36
 * Desc 
 */
object _02_TypeDemo {
  def main(args: Array[String]): Unit = {
    val a:Byte = 1
    val b:Short = 2
    val c:Int = 3
    val d:Long = 4
    //.....
    val cc:Char = '1'
    val s:String = "abc"

  }
}

String类型

• 1.双引号：

val/var 变量名 = "字符串"

• 2.三引号：

val/var 变量名 = """字符串1字符串2"""

• 3.插值表达式：

val/var 变量名 = s"${变量/表达式}字符串"

• 注意:s不能省略,不然识别不了$

package cn.hanjiaxiaozhi.basic

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 11:43
 * Desc 
 */
object _03_StringDemo {
  def main(args: Array[String]): Unit = {
    //定义字符串也是用val/var
    //但是字符串得用" "或者""" """引起来

    //1." "
    val s1:String = "str1"

    //2.""" """
    val s2:String ="""这里可以写很多字符串"""
    val s3:String ="""这里可以写很多字符串,
                      |还可以换行写""".stripMargin
    //3.使用插值表达式
    val name:String = "jack"
    val s4 :String ="my name is " + name//以前的写法
    val s5 :String =s"my name is ${name}"//现在的写法，前面的s不能删除

    //4.""" """和插值表达式一起用
    val tableName :String= "student"
    val conditionValue:String = "tom"
    val sql1:String ="select * from student where name = 'tom';" //之前的写法
    val sql2:String =
      s"""
        |select *
        |from ${tableName}
        |where name = ${conditionValue};
        |""".stripMargin

    println(s1)
    println(s2)
    println(s3)
    println(s4)
    println(s5)
    println(sql1)
    println(sql2)

  }
}

操作符

• 和Java类似, + - * / % …
• 其他的位运算 逻辑运算符和Java都是一样的规则,
• 位操作符有 $ | ^ >> <<
• 注意:
  • 1.scala中的操作符实际上是方法
  • 2.scala中没有++ -- 操作符,需要通过+= -=来实现

package cn.hanjiaxiaozhi.basic

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 11:56
 * Desc 演示操作符
 */
object _04_OperatorDemo {
  def main(args: Array[String]): Unit = {
    //和Java类似, Scala也支持 + - * / % 等操作符,但是没有 ++和--
    var a:Int = 1 + 2
    //- * / %  一样使用
    //注意1:Scala万物皆对象,1也是对象,所以1+2可以这样写:
    var b = 1.+(2) //也表示1+2,但是一般不这么用,太别扭(其实通过这样的写法可以知道在Scala中运算符也是方法,那么既然是方法就支持方法重载)

    //注意2:不支持++和--
    //a++
    //a--
    //++a
    //--a
    a += 1
    b.+=(1)

    println(a)//4
    println(b)//4
  }
}

Java和Scala混编

package cn.hanjiaxiaozhi.basic

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 14:16
 * Desc 演示Scala和Java混编
 */
object TestComplex {
  def main(args: Array[String]): Unit = {
    println("Scala代码")
    System.out.println("Java代码")
  }
}


package cn.hanjiaxiaozhi.basic;

import scala.Console;

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 14:17
 * Desc java代码中混编scala
 */
public class TestComplex2 {
    public static void main(String[] args) {
        System.out.println("java");
        Console.println("scala");
    }
}

表达式

块表达式

• 1.最后一个表达式就是整个块表达式的值

package cn.hanjiaxiaozhi.basic

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 14:24
 * Desc 演示块表达式{}
 */
object _05_BlockExpressionDemo {
  def main(args: Array[String]): Unit = {
    val a:Int = 1
    val b:Int = 1
    val sum1:Int = a + b //2
    val sum2:Int = {a + b} //2
    val sum3:Int = {
      val c = a + b //2
      val d = a + c //3
      d//相当于return d //相当于sum3 = d //3
    }

    println(sum1)//2
    println(sum2)//2
    println(sum3)//3

    //上面的现象说明,{}块表达式的最后一行就是返回值

  }
}

判断

条件判断

• 1.与java不同,if else表达式有返回值
• 2.没有三元表达式
• 3.如果返回值类型不同,就返回Any类型;如果没有返回值类型,使用Unit,相当于java中的void

package cn.hanjiaxiaozhi.basic

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 14:28
 * Desc 演示条件表达式if-else....
 */
object _06_ConditionDemo {
  def main(args: Array[String]): Unit = {
    val age:Int = 18
    //普通的if-else
    if(age >= 18){
        println("已成年")
    }else{
      println("未成年")
    }

    //带返回值的if-else
    val result:String = if(age >= 18){
      "已成年"
    }else{
      "未成年"
    }
    println(result)

    //返回值的类型还可以不一样
    val result2:Any = if(age >= 18){
      1 //返回Int类型
    }else{
     "0"//返回字符串
    }
    println(result2)

    //也可以返回()表示Unit,类似与void
    val result3:Any = if(age < 18){
      1 //返回Int类型
    }else{
      ()//表示Unit,类似与void,表示没有返回值,没有返回值也是一种类型,因为万物皆对象
    }
    println(result3)
  }
}

循环

• i <- 1to/until 10 by 2
• 1.循环没有返回值
• 2.多重循环以分号隔开,与判断结合使用时不需要隔开
• 3.推导式yield可以生成新的一组数据

简单for循环：
for (变量 <- 表达式/数组/集合) {循环体}
for(i <- 1 to 10) println(i) 

●嵌套for循环
for (变量1 <- 表达式/数组/集合; 变量2 <- 表达式/数组/集合) {循环体}
for(i <- 1 to 9; j <- 1 to 9){
      if(i >= j ) print(s"${j} * ${i} = ${j*i}")
      if(j == 9) println()
    }
●守卫
for表达式中，可以添加if判断语句，这个if判断就称之为守卫。我们可以使用守卫让for表达式更简洁。
for(i <- 表达式/数组/集合 if 表达式) {循环体}
for(i <- 1 to 10 if i % 3 == 0) println(i)

●for推导式
在for循环体中，可以使用yield表达式构建出一个集合，我们把使用yield的for表达式称之为推导式
即可以使用for推导式生成一个新的集合（一组数据）
//该for表达式会构建出一个集合
val l = for(i <- 1 to 10) yield i * 10

package cn.hanjiaxiaozhi.basic

/**
 * Author hanjiaxiaozhi
 * Date 2020/7/13 14:35
 * Desc 演示循环表达式
 */
object _07_LoopDemo {
  def main(args: Array[String]): Unit = {
    //for循环
    //从1循环输出到10, [1,10]  === 掌握
    for (i <- 1 to 10) {
      println(i)
    }
    println("=====================")

    //从1循环输出到10, [1,10)
    //和to的区别在于Until是左闭右开
    for (i <- 1 until 10) {
      println(i)
    }
    println("=====================")

    //循环步长
    //从1循环输出到10,每次间隔2打印, [1,3,5,7,9]
    for (i <- 1 to 10 by 2) {
      println(i)
    }
    println("==========while循环===========")
    //while循环  === 掌握
    var a = 1;
    while (a <= 10) {
      println(a)
      a += 1
    }
    
    //后面的能看懂即可

    println("==========双层嵌套for循环完成99乘法表--写法1===========")
    //双层嵌套for循环
    for (i <- 1 until 10) {
      for (j <- 1 until 10) {
        if (i >= j) {
          print(s"${j}*${i}=${i * j}\t")
        }
      }
      println()
    }

    println("==========双层嵌套for循环完成99乘法表--写法2-更简洁但是可读性不好===========")
    for (i <- 1 to 9; j <- 1 to 9) {
      if (i >= j) {
        print(s"${j}*${i}=${i * j}\t")
      }
      if (j == i) {
        println()
      }
    }

    println("==========for循环和判断合并写===========")
    for(i <- 1 to 10 if i % 2 == 0) println(i)
    println("==========等价于下面的===========")
    for(i <- 1 to 10 ) {
      if (i % 2== 0) {
        println(i)
      }
    }


    println("==========注意:循环没有返回值===========")
    var n:Int = 1
    val result = while (n<=10){
      n+=1
      n
    }
    println(n)//11
    println(result)//() result为空说明循环没有返回值

    val result2 = for(i <- 1 to 10 ) {
      1
    }
    println(result2)//() result为空说明循环没有返回值
  }
}

循环中的break和continue

• scala并没有提供break和continue来退出循环
• 要想使用，可以导包
• import scala.util.control.Breaks._
• 详解：

实现break：

• 使用breakable将for表达式包起来

//打印1-100的数字，如果数字到达20，退出for表达式
    import scala.util.control.Breaks._
    breakable{
      for(i <- 1 to 100) {
        if(i >= 20)
          break()
        else
          println(i)
      }
    }

实现continue：

• breakable{}将for表达式的循环体包含起来

//打印1-100的数字，如果数字能整除10，不打印 
    for(i <- 1 to 100 ) {
      breakable{
        if(i % 10 == 0)
          break()
        else println(i)
      }
    }