• scala-学习 1


    变量定义

    scala定义两种变量:

    • var 可变 初始化之后,可以多次被重新赋值
    • val 不可变 一旦被初始化 就不能再赋值。
    var firstarg :java.lang.String =  "Hello World"
    val secondarg :java.lang.String = "Hello dear"
    

    但是由于有简化名的存在可以如下写法

    var firstarg :String = "Hello World"
    

    因为 scala 具有类型推断的能力,因此还可以如下写:

    var firstarg = "Hello World"
    

    打印输出:

    println("Hello World") // 该方法 会自动换行 
    print("Hello World")  //  该方法 不会 自动换行
    print(firstarg)
    
    函数定义
    def fun(x: Int, y: Int):Int = {
      return x + y  // 其实这么写是不好的,为什么不好,以后再说
    }
    /*
    def  开始函数的定义
    fun  函数名
    x:Int  参数,必须要指定类型,默认所有的参数都是 val 也就是 不可变的。
    fun(*):Int 函数返回的值的类型  返回类型可以省略,scala可以推断,但是在递归函数例外,必须指定
    =  连接函数名和函数体,必须要有,如果没有就是另外一种结果了。
    {*}  花括号 包含函数体   如果函数体只包含一条语句,那么{}可以不写
    
    另外:scala 采用 /*ssss*/ 和 // ssss 两种注释方式
    */
    

    综合上面两个省略,函数也可以写成如下:

    def fun(x:Int, y:Int) = x + y
    

    函数一旦定义号,就可以通过函数用调用了

    fun(1,2)
    
    数组 (Array)

    scala 使用 new 方法实例化对象(也叫类实例) ,在实例类的过程中,可以传入值和类型使实例参数化

    参数化 指:创建实例的同时完成对它的设置。

    • 使用值 参数化实例,可以把值传给构造器的 括号来实现。
    • 使用类型 参数化实例, 可以把一个或多个类型指定到基础类型后的 括号来实现
    val big = new java.math.BigInteger("12345")
    val gre = new Array[String](3)  //实例化了一个字符串数组,其初始长度为 3
    gre(0) = "hello"
    gre(1) = "xiao"
    gre(2) = "ming"
    gre.foreach(println) //查看 gre 的三个元素
    val gree: Array[String] = new Array[String](2) //这么写当然也是可以的
    //以上二者都不是初始化数组的推荐方式
    

    访问数组内的元素

    print(gre(0)) // "hello"
    

    val 说明 gre 是不可变的,但是 gre 内部的元素是 可变的。

    gre(0) = "welcom"
    print(gre(0)) // "welcom"
    gre = Array[String](5) // 会报错 因为它是 val 类型的。  
    

    scala 没有传统意义上的操作符,也就没有操作符重载。因为 + - * / 这样的字符,是方法名。

    我们1 + 2 实际上是调用了 1+ 方法,然后把2 作为参数传给 + 方法。详细些如下:

    1 + 2  // 我们这样写
    1.+(2) //实际上是如此
    

    也可以解释为什么scala 方位数组内元素用 小括号 而不是 方括号

    gre(0) // 我们这样写
    gre.apply(0) // 实际上是如此 调用了 apply 方法
    gre(0) = "nihao"  //我们这样写
    gre.update(0,"nihao") // 实际上是这样 调用了update 方法
    

    scala 有这样一个原则

    任何对于对象的值参数应用将都被转化为对 apply 方法的调用

    更简洁的初始化数组方法:

    val numArr = Array("one","two","three")
    //该方法创造并返回了新数组的 apply 方法
    

    方法没有副作用是函数式编程的重要理念,计算并返回值应该是方法的唯一目的

    所谓 副作用 我的理解是在函数运行中与返回值无关的,只是为了达到某些目的而进行的一些运算。如:

    def fun(x:Int):Unit ={ //Unit 表示不返回任何值。
       x+1   // 这个函数我们不需要返回任何值,只是为了达到将x 加 1的目的,其实把这个方法放到类里面举例更好,这是副作用
      print(x) // 这也是副作用
    } 
    
    列表

    数组和列表都是同类对象序列。不同的是:数组是可变的。而列表可变

    对列表的修改,其实是生成了一个新的列表

    val a = Array("hello","ni","hao")
    val b = List("hello","ni","hao")
    a(0) = "welcom" // print(a(0)) 为 “welcom”
    b(0) = "welcom" //会报错
    b = List("haha") //这样也不可以
    
  • 相关阅读:
    Android应用增量更新
    corner2
    UIProject
    Argo
    flower-recognition
    Android-Chat-Widget
    leanchat-android
    Beautyacticle
    XianBicycle
    完整性约束(章节摘要)
  • 原文地址:https://www.cnblogs.com/jijizhazha/p/7101599.html
Copyright © 2020-2023  润新知