第五章 Scala 变量与运算符

1 变量

变量是一种使用方便的占位符，用于引用计算机内存地址，变量创建后会占用一定的内存空间。基于变量的数据类型，操作系统会进行内存分配并且决定什么将被储存在保留内存中。因此，通过给变量分配不同的数据类型，你可以在这些变量中存储整数，小数或者字母。

1.1 变量声明

在学习如何声明变量与常量之前，我们先来了解一些变量与常量。

• 变量： 在程序运行过程中其值可能发生改变的量叫做变量。如：时间，年龄。
• 常量 ：在程序运行过程中其值不会发生变化的量叫做常量。如：数值 3，字符’A’。在 Scala 中，使用关键词 “var” 声明变量，使用关键词 “val” 声明常量。
  声明变量实例如下：

var myVar : String = "Foo"
var myVar : String = "Too修改"

以上定义了变量 myVar，我们可以修改它。
声明常量实例如下：

val myVal : String = "Foo"

以上定义了常量 myVal，它是不能修改的。如果程序尝试修改常量 myVal 的值，程序将会在编译时报错。

1.2 变量类型推断

在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。

var myVar = 10;
val myVal = "Hello, Scala!";

以上实例中，myVar 会被推断为 Int 类型，myVal 会被推断为 String 类型。

1.3 多个变量声明

Scala 支持多个变量的声明：

val xmax, ymax = 100  // xmax, ymax都声明为100

如果方法返回值是元组，我们可以使用 val 来声明一个元组：

 val pa = (40,"Foo")
pa: (Int, String) = (40,Foo)

2 运算符

一个运算符是一个符号，用于告诉编译器来执行指定的数学运算和逻辑运算。

Scala 含有丰富的内置运算符，包括以下几种类型：

2.1 算术运算符

实例：

object Test {
   def main(args: Array[String]) {
      var a = 10;
      var b = 20;
      var c = 25;
      var d = 25;
      println("a + b = " + (a + b) );
      println("a - b = " + (a - b) );
      println("a * b = " + (a * b) );
      println("b / a = " + (b / a) );
      println("b % a = " + (b % a) );
      println("c % a = " + (c % a) );
      
   }
}

结果:
$ scalac Test.scala 
$ scala Test
a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5

2.2 关系运算符

实例：

object Test {
   def main(args: Array[String]) {
      var a = 10;
      var b = 20;
      println("a == b = " + (a == b) );
      println("a != b = " + (a != b) );
      println("a > b = " + (a > b) );
      println("a < b = " + (a < b) );
      println("b >= a = " + (b >= a) );
      println("b <= a = " + (b <= a) );
   }
}

结果:
$ scalac Test.scala 
$ scala Test
a == b = false
a != b = true
a > b = false
a < b = true
b >= a = true
b <= a = false

2.3 逻辑运算符

object Test {
   def main(args: Array[String]) {
      var a = true;
      var b = false;

      println("a && b = " + (a&&b) );

      println("a || b = " + (a||b) );

      println("!(a && b) = " + !(a && b) );
   }
}

结果:
$ scalac Test.scala 
$ scala Test
a && b = false
a || b = true
!(a && b) = true

2.4 位运算符

数据在计算机中存储是以0和1二进制存储的并且是以补码的形式存储的。
原码、反码以及补码都是有符号的，其中最高位存放符号位，0 表示正数，1 则表示负数。

• 原码：最高位表示正负，其余位表示数值。

+1 = [0000 0001]原，-1 = [1000 0001]原

• 反码：正数的反码和原码相同；负数的反码是在原码的基础上，符号位不变，其余位按位取反。

+1 = [0000 0001]反，-1 = [1111 1110]反 

• 补码：正数的补码和原码也相同；负数的补码是在反码的基础上加 1。

+1 = [0000 0001]补，-1 = [1111 1111]补 

特殊规则：一个数被同一个数异或2次等于他本身 10 ^ 20^20 = 10

• &：相同为1，不同为0
• | ：有一个1就位1，否则为0
• `^：相同为0，不同为1
• ~：取反0转1,1转0

实例：

A = 0011 1100

B = 0000 1101

-------位运算----------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011



结果:
A = 0011 1100

B = 0000 1101

-------位运算----------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A  = 1100 0011

2.5 赋值运算符

实例：

object Test {
   def main(args: Array[String]) {
      var a = 60;           /* 60 = 0011 1100 */  
      var b = 13;           /* 13 = 0000 1101 */
      var c = 0;

      c = a & b;            /* 12 = 0000 1100 */ 
      println("a & b = " + c );

      c = a | b;            /* 61 = 0011 1101 */
      println("a | b = " + c );

      c = a ^ b;            /* 49 = 0011 0001 */
      println("a ^ b = " + c );

      c = ~a;               /* -61 = 1100 0011 */
      println("~a = " + c );

      c = a << 2;           /* 240 = 1111 0000 */
      println("a << 2 = " + c );

      c = a >> 2;           /* 15 = 1111 */
      println("a >> 2  = " + c );

      c = a >>> 2;          /* 15 = 0000 1111 */
      println("a >>> 2 = " + c );
   }
}

结果:
$ scalac Test.scala 
$ scala Test
c = a + b  = 30
c += a  = 40
c -= a = 30
c *= a = 300
c /= a  = 1
c %= a  = 5
c <<= 2  = 20
c >>= 2  = 5
c >>= a  = 0
c &= 2  = 0
c ^= a  = 10
c |= a  = 10