Scala基础知识01

最新推荐文章于 2024-05-10 22:47:55 发布

Cc_sai_sai

最新推荐文章于 2024-05-10 22:47:55 发布

阅读量316

点赞数

CC 4.0 BY-SA版权

分类专栏： Scala 文章标签： scala 开发语言

本文链接：https://blog.youkuaiyun.com/Cc_DaGe/article/details/127945990

Scala 专栏收录该内容

1 篇文章

订阅专栏

本文是Scala基础知识的入门介绍，涵盖了字符串的使用、键盘输入的方法、各种数据类型的解析以及运算符的规则。适合对Scala感兴趣的开发者阅读。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

规范

/*
* Scala完全面向对象，Scala去掉了Java中非面向对象的元素，如 static 关键字，void类型
* 1.static
*   Scala无static关键字，由object实现类似静态方法的功能（类名，方法名） class关键字和java中的class关键字作用相同，用来定义一个类
* 2.void
*   对于无返回值的函数，Scala定义其返回值类型为unit类
* */


// 单行注释

/* 多行注释 */

/**
 * 文档注释
 */

/*代码规范
* 1.使用一次 tab 操作，实现缩进，默认整体向右边移动，用 shift+tab 整体向左移动
* 2.或者使用 Ctrl+Alt+L 来进行格式化
* 3.运算符两边习惯性加空格 例如: 2 + 3 = 5
* 4.一行最多不超过80个字符，如果超过了请使用换边展示，尽量保持格式优雅
* */

/* Scala的常量和变量
* 1.基本语法
*   var 变量名称 : 变量类型 = 初始值   例如：var a:int = 10   可变
*   val 常量名称 : 常量类型 = 初始值   例如：val b:int = 10   不可变
* -- 注意能用常量的地方不用变量
* 2.案例实操
*   -- 声明变量的时候类型可以省略，编译器自动推导，即类型推导
*   -- 类型确定之后就不能修改，说明Scala是强数据类型语言
*   -- 变量声明时必须要有初始值
*   -- 在声明或定义一个变量的时候，可以使用var/val来修饰，var修饰的变量可改变 val修饰的变量不可变
* */

字符串

/*  字符串输出
* 基本语法
* 1.字符串通过 + 号连接
* 2.printf用法：字符串，通过%号传值
* 3.字符串模板（插值字符串）：通过$获取变量值
*
* */
object Hello01 {

  def main(args: Array[String]): Unit = {

    var name: String = "zhangsai"
    var age: Int = 18

    // 1.字符串通过+号连接
    println(name + " " + age)

    // 2.printf用法：字符串，通过%号传值
    printf("name=%s age=%d\n", name, age)

    // 3.字符串，通过$引用
    val s =
      """
        |select
        |name,
        |age
        |from user
        |where name = "zhangsan"
      """.stripMargin
    println(s)
    // 如果需要对变量进行运算，那么可以加${}
    val s1 =
      s"""
         |select
         | name,
         | age
         |from user
         |where name="$name" and age=${age + 2}
 """.stripMargin
    println(s1)
    val s2 = s"name=$name"
    println(s2)
  }
}

键盘输入

/* 键盘输入
*基本语法
* StdIn.readLine("字符串类型")、StdIn.readShort("整数类型")、StdIn.readDouble("双精度小数类型")
*
* */
object Hello02 {

  //  需求：可以从控制台接收用户信息，【姓名，年龄，薪水】
  def main(args: Array[String]): Unit = {

    // 输入姓名
    println("请输入姓名：")
    val name = StdIn.readLine()

    // 输入年龄
    println("请输入年龄：")
    val age = StdIn.readShort()

    // 输入薪水
    println("请输入薪水：")
    val sal = StdIn.readDouble()

    // 打印
    println("name= " + name + " age= " + age + " sal= " + sal)
//    println("age=" + age)
//    println("sal=" + sal)

  }

}

数据类型

