浅谈scala-API的基础概念及简单例子

为什么学习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 + 1
println(addOne(1)) // 2

函数可带有多个参数。

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

或者不带参数。

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

方法

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

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

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

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

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

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

或者没有参数列表。

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

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

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

def getSquareString(input: Double): String = {val square = input * inputsquare.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 + dxy = y + dy}override def toString: String =s"($x, $y)"//此为占位符的写法，在接下来的内容中会有介绍
}

val point1 = new Point(2, 3)
point1.x  // 2
println(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 0
val 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 = 0private var _y = 0private val bound = 100def x = _xdef x_= (newValue: Int): Unit = {if (newValue < bound) _x = newValue else printWarning}def y = _ydef y_= (newValue: Int): Unit = {if (newValue < bound) _y = newValue else printWarning}private def printWarning = println("WARNING: Out of bounds")
}

val point1 = new Point
point1.x = 99
point1.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 = 0def create(): Int = {counter += 1counter}
}

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

val newId: Int = IdFactory.create()
println(newId) // 1
val 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.eatp1.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 = 987654321
val 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 = 987654321
val y: Float = x  // 9.8765434E8
val z: Long = y  // Does not conform

Nothing和Null

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

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