scala的根本语法

注释

关于scala的注释，简而言之便是一句话，和java的注释如出一辙
根本语法

（1）单行注释：//
（2）多行注释：/* */
（3）文档注释：/**
              *
              */

代码示例：

package com.doitedu.demo01
object TestNotes {
 def main(args: Array[String]): Unit = {
 //（1）单行注释：//
 println("涛哥")
 
 //（2）多行注释：/* */
 /*
 println("涛哥")
 println("行哥")
 */
 
 //（3）文档注释：
 /**
 *
 */
 /**
 * println("乃哥")
 * println("雨哥")
 * println("行哥")
 */
   } 
} 

变量和常量（要点）

// 回忆：Java 变量和常量语法
// 变量类型 变量称号 = 初始值 
int a = 10
// final 常量类型 常量称号 = 初始值 
final int b = 20
scala界说变量常量的根本语法
Scala
// var 变量名 [: 变量类型] = 初始值 
var i:Int = 10   variable ：可变的
// val 常量名 [: 常量类型] = 初始值 
val j:Int = 20   value ：值

var variable  可变的   代表声明变量

val  value  值    代表声明常量

留意：
• val 在编程的过程中咱们大部分的操作是获取值或许是获取一个创建好的目标,然后操作目标中的特点,很少改动这个目标变量
• val 是线程安全的 , 在运用的时分功率更高
• 优先运用val ,可是当变量后续的需求改动的时分运用var

package com.doitedu.demo02
object TestVar {
 def main(args: Array[String]): Unit = {
 //（1）声明变量时，类型能够省掉，编译器主动推导，即类型推导
     var age = 18
     age = 30
 //（2）类型确认后，就不能修正，阐明 Scala 是强数据类型言语。
// age = "zhangsan" // 过错
 //（3）变量声明时，有必要要有初始值
// var name //过错
//（4）在声明/界说一个变量时，能够运用 var 或许 val 来润饰，var 润饰的变量可改动，val 润饰的变量不行改。
 var num1 = 10 // 可变
 val num2 = 20 // 不行变
 num1 = 30 // 正确
 //num2 = 100 //过错，由于 num2 是 val 润饰的
     } 
}


object demo03{
 def main(args: Array[String]): Unit = {
 // p1 是 var 润饰的，p1 的特点能够变，并且 p1 自身也能够变
 var p1 = new Person()
 p1.name = "zhangsan"
 p1 = null
 // p2 是 val 润饰的，那么 p2 自身就不行变（即 p2 的内存地址不能变），
可是，p2 的特点是能够变，由于特点并没有用 val 润饰。
 val p2 = new Person()
 p2.name="jinlian"
// p2 = null // 过错的，由于 p2 是 val 润饰的
 } 
}
class Person{
 var name : String = "jinlian"
} 

练一练：
多易现在开售了一个小讲堂来卖课(小型的电商渠道)：
关于出售这块而言，咱们是不是要存在一些特点字段：
店肆称号：多易教育
课程称号：java根底,mysql,hadoop.....
讲课教师：源哥,涛哥,星哥,行哥
课程的价格：199,299,399,99
红包类型: 初次购买红包,老学员红包
红包金额：9.9 18.8
活动称号：老用户再次购买,新用户初次购买,学员引荐购买
活动类型：6.18 10.24 11.11
活动扣头力度：9折 5折 8.8折
购买用户用户名：zhangsan，lisi
用户手机号：18860875775，18860875776
用户现在的职位：etl工程师，大数据开发工程师，数仓工程师
用户的邮箱：email
订单号：111122223333
订单金额：398
代码：

package com.doitedu

object demo01{

  /**
   * 店肆称号：多易教育
   * 课程称号：java根底,mysql,hadoop.....
   * 讲课教师：源哥,涛哥,星哥,行哥
   * 课程的价格：199,299,399,99
   * 红包类型: 初次购买红包,老学员红包
   * 红包金额：9.9  18.8
   * 活动称号：老用户再次购买,新用户初次购买,学员引荐购买
   * 活动类型：6.18     10.24  11.11
   * 活动扣头力度：9折   5折   8.8折
   * 购买用户用户名：姜海涛，江一
   * 用户手机号：18860875775，1886087，5776
   * 用户现在的职位：etl工程师，大数据开发工程师，数仓工程师
   * 用户的邮箱：email
   * 订单号：111122223333
   * 订单金额：119.4
   */
  def main(args: Array[String]): Unit = {
    //店肆称号：多易教育
    val shopName = "多易教育"
    //课程称号：java根底,mysql,hadoop.....
    val subjectName = "java根底"
    //讲课教师：源哥,涛哥,星哥,行哥
    val tName = "涛哥"
    //课程的价格：199,299,399,99
    val subjectPrice = 199.00
    //红包类型: 初次购买红包,老学员红包
    val bonusType = "new"
    //红包金额
    val bonus = 9.9
    //活动称号
    val activeName = "老用户再次购买"
    //活动类型：6.18     10.24  11.11
    val activeType = "程序员节"
    //活动扣头力度
    val activeDiscount = 0.6
    //购买用户用户名
    val userName = "haiTao Jiang"
    //用户手机号
    val tel = "13372090488"
    //用户邮箱
    val email = "[email protected]"
    //订单号
    val orderId = "111122223333"
    //订单金额
    val orderAmount = 119.4
  }

}

