（超详细）Scala变量和数据类型（scala-2.12.15、IDEA2021.1.3）

柔情只为你懂 2023-10-01 16:06 23阅读 0赞

# **Scala变量和数据类型** #

*JunLeon——go big or go home*

--------------------

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_19_color_FFFFFF_t_70_g_se_x_16][]

**目录**

Scala变量和数据类型

一、Scala注释及代码规范

1、Scala注释

2、代码规范

二、Scala变量

1、变量与常量

2、标识符的命名规范

3、字符串的输出

4、键盘输入

三、Scala数据类型

1、Scala数据类型

2、整数类型

3、浮点数类型

4、字符类型

5、布尔类型-Boolean

6、Unit类型、Null类型和Nothing类型（重点）

7、类型转换

--------------------

**前言：**

Scala 是一种有趣的语言。它一方面吸收继承了多种语言中的优秀特性，一方面又没有抛弃 Java 这个强大的平台，它运行在 Java 虚拟机 (Java Virtual Machine) 之上，轻松实现和丰富的 Java 类库互联互通。它既支持面向对象的编程方式，又支持函数式编程。它写出的程序像动态语言一样简洁，但事实上它确是严格意义上的静态语言。Scala 就像一位武林中的集大成者，将过去几十年计算机语言发展历史中的精萃集于一身，化繁为简，为程序员们提供了一种新的选择。

## **一、Scala注释及代码规范** ##

### **1、Scala注释** ###

> 注释是一个程序员必须要具有的良好编程习惯。将自己的思想通过注释先整理出来，再用代码去体现。

**1）基本语法**

（1）单行注释

//用于单行注释

（2）多行注释

/*
    用于多行注释
    */

（3）文档注释

/**
     * 用于文档注释,多用于对类，方法的文档注释
     */

**2）示例**

package com.junleon.chapter01
    
    /*	这是多行注释
    	创建一个单例对象：HelloWorld
     */
    object HelloWorld {
      /**这是文档注释
       * 这是main方法，是运行入口
       * @param args
       */
      def main(args: Array[String]): Unit = {
        //这是单行注释，输出 Hello World
        println("Hello World")
      }
    }

### **2、代码规范** ###

（1）使用一次 tab 操作，实现缩进，默认整体向右边移动，用 shift+tab 整体向左移；

（2）或者使用 ctrl + alt + L 来进行格式化；

（3）运算符两边习惯性各加一个空格。比如 2 + 4 \* 5 ；

（4）一行最长不超过 80 个字符，超过的 请使用换行展示 ，尽量保持格式优雅。

## **二、Scala变量** ##

### **1、变量与常量** ###

**1）基本语法**

> var 变量名 \[: 变量类型\] = 初始值 例如：创建变量v1 var v1:Int = 10
> 
>  val 常量名 \[: 常量类型 \] = 初始值 例如：创建常量v2 val v2:Int = 20

**注意：**能用常量的地方不用变量

（1）声明变量时，类型可以省略，编译器自动推导，即类型推导；

（2）类型确定后，就不能修改，说明 Scala 是强数据类型语言；

（3）变量声明时，必须要有初始值；

（4）在声明定义一个变量时，可以使用 var 或者 val 来修饰， var 修饰的变量可改变，val 修饰的变量不可改。

（5）var 修饰的对象引用可以改变，val 修饰的对象则不可改变，但对象的状态（值）却是可以改变的。（比如：自定义对象、数组、集合等等）

**2）示例**

package com.junleon.chapter02
    
    object TestVariable {
      def main(args: Array[String]): Unit = {
        //定义一个变量v1,初始化值为10
        var v1 : Int = 10
        //定义一个常量v2,初始化值为20
        val v2 : Int = 20
        //打印输出v1、v2的值
        println("v1值为：" + v1)
        println("v2值为：" + v2)
    
        var v3 = 30   //声明变量时，类型可以省略，编译器自动推导类型
    
        v1 = 15   //var修饰的变量可以改变
        //v2 = 25 则会报错，val修饰的常量值不可以改变
    
        //v1 = "hello" 报错，v1是整型，不能赋值为字符串，即类型确定后，就不能修改，说明Scala是强数据类型语言。
    
        //var v4 : int 报错，声明变量时，必须初始化值
      }
    }

