scala学习复习笔记超详细（变量）

文章目录

• • Scala变量
  • • 1. 变量的快速入门
    • • 变量的使用说明：
      • 程序中 + 的使用：
    • 2. Scala数据类型
    • • Scala 数据类型体系一览图
      • Scala数据类型列表
      • • 整数类型
        • 浮点类型
        • 字符类型
        • 布尔类型
        • Unit类型、Null类型和Nothing类型
    • 3.值类型转换
    • • 值类型隐式转换
      • 高级隐式转换和隐式函数
      • 强制类型转换
      • 值类型转换
      • 值类型和String类型的转换
      • • 基本类型转String类型
        • String类型转基本数据类型
        • 注意事项
    • 4. 标识符的命名规范
    • • 标识符的命名规则(记住)
      • 标识符举例说明
      • 标识符命名注意事项
      • Scala有39个关键字
  • ☆

Scala变量

1. 变量的快速入门

/**
  * @Date 2021/3/21 16:38
  * @Version 10.21
  */
object ScalaVarDemo01 {
  def main(args: Array[String]): Unit = {
    var a: Int = 10
    var b: Int = 20
    b = 30;
    println("a=" + a)
    println("b=" + b)

    var age: Int = 10
    var sal: Double = 11.2
    var name: String = "tom"
    var isPass: Boolean = true

    // 在Scala中，小数默认为Double,整数默认为Int
    var score : Float = 99.99F
    println(s"$name 今年 $age 岁了 ，薪资为$sal 绩效为 $score 是否涨工资 $isPass")
  }
}

变量的使用说明：

// 基本语法：
var | val 变量名 [: 变量类型] = 变量值

/**
  * @Date 2021/3/21 17:17
  * @Version 10.21
  */
object ScalaVarDemo02 {
  def main(args: Array[String]): Unit = {

    // 类型推导，这个时候age是Int类型
    var age = 18

    /**
      * 有两种方式我们可以age是Int类型的：
      *   1. idea提示
      *   2. println(age.isInstanceOf[Int]) 结果为true
      */

    // 类型确定后，就不能修改，说明Scala是强数据类型语言
    // age = 2.1 编译器报错

    // age可以修改，因为age是var声明的
    age = 19
    val sal = 200
    // sal是val声明的，所以不可变
    // sal = 10000  编译器报错

    /**
      * Scala设计者为什么设计 var 和 val 呢？
      * 1、在实际编程，我们更多的需求是获取/创建一个对象后，读取该对象的属性，或者是修改对象的属性值，但是我们很少去改变这个对象本身。
      *     var dog = new Dog()
      *     dog.age = 99
      *     dog = new Dog()
      *   这时我们就可以使用val定义dog
      *     val dog = new Dog()
      *     dog.age = 99
      * 2、因为val 没有线程安全问题，因此效率高，scala的设计者推荐我们val
      * 3、如果对象需要改变，则使用var
      */
    val dog = new Dog()
    // 0
    println(dog.age)

    println(dog.name)

    // 这里我们就不能有下面的操作了
    // dog = new Dog()

  }
}

/**
  * 声明一个Dog类
  */
class Dog {
  // 声明一个age属性,给了一个默认值 _
  var age: Int = _
  var name: String = "小花"
}

程序中 + 的使用：

2. Scala数据类型

/**
  * @Date 2021/3/21 18:48
  * @Version 10.21
  */
object ScalaTypeDemo01 {
  def main(args: Array[String]): Unit = {
    
    var num: Int = 10
      
    /*
      因为Int是一个类，因此他的一个实例，就是可以使用很多方法
      在 scala中，如果一个方法，没有形参，则可以省略()
     */
    println(num.toDouble + "\n" + num.toString + "\n" + 10.toString)

    var isPass = true
    println(isPass.toString)

    // 这两种方法的调用都可以
    sayHi()
    sayHi
  }

