本文共 7420 字，大约阅读时间需要 24 分钟。

为什么学习scala

唯一的目的就是:能够看懂Spark源码;

介绍scala

Scala:它不是一门新的编程语言,而是一个结合体;

scala要想运行,必须安装jdk;它的编译和运行在jdk基础之上;(scala就是java的一个框架而已) 它的语法和javascript很像; 一个方法的参数类型居然还可以是方法;(函数编程)(和lambda表达式的思想很像)

在scala中,类型可是方法;在java中类型(基本数据类型和引用类型;在javascript中类型又多了一个function;scala就是把javascript和java结合起来)

要定义一个变量,或者准备要使用一个类型,必须定义变量是什么类型;(强类型语言);scala是一个弱类型语言(变量不需要指定类型);javascript也是一个弱类型语言

代码块:直接用大括号括起来,代码块

函数和方法类似,但是两个不相等;

方法是被def修饰,

函数是木有被def修饰

剩下的都一样

函数

函数是带有参数的表达式。

你可以定义一个匿名函数（即没有名字），来返回一个给定整数加一的结果。

(x: Int) => x + 1

=>的左边是参数列表，右边是一个包含参数的表达式。

你也可以给函数命名。

val addOne = (x: Int) => x + 1println(addOne(1)) // 2

函数可带有多个参数。

val add = (x: Int, y: Int) => x + yprintln(add(1, 2)) // 3

或者不带参数。

val getTheAnswer = () => 42println(getTheAnswer()) // 42

方法

方法的表现和行为和函数非常类似，但是它们之间有一些关键的差别。

方法由def关键字定义。def后面跟着一个名字、参数列表、返回类型和方法体。

def add(x: Int, y: Int): Int = x + yprintln(add(1, 2)) // 3

注意返回类型是怎么在函数列表和一个冒号: Int之后声明的。

方法可以接受多个参数列表。

def addThenMultiply(x: Int, y: Int)(multiplier: Int): Int = (x + y) * multiplierprintln(addThenMultiply(1, 2)(3)) // 9

或者没有参数列表。

def name: String = System.getProperty("user.name")println("Hello, " + name + "!")

还有一些其他的区别，初学者可以认为方法就是类似于函数的东西。

方法也可以有多行的表达式。

def getSquareString(input: Double): String = {  val square = input * input  square.toString}println(getSquareString(2.5)) // 6.25

方法体的最后一个表达式就是方法的返回值。（Scala中也有一个return关键字，但是很少使用）

所有的代码都可以省略

如果方法的形参木有,小括号可以省略

如果方法木有返回值,那么方法名后面跟的是:返回值可以省略

如果大括号(方法体)只有一行,那大括号可以省略 例如：

//省略写法

def fun5 = println(“a + b ===== 测试一下”); //最全写法 def fun3(x:String):String={ x }

var fun1 = (a:Int,b:Int) => {a + b}    /* 两者作用一样 */    def fun2(a:Int,b:Int) :Int = {a + b}

类

Scala中的类是用于创建对象的蓝图，其中包含了方法、常量、变量、类型、对象、特质、类，这些统称为成员.

可以使用class关键字定义一个类，后面跟着它的名字和构造参数。

class Greeter(prefix: String, suffix: String) {  def greet(name: String): Unit =    println(prefix + name + suffix)}

类定义

一个最简的类的定义就是关键字class+标识符，类名首字母应大写。

class Userval user1 = new User

关键字new被用于创建类的实例。User由于没有定义任何构造器，因而只有一个不带任何参数的默认构造器。然而，通常需要一个构造器和类体。下面是类定义的一个例子：

