一、Scala

Scala基于JVM, 和Java完全兼容, 同样具有跨平台,可以执行好,方便的垃圾回收等特性;
Scala是一种纯粹的面向对象语言;
Scala是一门函数式编程语言；
Scala对集合类型数据处理有非常好的支持

Spark的底层用Scla编写, 深入学习Spark必定要掌握Scala。

二、Scala基础语法

注意：

scala中每行后面都会有分号自动推断机制，不用显式写出“；”
建议在scala中，类名首字母大写，方法首字母小写，类和方法命名建议符合驼峰命名法

2.1 注释与标识符规范

（1）注释：

//  	1.单行注释

/* */ 	2. 多行注释

/** 	3. 文档注释
*
**/

（2）标识符命名规范：

字母下划线开头，后跟字母数字下划线，和C/C++/Java一样。
操作符开头，且只包含(+-*/#!等)，也是有效的标识符。这样用会用什么奇怪的好处吗？答案是灵活到天顶星的运算符重载。
用反引号包括的任意字符串，即使是同39个Scala关键字同名也可以。

var _abc:String = "hello"
val -+/%# = 10
val `if` = 10
println(_abc)
println(-+/%#)
println(`if`)

关键字：

package import class obejct trait extends with type for
private protected abstract sealed final implicit lazy override
try catch finlly throw
if else match case do while for return yield
def var val
this super
new
true false null
其中Java没有的关键字：object trait with implicit match yield def val var

字符串：

类型：String
+号连接
*字符串乘法，复制一个字符串多次
printf格式化输出
字符串插值：s"xxx${varname}"前缀s模板字符串，前缀f格式化模板字符串，通过$获取变量值，%后跟格式化字符串。
原始字符串：raw"rawstringcontents${var}"，不会考虑后跟的格式化字符串。
多行字符串：""" """。
输出：print printf println ...

    val name: String = "Pyrrha" + " " + "Nikos"  // +号拼接字符串
    val age = 17
    println((name + " ") * 3)  // 将一个字符串复制多次进行拼接
    printf("%s : dead in %d\n", name, age) // printf：前缀f格式化模板字符串，通过$获取变量值，%后跟格式化字符串
    print(s"$name : dead in ${age}") // 字符串插值：前缀s模板字符串，通过$获取变量值
    val power = 98.9072
    println(f" : power ${power}%.2f.") // 取小数后2位

2.2 变量与常量

Scala有两种类型的变量：

关键字 var 声明的变量，值是可变的；
关键字 val 声明的变量，也叫常量，值是不可变的；

注意：

变量的类型如果能够通过变量值推断出来，那么可以省略类型声明；
变量必须进行显示初始化；
一般默认为val类型变量；

【案例：变量声明和赋值】

object HelloWorld {
  def main(args: Array[String]): Unit = {
    // 定义方法 main ==  def 方法名(参数名: 参数类型):返回值 ={}
    println("hello world")

    //1. 类型推导; 声明变量时, 类型可以忽略, 编译器会自动推导;
    var a1 = 10;
    var a2: Int = 10;
    var b3 = "areusb?";
    val c5 = false;

    //2. 强类型语言; 变量/常量的数据类型确定后, 就不能再修改
    var e3: Int = 250;
    e3 = "feswgf"; // 编译器不会对此句报错, 执行时才会报错 type mismatch

    //3. 声明变量时必须有初始值，否则报错;
    var e4: Int;

    //4. var可变, va不可变
    var f4 = 6;
    f4 = 9;
    val f5 = 100;
    f5 = 200; // 编译器当场报错;
  }
}

控制台中输出结果：

2.3 object

scala 中的object是单例对象，相当于java中的工具类，可以看成是定义静态的方法的类。

如果在同一个文件中，object对象和class类的名称相同，则这个对象就是这个类的伴生对象，这个类就是这个对象的伴生类。可以互相访问私有变量。

【案例：伴生对象，val通过对象来改变属性】

object不可以传参数；
scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。重写构造函数的时候，必须要调用默认的构造函数；
class类中的属性默认有setter和getter方法；

package test

class Student(name: String, var age: Int) {
  def printInfo(): Unit = {
    println(name + " " + age + " " + Student.school)
  }
}

// 引入 object 伴生对象/单例对象，所有的私有属性都可以互相访问
object Student {
  val school: String = "atguigu"

  def main(args: Array[String]): Unit = {
    val alice = new Student(name = "alice", age = 19)
    alice.age = 24
    alice.printInfo()
  }
}

控制台中输出结果：

【案例：重写构造函数，对象中的apply方法】

scala中的class类默认可以传参数，默认的传参数就是默认的构造函数。重写构造函数的时候，必须要调用默认的构造函数；
使用object时，不用new；使用class时要new ,并且new的时候，class中除了方法不执行（不包括构造），其他都执行；
对象中的apply方法：object中不可以传参，当创建一个object时，如果传入参数，那么会自动寻找object中的相应参数个数的apply方法；

package com.yt.test

class Person(xname: String, xage: Int) {
  val name = xname
  var age = xage
  var gender = 'M'
  println("----------- Person Class -----------") // new时，class中除了方法不执行（不包括构造），其他都执行

  def this(yname: String, yage: Int, ygender: Char) {
    this(yname, yage)  // 类中重写构造时，构造中第一行要调用默认的构造函数
    this.gender = ygender
  }

  def sayName() = {
    println("sayName:", ClassAndObj.name) // 调用object静态属性
  }
  println("************ Person Class ************")
}

object ClassAndObj {
  println("----------- ClassAndObj object -----------")
  val name = "wangwu" // object静态属性，相当于java的工具类

  def apply(s: String, age: Int) = {
    println("name is " + s + ",age" + age)
  }

  def main(args: Array[String]): Unit = {
    val p1 = new Person("zhangsan", 19)
    val p2 = new Person("zhangsan", 19, 'F')
    p1.age = 200
    println(p1.name, p1.age)
    p1.sayName()
    println(p2.name, p2.age, p2.gender)

    ClassAndObj("lisi", 500)
  }

}

控制台中输出结果：