为什么学习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 * 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 User
val 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 // 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 = 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 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 = 0
def create(): Int = {
counter += 1
counter
}
}
可以通过引用它的名字来访问一个对象。
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 Greeter
class 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 = 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的替代方案。
1110
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
