Scala面向对象彻底精通及Spark源码阅读

1.Scala中的类、object实战讲解
java8前 ：类或对象中新增加一个方法，方法中本身调用其他方法，写匿名内部类写个方法，回调，
java8 lamada解决了此问题
scala （无需考虑该问题）方法里有一个方法，不用写匿名内部类，new实例
scala适合大型规模项目

方法method
定义两个函数，sayName，不接受返回值，返回值是Unit类型
getName,定义为函数，并把它赋值为name，（scala中函数和变量是同等地位的）
scala不传参数，可不写括号
name本身是private，而jvm会生成private的setter，getter方法，如果没有private，jvm会生成public的setter，getter方法

scala.name不是访问的name，而是访问的是jvm自动生成的public的getter，setter方法

覆写getter ，setter方法
_ = (间没有空格

class Person {
private var myName = "Flink"
def name = this.myName
def name_=(newName :String){
myName=newName
println("Hi:"+myName)}
}

不希望其他人修改name，不覆写setter方法，但是重新定义一个函数update进行修改

class Person {
 private var myName = "Flink"
 def name = this.myName
 def update(newName :String){
  myName=newName
  println("Hi:"+myName)
 }
}

private[this]
不仅是类私有，更强一层的控制，类中的方法或属性是对象私有

class Person {
 private var myName = "Flink"
 def name = this.myName
 def update(newName :String){
  myName=newName
  println("Hi:"+myName)
 }
 def talk(p : Person) = {
 println("hello"+p.name)
 }
}

private[this],不能访问

class Person {
 private[this] var name = "Flink"
 def update(newName :String){
  name=newName
  println("Hi:"+name)
 }
 def talk(p : Person) = {
 println("hello"+p.name)
 }
}

构造器
所有重载的构造器都必须调用默认的构造器或者其他重载的构造器

class Person {
  var name = "Flink"
  var age = 10
 def this(name : String)
 {
 this()
 this.name =name
 }
 def this(name : String,age:Int)
 {
 this(name)
 this.age=age
 }
}

class加载：从开头往下执行，有print就会执行

object所有成员都是静态的,静态的方法（全局唯一）
伴生对象，有默认的construter，不接受参数，再次调用，不会执行
伴生对象和伴生类必须在一个类中

object Person{
println("Scala")
var salary=0.0
def getSalary=salary
}

伴生类的伴生对象的apply方法

2.Scala中的抽象类、接口实战详解
与Java一样：
抽象abstract class
override 重写父类方法
抽象属性：定义的时候没有赋值
抽象方法：定义的时候没有给方法体

伴生对象的apply方法：它就是当前类的对象的工厂方法，它可以控制对象的生成。

scala不支持多重继成

trait：工具方法的一个容器
接口：trait
第一个接口用extends关键字，第二个接口用with关键字
extends Serializable with Logging
3.综合案例及Spark源码解析
SparkContext
RDD
SparkConf只产生一次

作业：分析Spark核心类：SparkContent，RDD，读懂70%代码

SparkContext类源码解析：

SparkContex位于项目的源码路径\spark-master\core\src\main\scala\org\apache\spark\SparkContext.scala中，源文件包含SparkContextClasss声明和其伴生对象SparkContextObject

class SparkContext extends了Logging。Logging是一个trait，它是用于存放工具方法的一个容器，trait封装方法和字段。把trait混入到类中，就可以重用它们。一个类，可以继承任意多个trait，多个trait继承采用with来实现，可以将trait视为Java的接口interface，跟interface非常相似。唯一的差别在于，interface声明函数，但不实现它们，trait可以实现函数。

trait跟class的差别在于，trait没有任何类参数，trait调用的方法是动态绑定的。

class SparkContext类中有多个重载的构造方法：
如下：

def this(master: String, appName: String, conf: SparkConf) =
this(SparkContext.updatedConf(conf, master, appName))

@deprecated("Passing in preferred locations has no effect at all, see SPARK-10921", "1.6.0")
def this(
master: String,
appName: String,
sparkHome: String = null,
jars: Seq[String] = Nil,
environment: Map[String, String] = Map(),
preferredNodeLocationData: Map[String, Set[SplitInfo]] = Map()) =
{
this(SparkContext.updatedConf(new SparkConf(), master, appName, sparkHome, jars, environment))
if (preferredNodeLocationData.nonEmpty) {
logWarning("Passing in preferred locations has no effect at all, see SPARK-8949")
}
}


val startTime = System.currentTimeMillis()

startTime没有加上private，scala编译时，startTime这个变量是私有的，但会自动的生成它的public的get和set方法，供外部对象调用。

private[spark] val stopped: AtomicBoolean = new AtomicBoolean(false)

private[class_name] 指定可以访问该字段的类，访问的级别较严，在编译时，会自动的生成get和set方法，class_name必须是当前定义的类或类的外部类。

private def assertNotStopped(): Unit = {}

这个方法它是一个过程，因为返回值是Unit，没有结果返回。

RDD类源码解析：
class RDD它是个抽象类，

private[spark] def conf = sc.conf

private[class_name] 指定可以访问该字段的类，访问的级别较严，在编译时，会自动的生成get和set方法，class_name必须是当前定义的类或类的外部类。

class RDD类中有很多加了final修饰符的方法，表示：此方法或属性，子类继承此类时不可被覆写，如下：

final def dependencies: Seq[Dependency[_]] = {
checkpointRDD.map(r => List(new OneToOneDependency(r))).getOrElse {
if (dependencies_ == null) {
dependencies_ = getDependencies
}
dependencies_
}
}

final def partitions: Array[Partition] = {
checkpointRDD.map(_.partitions).getOrElse {
if (partitions_ == null) {
partitions_ = getPartitions
}
partitions_
}
}

final def getNumPartitions: Int = partitions.length