### **2、标识符的命名规范** ###

> Scala对各种变量 、方法 、函数等命名时使用的字符序列称为标识符 。即凡是自己可以起名字的地方都叫标识符。

**1）命令规则**

Scala中的标识符声明，基本和Java是一致的 ，但是细节上会有所变化，有以下三种规则：

（1）以字母或者下划线开头，后接字母、数字、下划线；

（2）以操作符开头，且只包含操作符等；

（3）用反引号包括的任意字符串，即使是 Scala 关键字（ 39 个）也可以（红色表示Java中没有的关键字）

*  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

**2）示例**

需求判断 hello 、 Hello12 、 1hello 、 h b 、 x h 、 h\_4 、 \_ab 、 Int 、 \_、 、 +*+*\--/\#!1 、 if 、'if'，这些 名字是否合法 。

package com.junleon.chapter02
    
    object TestName {
      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 = "hel lo" // ok 单独一个下划线不可以作为标识符，因为被认为是一个方法
        println(_)
        //(2) 以操作符开头，且只包含操作符 （+ * / # 等）
        var +*--/#! : String = "" // ok
    //    var +*--/#!1 : String = "" // error 以操作符开头，必须都是操作符
        //(3) 用反引号'xxx'包括的任意字符串，即使是 Scala 关键字（ 39 个）也可以
    //    var if : String = "" // error 不能用关键字
        var `if` : String = "" // ok 用反引号`包括的任意字符串包括关键字
      }
    
    }

### **3、字符串的输出** ###

**1）基本语法**

（1）字符串，通过‘+’号连接

（2）printf()用法：字符串，通过%传值。

*  %d 数值类型
 *  %s 字符串类型
 *  %f 浮点型

（3）字符串格式化模板 s"$\{xxx\}"（插值字符串通过$\{\}获取变量值)

**2）示例**

package com.junleon.chapter02
    
    object TestString {
      def main(args: Array[String]): Unit = {
        var name: String = "zhangsan"
        var age: Int = 18
        //(1) 字符串，通过+号连接
        println(name + "\t" + age)
    
        //(2) printf用法：字符串通过%传值
        printf("name=%s age=%d \n", name, age)
    
        //(3)字符串，通过${}引用
        println(s"name=${name},age=${age}")
    
        /*
        多行字符串，在Scala中，利用三个双引号包围多行字符串就可以实现。
        输入的内容，带有空格、\t之类，导致每一行的开始位置不能整洁对齐。
        应用scala的stripMargin方法，在scala中stripMargin默认
        是 | 作为 连接符， 在多行换行的行头前面加一个 | 符号即可。
         */
        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)
      }
    }

### **4、键盘输入** ###

> 在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取。

**1）基本语法**

**StdIn.readLine()**、**StdIn.readShort()** 、**StdIn.readDouble()**

**2）示例**

package com.junleon.chapter02
    
    import scala.io.StdIn
    
    object TestInput {
      def main(args: Array[String]): Unit = {
        // 1 输入姓名
        println("请输入姓名:")
        var name = StdIn. readLine
        // 2 输入年龄
        println("请输入年龄:")
        var age = StdIn. readShort
        // 3 输入薪资
        println("请输入薪资:")
        var sal = StdIn. readDouble
        // 4 打印
        println("姓名：" + name)
        println("年龄：" + age)
        println("薪资：" + sal)
      }
    }

## **三、Scala数据类型** ##

**Java知识注入：**