/* 数据类型（重点）

*   Java数据类型
Java基本类型：char、byte、short、int、long、float、double、boolean
Java引用类型：（对象类型）
由于Java有基本类型，而且基本类型不是真正意义的对象，即使后面产生了基本类型的包装类，但是仍然存在基本数据类型，所以Java语言并不是真正意思的面向对象。
Java基本类型的包装类：Character、Byte、Short、Integer、Long、Float、Double、Boolean
注意：Java中基本类型和引用类型没有共同的祖先。

*   Scala数据类型
1）Scala中一切数据都是对象，都是Any的子类。
2）Scala中数据类型分为两大类：数值类型（AnyVal）、引用类型（AnyRef），不管是值类型还是引用类型都是对象。
3）Scala数据类型仍然遵守，低精度的值类型向高精度值类型，自动转换（隐式转换）
4）Scala中的StringOps是对Java中的String增强
5）Unit：对应Java中的void，用于方法返回值的位置，表示方法没有返回值。Unit是 一个数据类型，只有一个对象就是()。Void不是数据类型，只是一个关键字
6）Null是一个类型，只 有一个对 象就 是null。它是所有引用类型（AnyRef）的子类。
7）Nothing，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。
* */
object Hello03 {

  def main(args: Array[String]): Unit = {

    /*  1.整数类型（byte、short、int、long）
      * scala的整数类型就是用来存放整数值的，例如12,12323,34545等
      * 整形分类
        byte    -- 8位有符号补码整数。数值区间为-128到127
        short   -- 16位有符号补码整数。数值区间为-32768到32767
        int     -- 32位有符号补码整数。数值区间为-2147483648到2147483647
        long    -- 64位有符号补码整数。数值区间为--9223372036854775808到9223372036854775807 = 2 的(64-1)次方-1
    * */
    var n1: Byte = 127 // var n1:Byte = 128  错误的
    var n2: Byte = -128 // var n2:Byte = -129 错误的
    println(n1 + " and " + n2)
    var a1 = 10 //  scala默认的是int类型
    println(a1)
    var a2 = 173245672347656252L // 如果需要long类型需要在后面加 l或者L
    println(a2)
    // Scala 程序中变量常声明为 Int 型，除非不足以表示大数，才使用 Long

    /*  2.浮点类型（float、double）  -- 建议在开发中需要高精度小数时候请选择 double
    * float   -- 32位单精度浮点数
    * double  -- 64位双精度浮点数
    * */
    var a3 = 2.11877587687787778f
    var a4 = 2.11877587687787778 // 默认是double类型
    println(a3 + " -- " + a4)

    /*  3.字符类型（char）字符类型可以表示单个字符，字符类型是char
    * 字符常量是用单引号 ' ' 括起来的单个字符。
    * \t ：一个制表位，实现对齐的功能
    * \n ：换行符
    * */
    var a5 = 's' // 表示单个字符
    println(a5)
    println("姓名\t年龄") //  \t 一个制表位，实现对齐的功能
    println("小明\n小红") //  \n 换行符
    println("c:\\aa\\cc") //  \\ 表示\
    println("同学们都说：\"大海哥最帅\"") //  \" ：表示"

    /*  4.布尔类型（Boolean）
    * 布尔类型也叫 Boolean 类型，Booolean 类型数据只允许取值 true 和 false   -- boolean 类型占 1 个字节。
    * */
    var buerleix1:Boolean = false
    var buerleix2:Boolean = true

    /*  5.Unit 类型、Null 类型和 Nothing 类型（重点）
    *  Unit 表示无值,和其他语言中 void 等同.用作不返回任何结果的方法的结果类型.Unit只有一个实例值,写成()
    *  null null类型只有一个实例值
    *  Nothing类型在 Scala 的类层级最低端；它是任何其他类型的子类型 当一个函数，我们确定没有正常的返回值，可以用 Nothing 来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）
    * */
    def sayOk : Unit = {} // unit 表示没有返回值，即 void
    println(sayOk)

    //null 可以赋值给任意引用类型（AnyRef），但是不能赋值给值类型（AnyVal）
//    var cat = new Cat();
//    cat = null // 正确
//    var b1: Int = null // 错误
//    println("n1:" + b1)

    /* 类型转换
    * （1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数据类型，然后再进行计算。
    * （2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
    * （3）（byte，short）和 char 之间不会相互自动转换。
    * （4）byte，short，char 他们三者可以计算，在计算时首先转换为 int 类型
    * */
    //（1）自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
    var n = 1 + 2.0
    println(n) // n 就是 Double
    //（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
    var n2s : Double= 1.0
    //var n3 : Int = n2s //错误，原因不能把高精度的数据直接赋值和低精度。
    //（3）（byte，short）和 char 之间不会相互自动转换。
    var n4 : Byte = 1
    //var c1 : Char = n4 //错误
    var n5:Int = n4

    /* 强制类型转换
    * 自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。
    * （1）将数据由高精度转换为低精度，就需要使用到强制转换
    * （2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
    * */
    //（1）将数据由高精度转换为低精度，就需要使用到强制转换
    var n1s: Int = 2.5.toInt // 这个存在精度损失
    //（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
    var r1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt // 10 *3 + 6*1= 36
    var r2: Int = (10 * 3.5 + 6 * 1.5).toInt // 44.0.toInt =44
    println("r1=" + r1 + " r2=" + r2)

    /*  数值类型和string类型间转换
    * 在程序开发中，我们经常需要将基本数值类型转成 String 类型。或者将 String 类型转成基本数值类型。
    * （1）基本类型转 String 类型（语法：将基本类型的值+"" 即可）
    * （2）String 类型转基本数值类型（语法：s1.toInt、s1.toFloat、s1.toDouble、s1.toByte、s1.toLong、s1.toShort）
    * */

    // 基本类型转string类型（语法：将基本类型的值+"" 即可）
    var str1 : String = true + ""
    var str2 : String = 2.1 + ""
    var str3 : String = 200 + ""
    // string类型转基本数值类型（语法：调用相关api）
    var s1 : String = "12"
    var c1 : Byte = s1.toByte
    var c2 : Short = s1.toShort
    var c3 : Int = s1.toInt
    var c4 : Long = s1.toLong
    println(c1 + "-" + c2 + "-" +c3 + "-" +c4)


  }
}