标识符的命名标准

Scala 对各种变量、办法、函数等命名时运用的字符序列称为标识符。即：但凡自己可
以起姓名的当地都叫标识符。
命名规矩：
Scala 中的标识符声明，根本和 Java 是一起的，可是细节上会有所改动，总结后有三点：

1. 以字母或许下划线最初，后接字母、数字、下划线 正常情况下：字母加下划线偶然来个数字
2. 以操作符最初，且只包括操作符（+ - / # !等）
3. 用反引号....包括的恣意字符串，即便是 Scala 关键字（39 个）也能够

• package, import, class, object, trait, extends, with, type, for
• private, protected, abstract, sealed, final, implicit, lazy, override
• try, catch, finally, throw
• if, else, match, case, do, while, for, return, yield
• def, val, var
• this, super
• new
• true, false, null

练一练：
需求：判别 hello、Hello12、1hello、h-b、x h、h_4、ab、Int、、+-/#!、+-/#!1、if、if，这些姓名是否合法。

object Test01 {
 def main(args: Array[String]): Unit = {
 // （1）以字母或许下划线最初，后接字母、数字、下划线
 var hello: String = "" // ok
 var Hello12: String = "" // ok
 var 1hello: String = "" // error 数字不能最初
 var h-b: String = "" // error 不能用-
 var x h: String = "" // error 不能有空格
 var h_4: String = "" // ok
 var _ab: String = "" // ok
 var Int: String = "" // ok 由于在 Scala 中 Int 是预界说的字符,不是关键字，但不引荐
 var _: String = "hello" // ok 独自一个下划线不能够作为标识符，由于_被认为是一个办法println(_)
 //（2）以操作符最初，且只包括操作符（+ - * / # !等）
 var +*-/#! : String = "" // ok
 var +*-/#!1 : String = "" // error 以操作符最初，有必要都是操作符
 //（3）用反引号`....`包括的恣意字符串，即便是 Scala 关键字（39 个）也能够
 var if : String = "" // error 不能用关键字
 var `if` : String = "" // ok 用反引号`....`包括的恣意字符串,包括关键字
 } 
}

字符串输出

根本语法：

1. 字符串，经过+号衔接
2. printf 用法：字符串，经过%传值。
3. 字符串模板（插值字符串）：经过$获取变量值

代码测验：

package com.doitedu.demo04
object TestString{
 def main(args: Array[String]): Unit = {
 var name: String = "jinlian"
 var age: Int = 18
 
 //（1）字符串，经过+号衔接
 println(name + " " + age)
 
 //能够用$来引证变量，大括号{}能够写也能够不写，假如不写，中心要用空格离隔
//最前面小写的s便是固定写法，写了他相当于便是一个模板字符串，咱们能够用$去引证变量了
println(s"${name}本年${age}岁了")
 
 //（2）printf 用法字符串，经过%传值。 他是不换行的，假如需求换行，那么要用\r\n来写在结尾换行
 printf("name=%s age=%d\r\n",name,age)
 
 val price = 119.99
printf("这个产品的价格是%.2f",price)

 //（3）字符串，经过$引证
//多行字符串，在 Scala中，运用三个双引号围住多行字符串就能够完成。
//输入的内容，带有空格、\t 之类，导致每一行的开端方位不能整齐对齐。
//运用 scala 的 stripMargin 办法，在 scala 中 stripMargin 默许
是“|”作为衔接符，//在多行换行的行头前面加一个“|”符号即可。
val sql =
  """
    |select
    |name,
    |count(1) as cnt
    |from
    |table_a
    |where name = "zhangSan"
    |and age = 18
    |group by name;
    |""".stripMargin
println(sql )
//假如需求对变量进行运算，那么能够加${}
val sql01 =
  """
    |select
    |name,
    |count(1) as cnt
    |from
    |table_a
    |where name = "$name"
    |and age = ${age+2}
    |group by name;
    |""".stripMargin
 println(sql01 )
 val s2 = s"name=$name"
 println(s2)
 } 
}