class Point(var x: Int, var y: Int) {  def move(dx: Int, dy: Int): Unit = {    x = x + dx    y = y + dy  }  override def toString: String =    s"($x, $y)"//此为占位符的写法，在接下来的内容中会有介绍}

val point1 = new Point(2, 3)point1.x  // 2println(point1)  // prints (2, 3)

Point类有4个成员：变量x和y，方法move和toString。与许多其他语言不同，主构造方法在类的签名中(var x: Int, var y: Int)。move方法带有2个参数，返回无任何意义的Unit类型值()。这一点与Java这类语言中的void相当。另外，toString方法不带任何参数但是返回一个String值。因为toString覆盖了AnyRef中的toString方法，所以用了override关键字标记。

构造器

构造器可以通过提供一个默认值来拥有可选参数：

class Point(var x: Int = 0, var y: Int = 0)val origin = new Point  // x and y are both set to 0val point1 = new Point(1)println(point1.x)  // 1

在这个Point类中，x和y拥有默认值0所以没有必传参数。然而，因为构造器是从左往右读取参数，所以如果仅仅要传个y的值，需要带名传参。

class Point(var x: Int = 0, var y: Int = 0)val point2 = new Point(y=2)println(point2.y)  //  2

这样的做法在实践中有利于使得表达明确无误。

私有成员和Getter/Setter语法

成员默认是公有（public）的。使用private访问修饰符可以在类外部隐藏它们。

class Point {  private var _x = 0  private var _y = 0  private val bound = 100  def x = _x  def x_= (newValue: Int): Unit = {    if (newValue < bound) _x = newValue else printWarning  }  def y = _y  def y_= (newValue: Int): Unit = {    if (newValue < bound) _y = newValue else printWarning  }  private def printWarning = println("WARNING: Out of bounds")}

val point1 = new Pointpoint1.x = 99point1.y = 101 // prints the warning

在Point类中，数据存在私有变量_x和_y中。def x和def y方法用于访问私有数据。def x_=和def y_=是为了验证和给_x和_y赋值。注意下对于setter方法的特殊语法：这个方法在getter方法的后面加上_=，后面跟着参数。

主构造方法中带有val和var的参数是公有的。然而由于val是不可变的，所以不能像下面这样去使用。

class Point(val x: Int, val y: Int)val point = new Point(1, 2)point.x = 3  // <-- does not compile

不带val或var的参数是私有的，仅在类中可见。

class Point(x: Int, y: Int)val point = new Point(1, 2)point.x  // <-- does not compile

greet方法的返回类型是Unit，表明没有什么有意义的需要返回。它有点像Java和C语言中的void。（不同点在于每个Scala表达式都必须有值，事实上有个Unit类型的单例值，写作()，它不携带任何信息）

可以使用new关键字创建一个类的实例。

val greeter = new Greeter("Hello, ", "!")greeter.greet("Scala developer") // Hello, Scala developer!

样例类

Scala有一种特殊的类叫做样例类（case class）。默认情况下，样例类一般用于不可变对象，并且可作值比较。可以使用case class关键字来定义样例类。

/*  * 样例类:(Case Class) * 样例类一般不用于可变的对象,并且可以做值比较(只有四类八种基本数据类型;==) * 样例类可以不用new来创建对象 * 样例类:toString:默认就是构造方法,同时把值带上了 * Point(点) */case class Point(x:Int,y:Int)

不用new关键字来实例化样例类。

val point = Point(1, 2)val anotherPoint = Point(1, 2)val yetAnotherPoint = Point(2, 2)

/* 创建案例类 */    var po1 = Point(3,4)    var po2 = Point(3,4);    println("==po1==" + po1.toString())    /* 案例类默认已经重写了equals方法,它比较的就是值 */    println("po1 == po2===" + (po1 == po2) )

并且它们的值可以进行比较。

if (point == anotherPoint) {  println(point + " and " + anotherPoint + " are the same.")} else {  println(point + " and " + anotherPoint + " are different.")} // Point(1,2) and Point(1,2) are the same.if (point == yetAnotherPoint) {  println(point + " and " + yetAnotherPoint + " are the same.")} else {  println(point + " and " + yetAnotherPoint + " are different.")} // Point(1,2) and Point(2,2) are different.

对象

对象是它们自己定义的单实例，可以把它看作它自己的类的单例。

可以使用object关键字定义对象。

/**object;对象的意思 ,默认就是单例;一个jvm只能有一个java对象*/object IdFactory {  private var counter = 0  def create(): Int = {    counter += 1    counter  }}

可以通过引用它的名字来访问一个对象。

val newId: Int = IdFactory.create()println(newId) // 1val newerId: Int = IdFactory.create()println(newerId) // 2

特质

特质是包含某些字段和方法的类型。可以组合多个特质。

使用trait关键字定义特质。

trait Greeter {  def greet(name: String): Unit}

特质也可以有默认的实现。

trait Greeter {  def greet(name: String): Unit =    println("Hello, " + name + "!")}

使用extends关键字来继承特质，使用**override(不写报错)**关键字来覆盖默认的实现。

class DefaultGreeter extends Greeterclass CustomizableGreeter(prefix: String, postfix: String) extends Greeter {  override def greet(name: String): Unit = {    println(prefix + name + postfix)  }}val greeter = new DefaultGreeter()greeter.greet("Scala developer") // Hello, Scala developer!val customGreeter = new CustomizableGreeter("How are you, ", "?")customGreeter.greet("Scala developer") // How are you, Scala developer?

这里，DefaultGreeter仅仅继承了一个特质，它还可以继承多个特质。

举个简单的例子

/** * 定义一个接口 */trait IAdmin{  /* 抽象方法 */  def eat():Unit ;  /* 抽象方法 */  def sleep;}/** * 一个类实现一个接口,要重写接口中所有的方法 */class Per extends IAdmin {    def eat(): Unit = {    println("=Per==eat=");  }  def sleep: Unit = {     println("=Per==sleep=");  }}/** * 写一个男人,继承自Per */class Man extends Per{  /* 对父类的方法不满意,要重写   * 必须加上override   *  */  override def eat() :Unit =  {    println("==Maneat==");  }}var p1 = new Per;    p1.eat    p1.sleep        /* 创建一个男人 */    var m:Man = new Man();    m.eat();    m.sleep;

主方法

主方法是一个程序的入口点。JVM要求一个名为main的主方法，接受一个字符串数组的参数。

通过使用对象，可以如下所示来定义一个主方法。

object Main {  def main(args: Array[String]): Unit =    println("Hello, Scala developer!")}

Scala类型层次结构

Any是所有类型的超类型，也称为顶级类型。它定义了一些通用的方法如equals、hashCode和toString。Any有两个直接子类：AnyVal和AnyRef。

AnyVal代表值类型。有9个预定义的非空的值类型分别是：Double、Float、Long、Int、Short、Byte、Char、Unit和Boolean。Unit是不带任何意义的值类型，它仅有一个实例可以像这样声明：()。所有的函数必须有返回，所以说有时候Unit也是有用的返回类型。

AnyRef代表引用类型。所有非值类型都被定义为引用类型。在Scala中，每个用户自定义的类型都是AnyRef的子类型。如果Scala被应用在Java的运行环境中，AnyRef相当于java.lang.Object。

类型转换

val x: Long = 987654321val y: Float = x  // 9.8765434E8 (note that some precision is lost in this case)val face: Char = '☺'val number: Int = face  // 9786

转换是单向，下面这样写将不会通过编译。

val x: Long = 987654321val y: Float = x  // 9.8765434E8val z: Long = y  // Does not conform

Nothing和Null

Nothing是所有类型的子类型，也称为底部类型。没有一个值是Nothing类型的。它的用途之一是给出非正常终止的信号，如抛出异常、程序退出或者一个无限循环（可以理解为它是一个不对值进行定义的表达式的类型，或者是一个不能正常返回的方法）。

Null是所有引用类型的子类型（即AnyRef的任意子类型）。它有一个单例值由关键字null所定义。Null主要是使得Scala满足和其他JVM语言的互操作性，但是几乎不应该在Scala代码中使用。我们将在后面的章节中介绍null的替代方案。

转载地址：http://agrzi.baihongyu.com/