运算符

/* 运算符  Scala运算符的使用和java运算符的使用基本相同，只有个别细节上不同
* 1.算术运算符   基本语法 + -（正负号） + - * / % +（字符串相加）
* 2.关系运算符   基本语法 == != < > <= >=
* 3.逻辑运算符   基本语法 &&（与） ||（或） ！（非）
* 4.赋值运算符   基本语法 =（简单赋值） +=（相加后赋值） -=（相减后赋值） *=（相乘后赋值） /=（相除后赋值） %=（求余后赋值） <<=（左移后赋值） >>=（右移后赋值） &=（按位与赋值） ^=（按位异或后赋值） |=（按位或后赋值）
* 5.位运算符    基本语法 & | ^ ~  << >> >>>
* */
object Hello04 {

  def main(args: Array[String]): Unit = {

    //  1.算术运算符
    var r1: Int = 10 / 3 // 3 除号它的整数除和小数除是有区别的 整数之间做除法时，只保留整数部分而舍弃小数部分
    println(r1)
    var r2: Double = 10 / 3 // 3.0
    println(r2)
    println(r2.formatted("%.2f")) // 含义：保留小数点2位，使用四舍五入
    var r3 = 10 % 4 // 2 对于一个数取模a%b,和java的取模规则一样
    println(r3)

    //  2.关系运算符
    val ss1 = "abc"
    val ss2 = new String("abc")
    println(ss1 == ss2)
    println(ss1.eq(ss2))
    println(ss1 eq ss2)

    //  3.逻辑运算符 && || ！
    var a = true // 真
    var b = false // 假
    println("a&&b=" + (a && b)) // false
    println("a||b=" + (a || b)) // true
    println("a!b=" + !(a && b)) // true

    //  4.赋值运算符
    var rr1 = 100
    rr1 += 1
    println(rr1)
    rr1 -= 2
    println(rr1)

    //  5.位运算符
    var n1 = 10
    n1 = n1 & 1
    println(n1)

    /* Scala运算符本质
    * 在Scala中其实是没有运算符的，所有的运算符都是方法
    * 1.当调用对象方法时，点.可以省略
    * 2.如果函数参数只有一个，或者没有参数，()可以省略
    * */

    // 标准的加法运算
    val i = 1.+(1)
    // 1.当调用对象方法时，.可以省略
    val j = 1 + (1)
    // 2.如果函数参数只有一个，或者没有参数，()可以省略
    val k = 1 + 1
    println(i.toString())
    println(i toString())
    println(i.toString)

  }
}

未完...