?

1. scala初識

spark由scala編寫，要解析scala，首先要對scala有基本的了解。

1.1 class vs object

A class is a blueprint for objects. Once you define a class, you can create objects from the class blueprint with the keyword?new.?

import java.io._class Point(val xc: Int, val yc: Int) {var x: Int = xcvar y: Int = ycdef move(dx: Int, dy: Int) {x = x + dxy = y + dyprintln ("Point x location : " + x);println ("Point y location : " + y);} }object Test {def main(args: Array[String]) {val pt = new Point(10, 20);// Move to a new locationpt.move(10, 10);} }

類的繼承，使用extend實現：

import java.io._class Point(val xc: Int, val yc: Int) {var x: Int = xcvar y: Int = ycdef move(dx: Int, dy: Int) {x = x + dxy = y + dyprintln ("Point x location : " + x);println ("Point y location : " + y);} }class Location(override val xc: Int, override val yc: Int,val zc :Int) extends Point(xc, yc){var z: Int = zcdef move(dx: Int, dy: Int, dz: Int) {x = x + dxy = y + dyz = z + dzprintln ("Point x location : " + x);println ("Point y location : " + y);println ("Point z location : " + z);} }object Test {def main(args: Array[String]) {val loc = new Location(10, 20, 15);// Move to a new locationloc.move(10, 10, 5);} }

單例對象

　　Scala is more object-oriented than Java because in Scala we cannot have static members. Instead, Scala has?singleton objects. A singleton is a class that can have only one instance, i.e., object. You create singleton using the keywordobject?instead of class keyword. Since you can't instantiate a singleton object, you can't pass parameters to the primary constructor. You already have seen all the examples using singleton objects where you called Scala's main method. Following is the same example of showing singleton:

import java.io._class Point(val xc: Int, val yc: Int) {var x: Int = xcvar y: Int = ycdef move(dx: Int, dy: Int) {x = x + dxy = y + dy} }object Test {def main(args: Array[String]) {val point = new Point(10, 20)printPointdef printPoint{println ("Point x location : " + point.x);println ("Point y location : " + point.y);}} }

1.2?trait?

A trait encapsulates method and field definitions, which can then be reused by mixing them into classes. Unlike class inheritance, in which each class must inherit from just one superclass, a class can mix in any number of traits.Traits are used to define object types by specifying the signature of the supported methods. Scala also allows traits to be partially implemented but traits may not have constructor parameters.

a trait is very similar to what we have?abstract classes?in Java. Below is a complete example to show the concept of traits:

trait Equal {def isEqual(x: Any): Booleandef isNotEqual(x: Any): Boolean = !isEqual(x) }class Point(xc: Int, yc: Int) extends Equal {var x: Int = xcvar y: Int = ycdef isEqual(obj: Any) =obj.isInstanceOf[Point] &&obj.asInstanceOf[Point].x == x }object Test {def main(args: Array[String]) {val p1 = new Point(2, 3)val p2 = new Point(2, 4)val p3 = new Point(3, 3)println(p1.isNotEqual(p2))println(p1.isNotEqual(p3))println(p1.isNotEqual(2))} }

1.3?extractor?

An extractor in Scala is an object that has a method called?unapply?as one of its members. The purpose of that unapply method is to match a value and take it apart. Often, the extractor object also defines a dual method?apply?for building values, but this is not required.

Following example shows an extractor object for email addresses:

object Test {def main(args: Array[String]) {println ("Apply method : " + apply("Zara", "gmail.com"));println ("Unapply method : " + unapply("Zara@gmail.com"));println ("Unapply method : " + unapply("Zara Ali"));}// The injection method (optional)def apply(user: String, domain: String) = {user +"@"+ domain}// The extraction method (mandatory)def unapply(str: String): Option[(String, String)] = {val parts = str split "@"if (parts.length == 2){Some(parts(0), parts(1)) }else{None}} }

1.4?closure?

?A?closure?is a function, whose return value depends on the value of one or more variables declared outside this function.?

object Test {def main(args: Array[String]) {println( "muliplier(1) value = " + multiplier(1) )println( "muliplier(2) value = " + multiplier(2) )}var factor = 3val multiplier = (i:Int) => i * factor }

?i, is a formal parameter to the function. Hence, it is bound to a new value each time multiplier is called.

?1.5?function?

　　A function is a group of statements that together perform a task. You can divide up your code into separate functions. How you divide up your code among different functions is up to you, but logically, the division usually is so that each function performs a specific task.

　　Scala has both functions and methods and we use the terms method and function interchangeably with a minor difference. A Scala method is a part of a class which has a name, a signature, optionally some annotations, and some bytecode where as a function in Scala is a complete object which can be assigned to a variable. In other words, a function, which is defined as a member of some object, is called a method.

　　A function definition can appear anywhere in a source file and Scala permits nested function definitions, that is, function definitions inside other function definitions. Most important point to note is that Scala function's name can have characters like +, ++, ~, &,-, -- , \, /, : etc.

object Test { def main(args: Array[String]) { println( "Returned Value : " + addInt(5,7) ); } def addInt( a:Int, b:Int ) : Int = { var sum:Int = 0 sum = a + b return sum } }

?

參考文獻：

【1】http://www.tutorialspoint.com/scala/scala_classes_objects.htm

【2】http://www.tutorialspoint.com/scala/scala_traits.htm

【3】http://www.tutorialspoint.com/scala/scala_extractors.htm

【4】http://www.tutorialspoint.com/scala/scala_functions.htm

【5】http://www.tutorialspoint.com/scala/scala_closures.htm

轉載于:https://www.cnblogs.com/davidwang456/p/5137456.html

總結

以上是生活随笔為你收集整理的spark源码解析之scala基本语法的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。