大数据系列第二课：scala基础

第一部分总结

一：定义类

class HiScala {
private var name = "Spark"
def sayName(){
println(name)
}
def getName = name
}

Scala中,变量与类中的方法是同等级的，可以直接赋值给方法。

scala中的get与set与Java中的get，set有很大的差异：

在Scala中，如果程序中给变量或方法前面定义了private，那么scala会给这个变量或方法自动生成private的get和set方

法，如果程序中没有给变量或方法前面定义了private，那么scala会给这个变量或方法自动生成public的get和set方法。

创建类的对象

val scal = new Hiscala
scal.sayName()
scal.sayName//如果不传参时，等同上面
scal.getName

var name="Spark" //如果不加private,默认会生成一个public的get和set方法，外部可以调

private[this] 对类对象较深层次的访问控制

类的构造器

注意：所有重载的构造器，都必须首先调用默认的构造器，或者说调用其它重载的构造器

类的构造器：重载

def this(name:String){
this() //调用默认的构造器
this.name=name
}

def this(name:String,age:Int){
this(name) //调用其它重载的构造器
this.age=age
}

伴生对象 object：

scala程序中，定义完类之后，一般会定义一个同名的object，它用于存放静态的成员或者方法，当我们第一次调

用这个伴生对象时，它会执行object的构造方法，只是这个构造方法是不接受参数的，而且这个构造方法只会调用一次，以后不会

在调用。

定义：

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

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

scala不支持多重继成

trait：工具方法的一个容器

val array = Array(1,2,3)//调用Array的伴生对象

//问题 半生对象和apply方法
半生对象的apply方法：它就是当前类的对象的工厂方法，它可以控制对象的生成。
伴生对象 object：
scala程序中，定义完类之后，一般会定义一个同名的object，它用于存放静态的成员或者方法，当我们第一次调
用这个伴生对象时，它会执行object的构造方法，只是这个构造方法是不接受参数的，而且这个构造方法只会调用一次，以后不会

抽象类
abstract class Person{}

覆写 override

继承
abstract class RDD () extends Serializable with Logging

通用的功能放到trait(类似于工具类)里面

private[spark] var name="spark"//只有spark包下面的才能访问，如：org.spark

scala类的定义
class HiScala{//默认是public级别的
private var name="Spark"//成员变量
def sayName(){
println(name)
}
def getName = name
}
val scala = new HiScala()
scala.sayName()//没有参数可以省略()scala.sayName
scala.getName

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

class Person {
private var myName = "Flink"
def name = this.myName
def update(newName : String){
myName = newName
println("Hi" + myName)
}
}
//rocky.name报错了
rocky.update("Hadoop")

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)
}
}
val p1 = new Person
val p2 = new Person
p2.update("Spark")
p1.talk(p2)

class Person {
private[this] var name = "Flink" //本对象独有，另外一个Person对象也访问不到
def update(newName : String){
println("Hi:")
}
def talk(p:Person) = {
println("Hello!" + p.name)//这里会报错
}
}
//构造函数
class Person(config : SparkConf) extends Logging//与类名并行的是默认构造器

class Person{
var name = ""
var age = 0
def update(newName : String){
println("Hi:")
}
def this(name : String){
this()
this.name = name
}
def this(name : String,age : Int){
this()
this.name = name
this.age = age
}
}
//伴生对象
class Person{
var name = ""
var age = 0
def update(newName : String){
println("Hi:")
}
def this(name : String){
this()
this.name = name
}
def this(name : String,age : Int){
this()
this.name = name
this.age = age
}
}

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

val array = Array(1,2,3)//调用Array的伴生对象

第二部分作业

RDD类源码解析：

class RDD它是个抽象类

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

private[spark] def conf = sc.conf

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

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

/**
* Get the array of partitions of this RDD, taking into account whether the
* RDD is checkpointed or not.
*/
final def partitions: Array[Partition] = {
checkpointRDD.map(_.partitions).getOrElse {
if (partitions_ == null) {
partitions_ = getPartitions
}
partitions_
}
}

final def getNumPartitions: Int = partitions.length

RDD是一个弹性的分布式数据集。
呈现了一个不可变的大量元素的分区集合，这些数据能够并行操作
此类包含了一些在所有RDDS的基本操作，如map 、filter、persist
RDD是一个分区集
RDD是一个计算每个分区的函数
RDD是一个依赖其他RDD的集合
RDD是一个计算每个分区首选位置的集合

SparkContext源码解析

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

创建sarpkContext唯一需要的参数就是sparkConf。它是一组K-V属性对

class SparkContext(config: SparkConf)

　　 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))

/**
* Alternative constructor that allows setting common Spark properties directly
*
* @param master Cluster URL to connect to (e.g. mesos://host:port, spark://host:port, local[4]).
* @param appName A name for your application, to display on the cluster web UI.
* @param sparkHome Location where Spark is installed on cluster nodes.
* @param jars Collection of JARs to send to the cluster. These can be paths on the local file
*             system or HDFS, HTTP, HTTPS, or FTP URLs.
* @param environment Environment variables to set on worker nodes.
*/
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))
this.preferredNodeLocationData = preferredNodeLocationData
}

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，没有结果返回。

该类是spark功能的一个主要入口，呈现了对于spark集群的连接，
通常用来创建RDDs，广播集群中变量的变化。
控制着spark的创建和停止。
设置日志的输出级别
线程池的控制
添加jar包
与Hadoop的交互