> Java基本类型：char、byte、short、int、long、float、double、boolean
> 
> Java引用类型：String等（对象类型）
> 
> Java基本类型的包装类：Character、Byte、Short、Integer、Long、Float、Double、Boolean

注意：Java中基本类型和引用类型没有共同的祖先。

### **1、Scala数据类型** ###

**![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_17_color_FFFFFF_t_70_g_se_x_16][]**

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，是所有数据类型的子类，主要用在一个函数没有明确返回值时使用，因为这样我们可以把抛出的返回值，返回给任何的变量或者函数。

### **2、整数类型** ###

> Scala 的整数类型就是用于存放整数值的，比如12，30，3456 等等。

**1）整型分类**

<table> 
 <thead> 
  <tr> 
   <th style="text-align:left;">数据类型</th> 
   <th style="text-align:left;">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#dfe2e5;text-align:left;">Byte [1]</td> 
   <td style="border-color:#dfe2e5;text-align:left;">8位有符号补码整数。数值区间为 -128 到 127</td> 
  </tr> 
  <tr> 
   <td style="border-color:#dfe2e5;text-align:left;">Short [2]</td> 
   <td style="border-color:#dfe2e5;text-align:left;">16位有符号补码整数。数值区间为 -32768 到 32767</td> 
  </tr> 
  <tr> 
   <td style="border-color:#dfe2e5;text-align:left;">Int [4]</td> 
   <td style="border-color:#dfe2e5;text-align:left;">32位有符号补码整数。数值区间为 -2147483648 到 2147483647</td> 
  </tr> 
  <tr> 
   <td style="border-color:#dfe2e5;text-align:left;">Long [8]</td> 
   <td style="border-color:#dfe2e5;text-align:left;">64位有符号补码整数。数值区间为 -9223372036854775808 到 9223372036854775807 =2的(64-1)次方-1</td> 
  </tr> 
 </tbody> 
</table>

**2）示例**

（1） Scala 各整数类型有固定的 表示 范围和字段长度，不受具体操作的影响，以保证Scala 程序的可移植性。

（2）Scala 的整型，默认为 Int 型，声明 Long 型，须后加‘ l ’或 L。

（3） Scala 程序中 变量常声明为 Int 型 ，除非不足以表示大数，才使用 Long。

package com.junleon.chapter02
    
    object TestDataType {
      def main(args: Array[String]): Unit = {
        // 正确
        var n1:Byte = 127
        var n2:Byte = -128
        // 错误
    //    var n3:Byte = 128
    //    var n4:Byte = -129
    
        var n5 = 10
        println(n5)
        var n6 = 9223372036854775807L
        println(n6)
      }
    }

### **3、浮点数类型** ###

> Scala的浮点类型可以表示一个小数，比如 123.4f 7.8 0.12 等等。

**1）浮点型分类**

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#dfe2e5;">Float [4]</td> 
   <td style="border-color:#dfe2e5;">32 位, IEEE 754标准的单精度浮点数</td> 
  </tr> 
  <tr> 
   <td style="border-color:#dfe2e5;">Double [8]</td> 
   <td style="border-color:#dfe2e5;">64 位 IEEE 754标准的双精度浮点数</td> 
  </tr> 
 </tbody> 
</table>

**2）示例**

Scala的浮点型常量默认为 Double 型，声明 Float 型常量，须后加‘ f’ 或‘ F’ 。

package com.junleon.chapter02
    
    object TestDataTypeFloat {
      def main(args: Array[String]): Unit = {
        //建议，在开发中需要高精度小数时，请选择Double
        var float_num = 2.2345678912f
        var double_num = 2.2345678912
        println("float_num=" + float_num)
        println("double_num=" + double_num)
      }
    }

运行结果：

float_num=2.2345679
    double_num=2.2345678912

### **4、字符类型** ###

**1）基本说明**

字符类型可以表示单个字符，字符类型是Char 。

**2）案例实操**

（1）字符常量是用单引号 ' ' 括起来的单个字符;

（2） \\t ：制表符