  def sayHi(): Unit = {
    println("say hi~")
  }

}

Scala 数据类型体系一览图

/**
  * @Date 2021/3/21 19:04
  * @Version 10.21
  */
object ScalaTypeDemo02 {
  def main(args: Array[String]): Unit = {

    // 默认为double
    var num1 = 1.2
    var num2 = 1.7f
    //在scala中仍然遵守，低精度的值，向高精度的值自动转换(implicit conversion)隐式转换

    //num2 = num1,错误
    num2 = num2.toFloat
    println(num2)

    //false
    println(num2.isInstanceOf[Double])
    // true
    println(num2.isInstanceOf[Float])

    println(sayHello)
  }

  /**
    * 比如开发中，我们有一个方法，就会异常中断，这时就可以返回Nothing
    * 即当我们Nothing 做返回值，就是明确说明该方法有没有正常返回值
    * @return Nothing
    */
  def sayHello: Nothing = {
    throw new Exception("抛出异常")
  }
}

Scala数据类型列表

整数类型

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

/**
  * @Date 2021/3/21 19:31
  * @Version 10.21
  */
object ScalaTypeDemo03 {
  def main(args: Array[String]): Unit = {
    println("Int的最大值：" + Int.MaxValue)
    println("Int的最小值：" + Int.MinValue)
    println("Long的最大值：" + Long.MaxValue)
    println("Long的最小值：" + Long.MinValue)

    var i = 10
    var j = 10L

    // 报错，因为超过了Int的范围
    //var k = 9223372036854775807
  }
}

浮点类型

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

/**
  * @Date 2021/3/21 19:31
  * @Version 10.21
  */
object ScalaTypeDemo03 {
  def main(args: Array[String]): Unit = {
    var num1: Float = 2.2345678910f
    var num2: Double = 2.2345678910

    /**
      * num1=2.2345679
      * num2=2.234567891
      */
    println("num1=" + num1)
    println("num2=" + num2)
  }
}

字符类型

字符类型可以表示单个字符，字符类型是Char， 16位无符号Unicode字符(2个字节)，区间值为 U+0000 到 U+FFFF

/**
  * @Date 2021/3/21 19:46
  * @Version 10.21
  */
object ScalaCharDemo {
  def main(args: Array[String]): Unit = {

    var char1: Char = 97

    /** 当我们输出一个char类型，
      * 他会输出该数字对应的字符（码值表unicode）/unicode码值表包括ascii
      */

    // char1 = a
    println("char1 = " + char1)

    // char可以当做数字进行运行
    var char2: Char = 'a'
    var num = 10 + char2
    // num = 107
    println("num = " + num)

    /**
      * 原因和分析：
      * 1、当把一个计算的结果赋值一个变量,则编译器会进行类型转换及判断(即会看范围+类型)
      * 2、当把一个字面量赋值一个变量，则编译器会进行范围的判定
      */
    //var c2: Char = 'a' + 1
    //var c3: Char = 97 + 1
    var c4: Char = 98
    // c4 = b
    println("c4 = " + c4)
  }
}

布尔类型

Unit类型、Null类型和Nothing类型

/**
  * @Date 2021/3/21 20:06
  * @Version 10.21
  */
object UnitNullNothingDemo {
  def main(args: Array[String]): Unit = {
    val res = sayHello()
    // res = ()
    println("res = " + res)

    /**
      * Null类只有一个实例对象,null类似于Java中的null引用
      * null可以赋值给任意引用类型(AnyRef),但是不能赋值给值类型(AnyVal:比如 Int, Float, Char， Boolean, Long,Double, Byte, Short)
      */
    val dog: Dog = null
    println("ok1~~~")
    //val char: Char = null  运行会报错
    println("ok1~~~")

  }

  /**
    * Unit等于Java的void，只有一个实例值()
    */
  def sayHello(): Unit = {

  }
}

class Dog {

}

3.值类型转换

值类型隐式转换