printf中格式化输出的模板
 %d 十进制数字
 %s 字符串
 %c 字符
 %e 指数浮点数
 %f 浮点数
 %i 整数（十进制）
 %o 八进制
 %u 无符号十进制
 %x 十六进制

数据类型（要点）

Java根本类型：char、byte、short、int、long、float、double、boolean
Java引证类型：（目标类型）
Java根本类型的包装类：Character、Byte、Short、Integer、Long、Float、Double、Boolean
由于Java有根本类型，并且根本类型不是真实含义的目标，即便后边产生了根本类型的包装类，可是依然存在根本数据类型，所以Java言语并不是真实意思的面向目标。
• scala中的数据类型和java中数据类型最大的差异便是scala中的数据类型都是目标 , 也便是scala中没有原生的数据类型!
• scala中的数据类型分红两类 AnyVal(值类型)和AnyRef(引证类型) , 两种目标都归于Any ,都是目标
val age:Int = 23
age是一个Int数值类型的变量 , 数值类型的变量也归于一个目标 , 所以age变量便是一个目标,也具有许多办法
留意：Java中根本类型和引证类型没有一起的先人。

1. Any : 一切类型的父类 , 类似于java中的Object
2. AnyVal: 数值类型(简略类型) ==-》 对应的是java中的根本数据类型
3. AnyRef: 引证数据类型
4. Null: 引证类型的子类,类似于java中的null ==》 写了一个类，将null这个值封装在了这个Null里边
5. Unit：对应Java中的void，表明办法没有回来值 ,他的值：（） ==》 由于针对这个目标，重写了toString 办法
6. Nothing: 所类型的子类，首要用在一个函数没有清晰回来值时运用，一般反常时运用,表明此处有错

数据类型具体表：

Unit 类型、Null 类型和 Nothing 类型

类型转化

当Scala 程序在进行赋值或许运算时，精度小的类型主动转化为精度大的数值类型，这
个便是主动类型转化（隐式转化）。数据类型按精度（容量）巨细排序为：

阐明：

1. 主动提高准则：有多种类型的数据混合运算时，体系首要主动将一切数据转化成精度大的那种数据类型，然后再进行核算。
2. 把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行主动类型转化。toInt toDouble
3. (byte，short)和 char 之间不会彼此主动转化。
4. byte，short，char 他们三者能够核算，在核算时首要转化为 int 类型。

测验事例：

object Test {
 def main(args: Array[String]): Unit = {
 //（1）主动提高准则：有多种类型的数据混合运算时，体系首要主动将一切数据转化成精度大的那种数值类型，然后再进行核算。
 var n = 1 + 2.0
 println(n) // n 便是 Double
 //（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行主动类型转化。
 var n2 : Double= 1.0
 //var n3 : Int = n2 //过错，原因不能把高精度的数据直接赋值和低精度。
 //（3）（byte，short）和 char 之间不会彼此主动转化。
 var n4 : Byte = 1
 //var c1 : Char = n4 //过错
 var n5:Int = n4
 //（4）byte，short，char 他们三者能够核算，在核算时首要转化为 int类型。
 var n6 : Byte = 1
 var c2 : Char = 1
 // var n : Short = n6 + c2 //当 n6 + c2 成果类型便是 int
 // var n7 : Short = 10 + 90 //过错
 } 
}

运算符

算术运算符

测验代码：

object Test {
  def main(args: Array[String]) {
    var a = 10;
    var b = 20;
    var c = 25;
    var d = 25;
    println("a + b = " + (a + b) );
    println("a - b = " + (a - b) );
    println("a * b = " + (a * b) );
    println("b / a = " + (b / a) );
    println("b % a = " + (b % a) );
    println("c % a = " + (c % a) );
  }
}

联系运算符

代码测验：

def main(args: Array[String]) {
  var a = 10;
  var b = 20;
  println("a == b = " + (a == b) );
  println("a != b = " + (a != b) );
  println("a > b = " + (a > b) );
  println("a < b = " + (a < b) );
  println("b >= a = " + (b >= a) );
  println("b <= a = " + (b <= a) );
}

逻辑运算符

代码测验：

val a = true
val b = false

println("a && b = " + (a && b))//false

println("a || b = " + (a || b))//true

println("!(a && b) = " + !(a && b))//true

赋值运算符

留意：scala中是没有++ -- 替换 += -=

代码测验：

object Test {
 def main(args: Array[String]): Unit = {
 var r1 = 10
 r1 += 1 // 没有++
 r1 -= 2 // 没有--
 }
}

位运算符

测验代码：