（3）\\n ：换行符

（4）\\\\：表示\\

（5）\\" ：表示"

package com.junleon.chapter02
    
    object TestCharType {
      def main(args: Array[String]): Unit = {
        //（1）字符常量是用单引号 ' ' 括起来的单个字符;
        var c1 : Char = 'a'
        println("c1="+c1)
    
        //（2） \t ：制表符
        println("姓名\t年龄")
    
        //（3）\n ：换行符
        println("姓名\n张三")
    
        //（4）\\：表示\
        println("C:\\bigdata\\scala")
    
        //（5）\" ：表示"
        println("军哥很\"帅\"")
      }
    }

**运行结果：**

c1=a
    姓名	年龄
    姓名
    张三
    C:\bigdata\scala
    军哥很"帅"

### **5、布尔类型-Boolean** ###

**1）基本说明**

（1）布尔类型也叫 Boolean 类型， Booolean 类型数据只允许取值 true 和 false； （2） boolean 类型占 1 个字节。

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#dfe2e5;">boolean [1]</td> 
   <td style="border-color:#dfe2e5;">Booolean 类型数据只允许取值 true 和 false</td> 
  </tr> 
 </tbody> 
</table>

**2）示例**

package com.junleon.chapter02
    
    object TestBooleanType {
      def main(args: Array[String]): Unit = {
        var isOk : Boolean = true
        var isOk1 : Boolean = false
        println("isok="+isOk+",类型为"+isOk.getClass)
        println("isok1="+isOk1+",类型为"+isOk1.getClass)
      }
    }

**运行结果：**

isok=true,类型为boolean
    isok1=false,类型为boolean

### **6、Unit类型、Null类型和Nothing类型（重点）** ###

**1）基本说明**

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td style="border-color:#dfe2e5;">Unit</td> 
   <td style="border-color:#dfe2e5;">表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。</td> 
  </tr> 
  <tr> 
   <td style="border-color:#dfe2e5;">Null</td> 
   <td style="border-color:#dfe2e5;">null , Null 类型只有一个实例值null</td> 
  </tr> 
  <tr> 
   <td style="border-color:#dfe2e5;">Nothing</td> 
   <td style="border-color:#dfe2e5;">Nothing类型在Scala的类层级最低端；它是任何其他类型的子类型。 当一个函数，我们确定没有正常的返回值，可以用Nothing来指定返回类型，这样有一个好处，就是我们可以把返回的值（异常）赋给其它的函数或者变量（兼容性）</td> 
  </tr> 
 </tbody> 
</table>

**2）示例**

（1）Unit 类型用来标识过程，也就是没有明确返回值的函数。

由此可见，Unit 类似于 Java 里的 void 。 Unit 只有一个实例 ——( )，这个实例也没有实质意义。

package com.junleon.chapter02
    
    object TestSpecialType {
      def main(args: Array[String]): Unit = {
        def sayOk: Unit = { // unit 表示没有返回值，即 void
          println(sayOk)
        }
      }
    }

（2）Null 类只有一个实例对象， Null 类似于 Java 中的 null 引用。

Null 可以赋值给任意引用类型（ AnyRef ），但是不能赋值给值类型 AnyVal。

package com.junleon.chapter02
    
    object TestSpecialType {
      def main(args: Array[String]): Unit = {
          //null 可以赋值给任意引用类型（ AnyRef ），但是不能赋值给值类型AnyVal
      	var cat = new Cat();
      	cat = null // 正确
      	var n1: Int = null // 错误
      	println("n1:" + n1)
      }
    }
    
    class Cat{
    
    }

（3） Nothing ，可以作为没有正常返回值的方法的返回类型，非常直观的告诉你这个方法不会正常返回，而且由于 Nothing 是其他任意类型的子类，他还能跟要求返回值的方法兼容。

package com.junleon.chapter02
    
    object TestSpecialType {
      def main(args: Array[String]): Unit = {
        def test() : Nothing = {
          throw new Exception()
        }
        test
      }
    }

