scala入门1-变量、运算符、流程控制

变量、运算符、流程控制

1、注释

scala的注释与java完全一样

/**
* java注释:
*   单行注释: //
*   多行注释: /*...*/
*   文档注释: /**..*/
* scala的注释与java完全一样
*/

2、命名

比java多，可以用特殊标识符做命名，比如+，但是此类为scala自己底层用

/**
* java中变量命名规范: 必须是字母、数字、下划线、$, 首字母不能是数字
* scala中变量的命名规范: 必须是字母、数字、下划线、$、一些特殊符号，首字母不能是数字
*   在变量命名的时候不建议使用特殊符号，而且企业中变量命名一般使用驼峰命名法
*/

3、变量定义

scala中 用val和var定义变量，其中val底层为final的，所以不能重新赋值，var才可以
scala中定义变量为 变量名:类型 ，与java相反

/**
* java中变量定义:  类型 变量名 = 值
*
* scala中变量定义语法:  val/var 变量名:变量类型 =  值
* val与var的区别:
*   val定义的变量不可以被重新赋值
*   var定义的变量可以被重新赋值
* scala在定义变量的时候，变量类型是可以省略，省略之后scala会自动推断数据类型
*
* scala定义变量的时候必须初始化
*/

4、数据类型

scala为完全面向对象，所以java中的八种基本类型在scala中都以首字母大写的方式有对应的类
void在scala中为Unit，唯一实例为()
scala中的Any相当于java中的Object
Null为所有引用数据类型的子类，唯一对象为null
Nothing为所有类的子类

/**
* java数据类型:
*   1、基本数据类型
*      byte、short、char、int、long、float、double、boolean
*   2、引用数据类型
*     String、class、集合、数组
*
* scala数据类型:
*   Any: 是所有类的父类
*       AnyVal: 值类型
*           Byte、Short、Char、Int、Long、Float、Double、Boolean
*           Unit: 相当于java的void, 有一个实例()
*           StringOps: 对java String的扩展
*       AnyRef: 引用类型
*          String、scala class、java class、scala集合、java集合,..
*               Null: 是所有引用类型的子类, 有一个实例null[null一般是给引用类型赋初始值使用，在定义变量的时候如果使用null赋初始值，此时变量的类型必须定义]
*
*      Nothing: 所有类型的子类,但是不是给程序员使用，是scala内部使用
*/

5、String

scala中的string比java多出以下的方式赋值

 val str:String = "a"
    //插值赋值
    val str2:String =s"=======${str}======"
    //三引号包裹
    val str3:String =
      """
        |aaaaaaaaaa
        |bbbbbbbbbb
        |cccccccccc
        |""".stripMargin
    //占位符赋值
    val str4:String = "====%s====".format("aaaa")

/**
* java中如何得到一个字符串:
*     1、通过""包裹
*     2、new String(..)
*     3、通过一些方法
*     4、字符串拼接【+】
* scala中得到一个字符串:
*     1、通过""包裹
*     2、字符串拼接[插值表达式] s"${变量名/表达式}"
*     3、new String(..)
*     4、通过""" """包裹[能够保留字符串的输入的格式]
*     5、通过一些方法
*/

6、类型转换

低精度向高精度转换跟java一样，不同的是高精度向低精度转换在scala中用对象的.toXxx方法实现

/**
* 数字和数字的转换
*    1、低精度向高精度转换: Int->Long
*         java中: 自动转换
*         scala中: 自动转换
*    2、高精度转低精度: Long->Int
*         java中: 强转
*         scala: toXXX方法
* 数字和字符串的转换
*   1、数字转字符串
*       java: 字符串拼接
*       scala: 字符串拼接\toString
*   2、字符串转数字
*       java: Integer.ValueOf(字符串),..
*       scala: toXXX方法
*/

7、运算符

scala中没有++ 和 --
scala中没有三元运算符
scala中的运算符都是方法

/**
* java中运算符：
*   1、算数运算符: +、-、*、/、% ++ --
*   2、比较运算符: > < >= <= != ==
*   3、逻辑运算符: && || !
*   4、赋值运算符: = += -= *= /=
*   5、位运算符: < > & | >>
*   6、三元运算符: 逻辑表达式? 表达式1: 表达式2
*
* scala中没有三元运算符，如果想要实现三元运算符可以通过if-else做
* scala没有++、--运算符。
* scala中运算符:
*   1、算数运算符: +、-、*、/、%
*   2、比较运算符: > < >= <= != ==
*   3、逻辑运算符: && || !
*   4、赋值运算符: = += -= *= /=
*   5、位运算符: < > & | >>
*
* scala中运算符都是方法。
*/

