一 入门

1 hello scala world 代码解析

package com.hike.bigdata.scala.chapter01

/**
 * scala语言是基于java开发的
 *
 * package：java中的包
 *
 * object：声明一个对象，在编译时，会编译为两个类文件
 *         声明对象的类型为：当前对象+$
 *      java：
 *        User user = new User();
 *        user.setName();
 *      scala：
 *        Scala01_HelloWorld = new Scala01_HelloWorld$();
 *
 * Scala01_HelloWorld：对象名称
 *
 * def：声明方法的关键字
 *
 * main：scala程序的入口方法名，没有main，程序执行不了
 *
 * ()：方法的参数列表
 *
 * args: Array[String]：参数
 *        java：
 *          String[] args，强类型语言，在运行之前就要确定变量是什么类型
 *                         在开发的过程中，变量名称比变量类型更重要
 *                         所以scala先写名称，在名称和类型之间加上冒号作为分隔符
 *        scala：
 *          args:Array[String]
 *            args：参数名
 *            Array[String]：参数类型
 *            ： 分隔符
 *
 * Array[String]：Array是一个数组类型
 *                scala语言是一个完全面向对象的语言，所以万物皆对象
 *                数组也是对象，也有自己的类型，类型为：Array，这里的[]表示泛型
 *
 *                java中的数组：
 *                  String[]：String表示数组中元素的类型，[]表示数组，
 *                            数组在java中没有类型
 * : Unit =>    在scala中：
 *                  名称：类型
 *                  参数名：参数类型
 *                  变量名：变量类型
 *                  方法名：方法的返回值类型
 *
 *                Unit表示返回值类型，Unit是scala中新的类型，为了代替void关键字，表示没有返回值
 *                  void关键字的问题：返回有值，加上变量的类型，如int String
 *                                   返回无值，加上关键字，并不统一
 *                                   等于将关键字与类型等同，并不合理，所以有了Unit类型
 * =：赋值
 * 
 * {}：方法体
 *
 * System.out.println("Hello Scala World")：java代码
 *      scala语言基于java语言开发，所以大部分的java代码可以直接在scala中使用
 *
 * 代码可以不需要分号结尾，scala推荐一行代码中只有一个逻辑，则分号可以省略
 * 如果一行有多个逻辑那么需要加上分号
 */
