scala02

 

整型  范围
    Byte     -128~127   记住  经典考题
    Short    -32768 ~ 32767
    Int(*****)  -2^31～2^31-1
    Long(*****) -2^63 ~2^63 -1

    有符号： + -
    无符号： -？

默认类型Int

浮点类型(*****)
    Float    32位  单精度
    Double   64位  双精度
    默认是Double

Boolean(***)
    true false
    0 1 也行

类型转行

强转精度会丟

 

 isInstanceOf  判断数据类型 eg：

 拼接加运算，运算必须要有{}

 

 运算符

 

 

&&与 

||或

a && b：a和b同时为true 才返回 true， 否则返回false；a || b：a或b任意一个为true 就返回true ， 否则返回false

 if语句

 

while

 while跳出循环

 结果如下

 

     for循环

 

 

 to是[ ],until是[ ）

for循环步长，步长不能为0

 

 

for循环控制步长的方式

object stepfor {
    def main(args: Array[String]): Unit = {
        for (i <- 1 to 10) {
            println("i=" + i)
        }
    //TODO 打印1到100的奇数
    //法1：利用Range函数。   
        for (i <- Range(1, 100, 2)) {
            println("i=" + i)
        }
    //法2：利用for循环守卫。
        for (i <- 1 to 100 if i % 2 == 1) {
            println("i=" + i)
        }
    } 
}

备注：

1. Range(1,10,2)的对应的构建方法是：def apply(start: Int, end: Int, step: Int): Range = new Range(start, end, step)，相当于直接new 了一个Range。

2. 在for循环守卫中，如果步长为3，则 i % 3，以此类推。

for没有返回值

循环返回值

 

 高阶函数后面单独做

function  *****

函数和方法不是一个东西   函数=方法

{} 方法体
def 函数名/方法名(x:Int, y:Int):Int = {
    if(x > y) x  else y 
}

注意方法体的最后一行是作为整个方法的返回值，不需要使用return
对于无入参的function来说，调用时不需要()

可变参数

object demo{

    def main(args: Array[String]): Unit = {
     println（sum（nums = 1,2,3,4,5,6,7,8,9,10））
        //或者println（sum(1 to 10 :_*)）
    /**
    *可变参数
    *int*表示可传入N个Int的值,一定要放到参数的最后一位
    */
    def sum（nums：Int*）：Unit{
    var res = 0
        for（num <- nums）{
            res += num
        }
        res
    }
    
    }
}

 

object demo01{

    def main(args: Array[String]): Unit = {
         
        printInfo(students = "001","002","003")
        //或者 val array = Array（"001","002","003"）
        //printInfo(array:_*)
        def printInfo(students:String*):Unit={
        students.foreach(println)
        }
    
    }
}

递归：

递归，就是在运行的过程中调用自己。

函数嵌套调用过程示例

构成递归需具备的条件：

1. 子问题须与原始问题为同样的事，且更为简单；

2. 不能无限制地调用本身，须有个出口，化简为非递归状况处理。

递归函数：

function recsum(x) {
    if (x===1) {
        return x;
    } else {
        return x + recsum(x-1);
    }
}

 

如果你调用recsum(5)，将会按照下面的次序来计算：

recsum(5)
5 + recsum(4)
5 + (4 + recsum(3))
5 + (4 + (3 + recsum(2)))
5 + (4 + (3 + (2 + recsum(1))))
5 + (4 + (3 + (2 + 1)))
15

注意在解释器计算recsum（5）之前，每个递归调用必须全部完成。

这是同一函数的尾递归版本：

function tailrecsum(x, running_total=0) {
    if (x===0) {
        return running_total;
    } else {
        return tailrecsum(x-1, running_total+x);
    }
}

下面是当你调用tailrecsum(5)的时候实际的事件调用顺序：

tailrecsum(5, 0)
tailrecsum(4, 5)
tailrecsum(3, 9)
tailrecsum(2, 12)
tailrecsum(1, 14)
tailrecsum(0, 15)
15

在尾递归的情况下，每次递归调用的时候，running_total都会更新。