8、block

代码块，在scala中的{}都可以看做是一个代码块，并且它的最后一个表达式的值，就是整个代码块返回的值

/**
* 块表达式: 由{ }包裹的一块代码称之为块表达式
* 块表达式有返回值，返回值是{ }中最后一个表达式的结果值
* 后续大家看到{ }就可以认为是块表达式[ for循环、while循环的大括号不能看做块表达式]
*
*/

9、流程控制

1）if else 和java的一样

    /**
    * java中条件表达式的用法：
    *   1、单分支: if
    *   2、双分支: if-else
    *   3、多分支： if-else if -..-else
    *
    * scala中条件表达式的用法：
    *    1、单分支: if
    *    2、双分支: if-else
    *    3、多分支： if-else if -..-else
    * scala的条件表达式有返回值,返回值是符合条件的分支的{ }的最后一个表达式的结果值
    */

2）for

没有java的增强for循环

    /**
    * java的for循环：
    *   1、基本for:  for(int i=0;i<=100;i++)
    *   2、增强for： for(类型 变量: 集合/数组)
    *
    * scala中重要的两个方法：
    *   to:
    *       用法: startIndex.to(endIndex)
    *       结果: 会生成一个左右闭合的集合
    *   until:
    *       用法: startIndex.until(endIndex)
    *        结果: 会生成一个左闭右开的集合
    *   scala中方法调用有两种方式：
    *     1、对象.方法名(参数值,..)
    *     2、对象 方法名 (参数值,..) [如果方法只有一个参数,此时()可以省略]
    * scala for循环语法:  for(变量 <- 数组/集合/表达式) { 循环体 }
    * for循环的守卫:  for(变量 <- 数组/集合/表达式 if(布尔表达式)) { 循环体 }
    * 步长: for(变量 <- start to end by step)  { 循环体 }
    * 嵌套for循环: for(变量 <- 数组/集合/表达式;变量 <- 数组/集合/表达式;...) { 循环体 }
    * 变量嵌入: for(变量 <- 数组/集合/表达式;  变量2 = 值 ;变量 <- 1  to 变量2;...)
    * for默认是没有返回值的，如果想要for有返回值需要用yield表达式： for(变量 <- 数组/集合/表达式) yield { 循环体 }
    *
    */

	//普通
    println("*" * 100)
    for (i <- 1 to 10) {
    println(i)
    }
    //步长
    println("-" * 100)
    for (i <- 1 to 10 by 3) {
    println(i)
    }
    //守卫
    println("+" * 100)
    for (i <- 1 to 10; if (i % 3 == 0)) {
    println(i)
    }
    //循环嵌套
    println("0" * 100)
    for (i <- 1 to 10; j <- 1 to 10) {
    println(s"i=${i},j=${j}")
    }
    //变量嵌入
    println("9" * 100)
    for (i <- 1 to 10; k = i; j <- k to 10) {
    println(s"i=${i},j=${j}")
    }
    //yield
    println("=" * 100)
    val yieldResult = for (i <- 1 to 10) yield {
    i * i
    }
    println(yieldResult.toBuffer)

3）while 、do while

与java的一模一样

    /**
    * scala中while、do-while的用法与java一样
    * while与do-while的区别：
    *   while  先判断在执行
    *   do-while  先执行在判断
    */

4)break 和continue

在scala中没有break和continue，通过抛异常再捕获的方式达到同样的效果

		import scala.util.control.Breaks._
        //break
        breakable({
            for (i <- 1 to 10) {
                if (i == 5) {
                break()
                }
                println(i)
            }
        })
        //continue
        for (i <- 1 to 10) {
            breakable({
                if (i == 5) {
                break()
                }
                println(i)
            })
        }

    /**
    * java中使用break与continue控制循环
    *       break: 结束整个循环
    *       continue: 结束本次循环立即开始下一次循环
    *
    *  scala中没有break与continue
    *  实现break:
    *     1、导入包:
    *     2、使用breakable以及break方法
    */