/**
  * @Date 2021/3/22 14:09
  * @Version 10.21
  */
object ScalaDataConvertDemo01 {
  def main(args: Array[String]): Unit = {
    var n1 = 10
    var n2 = 1.1f
    /**
      * 有多种类型的数据混合运算时，
      * 系统首先自动将所有数据转换成容量最大的那种数据类型，
      * 然后再进行计算
      * n3是Float类型的
      */
    var n3 = n1 + n2

    //(byte, short) 和 char之间不会相互自动转换。
    var n4: Byte = 10
    //var char1: Char = n4 ，报错，因为byte不能自动转换char
  }
}

高级隐式转换和隐式函数

Scala还提供了非常强大的隐式转换机制(隐式函数，隐式类等等)，我们放在高级部分专门用一个章节来讲解。

强制类型转换

/**
  * @Date 2021/3/22 14:25
  * @Version 10.21
  */
object ScalaDataConvertDemo02 {
  def main(args: Array[String]): Unit = {
    val num1: Int = 10 * 3.5.toInt + 6 * 1.5.toInt
    println("num1 = " + num1) // 36
    var num2: Int = (10 * 3.5 + 6 * 1.5).toInt
    println("num2 = " + num2) // 44


    var char1: Char = 1
    var num3 = 1
    // val char2: Char = num3，报错：
    // 因为Char类型可以保存 Int的常量值，但不能保存Int的变量值，需要强转
  }
}

值类型转换

// 判断是否能够通过编译,并说明原因
var s : Short  = 5 // ok
s = s-2    //  error  Int -> Short                
var b : Byte  = 3    // ok
b = b + 4              // error Int ->Byte     
b = (b+4).toByte       // ok ，使用强制转换
var c : Char  = 'a'  //ok
var  i : Int = 5 //ok
var d : Float = .314F //ok
var result : Double = c+i+d     //ok Float->Double
var b : Byte  = 5 // ok
var s : Short  = 3 //ok
var t : Short = s + b // error Int->Short
var t2 = s + b   // ok, 使用类型推导

值类型和String类型的转换

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

基本类型转String类型

String类型转基本数据类型

注意事项

/**
  * @Date 2021/3/22 14:36
  * @Version 10.21
  */
object ScalaStringToOther {
  def main(args: Array[String]): Unit = {
    var str = "12.5"

    //在scala中，不是将小数点后的数据进行截取，而是会抛出异常
    //println(str.toInt) 报错

    println(str.toDouble)//12.5

    // 思考就是要把"12.5"转成Int
    println(str.toDouble.toInt)
  }
}

4. 标识符的命名规范

标识符的命名规则(记住)

/**
  * @Date 2021/3/22 14:51
  * @Version 10.21
  */
object ScalaIdenDemo01 {
  def main(args: Array[String]): Unit = {
    val ++ = "Hello Scala"
    println(++)

    val -+*/ = 90
    println(-+*/)

    //其实编译器是进行以下处理的：
    // ++ ==>  $plus$plus

    //val +a = "abc" 报错

    var `boolean` = "true"
    println(`boolean`)
    val Int = 90.44

    println(Int) //Double类型

    // 不能使用 _ 做标识符
    var _ = "jack"
    //println(_)
  }
}

标识符举例说明

hello    // ok
hello12 // ok
1hello  // error
h-b   // error
x h   // error
h_4   // ok
_ab   // ok
Int    // ok, 在scala中，Int 不是关键字，而是预定义标识符,可以用，但是不推荐
Float  // ok
_   // 不可以，因为在scala中，_ 有很多其他的作用，因此不能使用
Abc    // ok
+*-   // ok
+a  // error

标识符命名注意事项

//包名：尽量采取有意义的包名，简短，有意义。
//变量名、函数名 、方法名 采用驼峰法。

Scala有39个关键字

package, import, class, object, trait, extends, with, type, forSome
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

☆