### **7、类型转换** ###

**1）数值类型自动转换**

> 当Scala 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数值类型，这 个就是自动类型转换（隐式转换）。数据类型按精度（容量）大小排序为：
> 
> ![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_14_color_FFFFFF_t_70_g_se_x_16][]

（1 ）自动提升原则：有多种类型的数据混合运算时，系统首先 自动将所有数据转换成精度大的那种数据类型 ，然后再进行计算。

（2）把精度大的数值类型赋值给精度小的数值类型时，就会报错 ，反之就会进行自动类型转换。

（3）（byte、short ）和 char 之间不会相互自动转换。

（4）byte、short、char 他们三者可以计算， 在计算时首先转换为 int 类型 。

**示例：**

package com.junleon.chapter02
    
    object TestValueTransfer {
      def main(args: Array[String]): Unit = {
        //(1) 自动提升原则：有多种类型的数据混合运算时，系统首先自动将所有数据转换成精度大的那种数值类型，然后再进行计算。
        var n = 1 + 2.0
        println(n,n.getClass) // n 就是 Double
        
        //(2) 把精度大的数值类型赋值给精度小的数值类型时，就会报错，反之就会进行自动类型转换。
        var n2 : Double = 1.0
        //var n3 : Int = n2 错误，原因不能把高精度的数据直接赋值和低精度。
        
        //(3) （byte short）和 char之间不会相互自动转换。
        var n4 : Byte = 1
        //var c 1 : 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 错误
      }
    }

注意：Scala还提供了非常强大的隐式转换机制（隐式函数，隐式类等）

**2）强制类型转换**

**基本说明：**

> 自动类型转换的逆过程，将精度大的数值类型转换为精度小的数值类型。使用时要加上强制转函数，但可能造成精度降低或溢出，格外要注意。

Java  :	 	int num = (int)2.5
    Scala :  	var num : Int = 2.7.toInt

**示例：**

（1）将数据由高精度转换为低精度，就需要使用到强制转换;

（2）强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级。

package com.junleon.chapter02
    
    object TestForceTransfer {
      def main(args: Array[String]): Unit = {
        //(1) 将数据由 高精度 转换为 低精度 ，就需要使用到强制转换
        var n1: 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)
      }
    }

**3）数值类型和String类型间转换**

**基本说明:**

> 在程序开发中，我们经常需要将基本数值类型转成String 类型。或者将 String 类型转成基本数值类型。

**示例：**

（1）基本类型转String类型（语法将基本类型的值 +"" 即可）

（2）String 类型转基本数值类型

（语法： s1.toInt 、s1.toFloat 、s1.toDouble 、s1.toByte 、s1.toLong、s 1.toShort）

package com.junleon.chapter02
    
    object TestStringTransfer {
      def main(args: Array[String]): Unit = {
        //(1) 基本类型转 String 类型（语法：将基本类型的值 +"" 即可）
        var str1: String = true + ""
        var str2: String = 4.5 + ""
        var str3: String = 100 + ""
    
        //(2) String 类型转基本数值类型（语法：调用相关API）
        var s1: String = "12"
        var n1: Byte = s1.toByte
        var n2: Short = s1.toShort
        var n3: Int = s1.toInt
        var n4: Long = s1.toLong
      }
    }

下一篇：Scala运算符及流程控制语句

如果你喜欢、对你有帮助，点赞+收藏，跟着军哥学知识……

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_19_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/68d3fb46eb424d2e9e33ad49dfbeccf3.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_19,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_17_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/5d9688dd98014320b1c749bb862d2d5c.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_17,color_FFFFFF,t_70,g_se,x_16
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U_size_14_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/46738c05ea074ddcb16367aa7989501d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBASVTot6_kuIrnmoTlhpvlk6U=,size_14,color_FFFFFF,t_70,g_se,x_16