object Scala01_HelloWorld {
  def main(args: Array[String]): Unit = {
    System.out.println("Hello Scala World")
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

2 反编译

如果只是通过代码来进行语法的解析，并不能了解其真正的实现原理。scala语言是基于Java语言开发的，所以也会编译为class文件，那么我们可以通过反编译指令javap -v 类名 或 反编译工具jd-gui.exe查看scala编译后的代码，通过对比和java语言之间的关系，来掌握具体代码的实现原理。

3 关联源码

在使用Scala过程中，为了搞清楚Scala底层的机制，需要查看源码，那么就需要关联和查看Scala的源码包。

将源码下载下来，选择路径。

二 变量和数据类型

1 变量

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

（1）变量声明

def main(args: Array[String]): Unit = {
      // TODO 变量
      // Java中变量声明： String name = "zhangsan";
      // scala中变量声明(1)：var 变量名 ：变量类型 = 变量值
      var name_var : String = "zhangsan"
      
      // 某些变量在某些场景中，初始化完成之后不能重新赋值
      // scala中变量声明(2)：val 变量名 ：变量类型 = 变量值
      val name_fin : String = "lisi"
      
   }
1
2
3
4
5
6
7
8
9
10
11

变量的类型如果能够通过变量值推断出来，那么可以省略类型声明，这里的省略，并不是不声明，而是由Scala编译器在编译时自动声明编译的。

def main(args: Array[String]): Unit = {
    // TODO 变量
    // 强类型语言中，类型的声明应该前后一致
    // 如果明确的知道变量的取值是什么类型，那么变量的类型可以省略不写
    // 如果使用多态，类型不能省略
    var name = "zhangsan"
    println(name)
  }
1
2
3
4
5
6
7
8

（2） 变量初始化

Java语法中变量在使用前进行初始化就可以，但是Scala语法中是不允许的，必须显示进行初始化操作。

def main(args: Array[String]): Unit = {
        var username // Error
        val username = "zhangsan" // OK
  }
1
2
3
4

（3） 可变变量

值可以改变的变量，称之为可变变量，但是变量类型无法发生改变, Scala中可变变量使用关键字var进行声明。

def main(args: Array[String]): Unit = {
        // 用户名称
        var username : String = "zhangsan"
        username = "lisi" // OK
        username = true // Error
    }
1
2
3
4
5
6

（4） 不可变变量

值一旦初始化后无法改变的变量，称之为不可变变量。Scala中不可变变量使用关键字val进行声明, 类似于Java语言中的final关键字。

def main(args: Array[String]): Unit = {
        // 用户名称
        val username : String = "zhangsan"
        username = "lisi" // Error
        username = true // Error
    }
1
2
3
4
5
6

val和var两个修饰符，推荐使用val

Java中的字符串为何称之为不可变字符串：因为在java中字符串的定义是private final char[] value;，并且String类没有提供任何改变内容的方法。所有对字符串操作的方法都会产生新的字符串。

trim方法用于去掉字符串的首尾半角空格。（欧美为半角，亚洲欧洲为全角）

2 标识符

（1）标识符定义规则

Scala的标识符和java的标识符基本一致，可以使用两种形式的标志符，字符数字和符号。

• 字符数字使用字母或是下划线开头，后面可以接字母或是数字，在 Scala 中[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传$也看作为字母。然而以开头的标识符为保留的Scala编译器产生的标志符使用，应用程序应该避免使用$开始的标识符，以免造成冲突。
• Scala 的命名规范采用和 Java 类似的 camel 命名规范，首字符小写，比如 toString。类名的首字符还是使用大写。此外也应该避免使用以下划线结尾的标志符以避免冲突。
• Scala 内部实现时会使用转义的标志符，比如:-> 使用 $colon$minus$greater 来表示这个符号。

// 和Java一样的标识符命名规则
/*
	数字，字母，下划线，$
	数字不能开头
	不能使用关键字和保留字
	区分大小写
	长度没有限制
*/
val name = "zhangsan" // OK
val name1 = "zhangsan0"   // OK
//val 1name = "zhangsan0" // Error
val name$ = "zhangsan1" // OK
val $name = "zhangsan2" // OK
val name_ = "zhangsan3" // OK
val _name = "zhangsan4" // OK
val $ = "zhangsan5"     // OK
val _ = "zhangsan6"     // OK
//val 1 = "zhangsan6"     // Error
//val true = "zhangsan6"  // Error
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

// 和Java不一样的标识符命名规则
// scala中的标识符可以用于声明运算符
val + = "lisi" // OK
println(+)
val - = "lisi" // OK
val * = "lisi" // OK
val / = "lisi" // OK
val ! = "lisi" // OK

//val @ = "lisi" // Error
val @@ = "lisi" // OK
//val # = "lisi" // Error
val ## = "lisi" // OK
val % = "lisi" // OK
val ^ = "lisi" // OK
val & = "lisi" // OK
//val ( = "lisi" // Error
//val ( = "lisi" // Error
//val ) = "lisi" // Error
//val = = "lisi" // Error
val == = "lisi" // OK
//val [ = "lisi" // Error
//val ] = "lisi" // Error
//val : = "lisi" // Error
val :: = "lisi" // OK
//val ; = "lisi" // Error
//val ' = "lisi" // Error
//val " = "lisi" // Error
val "" = "lisi" // OK
val < = "lisi" // OK
val > = "lisi" // OK
val ? = "lisi" // OK
val | = "lisi" // OK
val \ = "lisi" // OK
//val ` = "lisi" // Error
val ~ = "lisi" // OK
val :-> = "wangwu" // OK
val :-< = "wangwu" // OK
// 切记，能声明和能使用是两回事
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

//颜文字
var :-> = "zhangsan"
//var $colon$minus$greater = "zhangsan"
println(:->)
//一般情况下，标识符起名不能使用$开头
//反编译后的代码
//编译时，将特殊符号编译为转换的变量名，变量名以$开头
String $colon$minus$greater = "zhangsan";
1
2
3
4
5
6
7
8

Scala 中的标识符也不能是关键字或保留字，Scala中的关键字或保留字

（2）在Java语言中访问Scala对象

  def test(): Unit = {

  }
//在java代码中定义  
  public class TestObject {
    public static void main(String[] args) {
        Scala02_name.test();
    }
}
1
2
3
4
5
6
7
8
9

（3）如果变量就想使用特定含义的关键字

    var `private` = "私有的"
    println(`private`)
    
    Thread.`yield`()
1
2
3
4