object TestPosition {
 def main(args: Array[String]): Unit = {
 // 测验：1000 << 1 =>10000
 var n1 :Int =8
 n1 = n1 << 1
 println(n1)  //16 
 } 
} 

优先级

流程操控

Scala中的流程操控和java根本一起

规模数据循环（To）

根本语法

for(i <- 1 to 10){
  println(i)
}

（1）i 表明循环的变量，<- 规则 to 
（2）i 将会从 1-3 循环，前后闭合

需求：输出 5 句 "hello world"

object TestFor {
 def main(args: Array[String]): Unit = {
 for(i <- 1 to 5){
 println("hello  world"+i)
 }
 } 
}

规模数据循环（Until）

根本语法：

for(i <- 1 until 5) {
    println(i)
}

（1）这种方法和前面的差异在于 i 是从 1 到 5-1 即[0,5)
（2）即便前闭合后开的规模
操练：
需求：用until输出 5 句 "hello  world"
Scala
object TestFor {
 def main(args: Array[String]): Unit = {
 for(i <- 1 until 5+1){
 println("hello  world"+i)
 }
 } 
}

循环护卫

根本语法

for(i <- 1 to 3 if i != 2) {
     println(i)
}

// 循环护卫，即循环维护式（也称条件判别式，护卫）。维护式为 true 则进入循环体内部，为 false 则越过，类似于 continue。 
// 代码等价：

for (i <- 1 to 3){
    if (i != 2) {
        print(i + " ")
    } 
}    

// 需求：输出 1 到 5 中，不等于 3 的值
object TestFor {
 def main(args: Array[String]): Unit = {
 for (i <- 1 to 5 if i != 3) {
 println(i + "doit")
 }
 } 
} 

循环步长
根本语法:
阐明：by 表明步长

    for (i <- 1 to 10 by 2) {
     println("i=" + i)
    }

// 需求：输出 1 到 10 以内的一切奇数
for (i <- 1 to 10 by 2) {
println("i=" + i)
}

成果：
i=1
i=3
i=5
i=7
i=9

引进变量：

根本语法：

for(i <- 1 to 3; j = 4 - i) {
 println("i=" + i + " j=" + j)
}

阐明：
（1）for 推导式一行中有多个表达式时，所以要加 ; 来间隔逻辑
（2）for 推导式有一个不成文的约好：当 for 推导式仅包括单一表达式时运用圆括号，当包括多个表达式时，一般每行一个表达式，并用花括号替代圆括号，如下
举例：

for {
 i <- 1 to 3
 j = 4 - i
} {
 println("i=" + i + " j=" + j)
} 
// 等价得代码：
Scala
for (i <- 1 to 3) {
 var j = 4 - i
 println("i=" + i + " j=" + j)
}

循环回来值

根本语法：

val res = for(i <- 1 to 10) yield i
println(res)
// 阐明：将遍历过程中处理的成果回来到一个新 Vector 调集中，运用 yield 关键字。

// 操练：需求：将原数据中一切值乘以 2，并把数据回来到一个新的调集中。
object TestFor {
 def main(args: Array[String]): Unit = {
     var res = for(i <-1 to 10) yield {
         i * 2
     }
     println(res)
 } 
}

输出成果：
Vector(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)

倒序打印

阐明：假如想倒序打印一组数据，能够用 reverse。
需求：倒序打印 10 到 1

for(i <- 1 to 10 reverse){
 println(i)
}

循环中止

根本阐明:
Scala 内置操控结构特地去掉了 break 和 continue，是为了更好的习惯函数式编程，引荐运用函数式的风格处理break和continue的功用，而不是一个关键字。Scala中运用breakable操控结构来完成 break 和 continue 功用。

方法 1：选用反常的方法退出循环

object Demo_while {
  def main(args: Array[String]): Unit = {
    try {
      for (emel <- 1 to 10) {
        println(emel)
        if (emel == 5) {
          throw new RuntimeException
        }
      }
    } catch {
      case e: Exception =>
    }
    println("hello")
  }
}

方法 2：选用 Scala 自带的函数，退出循环

import scala.util.control.Breaks

object Demo_while {
  def main(args: Array[String]): Unit = {
    Breaks.breakable(
      for (emel <- 1 to 10) {
        println(emel)
        if (emel == 5) {
          Breaks.break()
        }
      }
    )
    println("正常完毕循环")
  }
}

对breaks进行省掉

object Demo_while {
  def main(args: Array[String]): Unit = {
    breakable(
      for (emel <- 1 to 10) {
        println(emel)
        if (emel == 5) {
          break()
        }
      }
    )
    println("正常完毕循环")
  }
}