深入掌握Scala面向对象编程与Spark源码解析

 

第二课&＃xff1a;Scala面向对象彻底精通及Spark源码阅读

 

 

 

一、 Scala中的类、object实战详解

Scala是纯面向对象语言。谈面向对象&＃xff0c;一定要谈类&＃xff0c;类把数据和代码封装起来。

 

类

跟Java一样&＃xff0c;Scala也是用关键字class来定义类。示例如下&＃xff1a;

 

scala> class HiScala{

     | private var name &＃61; "Spark"

     | def sayName(){println(name)}

     | def getName &＃61; name

     | }

defined class HiScala

 

以上代码&＃xff0c;定义了一个名称为HiScala的类&＃xff0c;默认情况下是public级别&＃xff0c;所以public关键字可以不写。

ü 定义了一个属性name&＃xff0c;为可变变量&＃xff0c;访问级别为private&＃xff0c;在类的外面不能被访问&＃xff01;

ü 定义一个函数&＃xff1a;sayName

ü 定义一个函数&＃xff1a;getName

在Scala中&＃xff0c;变量与类中的方法是同等级的&＃xff0c;可以直接相互赋值。

 

 

创建类实例

 

scala> val scal &＃61; new HiScala

scal: HiScala &＃61; HiScala&＃64;1c655221

//此时&＃xff0c;scal就是HiScala类的一个实例。但是&＃xff0c;在Scala中我们一边不会用new来创建类的实例&＃xff0c;而是用apply工厂方法模式来创建。

 

//调用scal的sayName方法&＃xff0c;用于打印出name成员的值。

scala> scal.sayName()

Spark

 

//由于sayName没有传参数&＃xff0c;所以可以把括号去掉&＃xff0c;这样更简洁。

scala> scal.sayName

Spark

 

//调用getName方法&＃xff0c;访问name成员的值

scala> scal.getName

res2: String &＃61; Spark

//此时确实返回了name的值。

 

//该示例中name是私有的&＃xff0c;所以不能直接访问scal实例的name&＃xff0c;如下访问就出错了。

scala> scal.name

:10: error: variable name in class HiScala cannot be accessed in HiScala

              scal.name

                   ^

get与set

Scala的get和set跟Java的get和set有很大的差异。

在Scala中&＃xff0c;如果给变量前定义了private&＃xff0c;那么Scala解释器会给这个变量自动生成private的get和set方 法&＃xff1b;

如果变量前没有定义了private&＃xff0c;那么解释器会给这个变量自动生成public的get和set方法&＃xff0c;这样就可以直接访问该类的实例对象的成员变量&＃xff0c;实际访问的是它的set和get方法。

 

//我们重新改造上面的类&＃xff0c;把属性name前面的private访问级别去掉。

scala> class HiScala{

     |        var name &＃61; "Spark"   //去掉了private关键字

     |        def sayName(){println(name)}

     |        def getName &＃61; name

     |        }

defined class HiScala

 

scala> val scal &＃61; new HiScala

scal: HiScala &＃61; HiScala&＃64;1e6d1014

 

//访问name属性, 值为Spark

scala> scal.name

res4: String &＃61; Spark

//此时虽然是访问属性name&＃xff0c;但其实不是直接访问var指定的变量name&＃xff0c;而是Scala解释器自动给name生成public级别的get和set方法。

 

//修改name属性

scala> scal.name&＃61;"Scala"

scal.name: String &＃61; Scala

 

//再次访问name属性, 值已经变为Scala

scala> scal.name

res5: String &＃61; Scala

 

 

自定义的get和set

scala> class Person {

     |     private var myName &＃61; "Flink"

     |     def name &＃61; this.myName        //自定义get方法

     |     def name_&＃61;(newName : String){  //自定义set方法&＃xff0c;注意下划线和等号之间没有空格&＃xff01;

     |         myName &＃61; newName

     |         println("Hi " &＃43; myName)        

     |     }

     | }

defined class Person

 

// luck为Person 类的实例

scala> val luck &＃61; new Person

luck: Person &＃61; Person&＃64;6a5fc7f7

 

//通过自定义的get方法&＃xff0c;访问到了myName属性

scala> luck.name

res0: String &＃61; Flink

 

//调用自定义的set方法&＃xff0c;修改了myName属性

scala> luck.name &＃61; "Spark"

Hi Spark

luck.name: String &＃61; Spark

 

//再次访问myName属性&＃xff0c;发现属性值已经变成Spark

scala> luck.name

res2: String &＃61; Spark

 

//修改上面的示例&＃xff0c;仅仅暴露属性的get方法&＃xff0c;没有为其复写set方法。但是提供一个名为update的方法用来修改该属性的值。

scala> class Person {

     |     private var myName &＃61; "Flink"

     |     def name &＃61; this.myName  //get方法

     |     def update(newName : String){

     |         myName &＃61; newName

     |         println("Hi " &＃43; myName)        

     |    }

     | }

defined class Person

 

// luck为Person 类的实例

scala>   val luck &＃61; new Person

luck: Person &＃61; Person&＃64;7c469c48

 

//通过自定义的get方法&＃xff0c;访问myName属性值&＃xff0c;初始值为Flink

scala> luck.name

res4: String &＃61; Flink

 

//想直接通过set方法来修改myName&＃xff0c;会提示出错&＃xff0c;因为没有复写set方法。

scala> luck.name&＃61;"Hadoop"

:9: error: value name_&＃61; is not a member of Person

       luck.name&＃61;"Hadoop"

            ^

 

//通过额外提供的update方法来修改属性

scala> luck.update("Hadoop")

Hi Hadoop

 

//再次查看myName属性值&＃xff0c;发现已经变成了Hadoop

scala> luck.name

res6: String &＃61; Hadoop

 

 

private[this]

private[this]至关重要的&＃xff0c;在Spark源码中随处可见。

代表属性或方法为对象私有&＃xff01;在类私有的基础上更强一层的控制。

 

//定义一个类:Person

scala> class Person {

     |     private var myName &＃61; "Flink"

     |     def name &＃61; this.myName  

     |     def update(newName : String){  

     |         myName &＃61; newName

     |         println("Hi " &＃43; myName)        

     |     }

     |     def talk(p:Person) &＃61; {

     |         println("hello:"&＃43;p.name)

     |     }  

     | }

defined class Person

 

//定义 p1为Person对象

scala> val p1&＃61;new Person

p1: Person &＃61; Person&＃64;14555e0a

//定义 p2为Person对象

scala> val p2&＃61;new Person

p2: Person &＃61; Person&＃64;1b2abca6

 

//把p1的myName 属性值改为p1

scala> p1.update("p1")

Hi p1

 

//把p2的myName 属性值改为p2

scala> p2.update("p2")

Hi p2

 

//查看p1的myName 属性值&＃xff0c;此时已经改为p1

scala> p1.name

res14: String &＃61; p1

 

//查看p2的myName 属性值&＃xff0c;此时已经改为p2

scala> p2.name

res15: String &＃61; p2

 

//调用p1的talk方法&＃xff0c;传入p2对象&＃xff0c;打印出p2的myName 属性值

scala> p1.talk(p2)

hello:p2

 

 

//我们修改一下代码&＃xff0c;看看下面代码&＃xff1a;

scala> class Person {

     |     private[this] var name &＃61; "Flink"

     |     def update(newName : String){  

     |         name &＃61; newName

     |         println("Hi " &＃43; name)        

     |     }

     |     def talk(p:Person) &＃61; {

     |         println("hello:"&＃43;p.name)

     |     }  

     | }

:15: error: value name is not a member of Person

               println("hello:"&＃43;p.name)

                                  ^

//此时&＃xff0c;在定义类时就报错&＃xff01;因为talk方法中p参数是Person类的对象&＃xff0c;而name属性被限制为private[this]&＃xff0c;所以只能在Person类内部使用&＃xff0c;Person类的对象无权使用。也就是说在Person类中&＃xff0c;update方法中可以使用name&＃xff0c;但是talk方法访问对象p的name是不允许的&＃xff01;

 

// private[this]改成private之后&＃xff0c;下面的写法就能正常定义&＃xff0c;代码如下&＃xff1a;

scala> class Person {

     |     private var name &＃61; "Flink"

     |     def update(newName : String){  

     |         name &＃61; newName

     |         println("Hi " &＃43; name)        

     |     }

     |     def talk(p:Person) &＃61; {

     |         println("hello:"&＃43;p.name)

     |     }  

     | }

defined class Person

scala>

 

构造器的重载

scala> class Person {

     |     private[this] var name &＃61; "Flink"

     |     private[this] var age &＃61; 10

     |     def update(newName : String){  

     |         name &＃61; newName

     |         println("Hi " &＃43; name)        

     |     }

     |  

     |         

     |     //重载的构造器&＃xff0c;首先调用默认的构造器

     |     def this(name:String){

     |       this()

     |       this.name&＃61;name

     |     }

     |     

     |     //重载的构造器&＃xff0c;调用上面已经存在的构造器

     |     def this(name:String, age:Int){

     |       this(name)

     |       this.age&＃61;age  

     |     }

     | }

defined class Person

 

 

在Spark源码中&＃xff0c;构造器重载非常常见&＃xff0c;如下图所示&＃xff1a;

 

&＃xff08;图一&＃xff09;

从图一的源代码中可以看出&＃xff0c;SparkContext类重写了有很多构造器&＃xff0c;在创建SparkContext实例对象时&＃xff0c;传递不同的参数来调用相应的构造器。

 

在Spark中&＃xff0c;与类名放在一起的构造器为默认构造器&＃xff0c;如下所示&＃xff1a;

 

&＃xff08;图二&＃xff09;

 

默认构造器可以带参数也可以不带参数&＃xff0c;在图二所示的源代码SparkContext类中&＃xff0c;默认构造器带有一个参数。初始化类成员的工作&＃xff0c;都放在默认构造器中完成。在SparkContext类中&＃xff0c;creationSite、allowMultipleContexts等变量&＃xff0c;就是在SparkContext类的默认构造器中完成。

 

object

 

定义一个类同名的object对象&＃xff0c;里面存放静态的成员或者方法&＃xff0c;把该object对象称之为该类的伴生对象。

查看SparkContext源码&＃xff0c;如下图三所示&＃xff1a;

 

&＃xff08;图三&＃xff09;

在图三中&＃xff0c;SparkContextobject为SparkContext类的伴生对象&＃xff0c;里面存放一系列静态的成员和静态的方法。而且&＃xff0c;当我们第一次调用SparkContext时&＃xff0c;SparkContext伴生对象会被执行一次&＃xff0c;仅此一次。

 

 

下面是一个示例&＃xff1a;

 

&＃xff08;图4&＃xff09;

上图中object Person是classPerson的伴生对象&＃xff0c;class Person称之为object Person的伴生类。伴生对象适合在里面定义一些工具方法&＃xff0c;以及存放一些全局唯一的常量&＃xff0c;节省空间。

 

 

//第一次调用&＃xff1a;Person伴生对象的getSalary方法

//此时&＃xff0c;我们发现&＃xff1a;Person伴生对象被初始化&＃xff0c;打印出字符串Scala。

scala> Person.getSalary

Scala

res34: Double &＃61; 0.0

 

//第二次调用&＃xff1a;Person伴生对象的getSalary方法

//此时&＃xff0c;我们发现&＃xff1a;Person伴生对象不再需要初始化&＃xff0c;没有打印出字符串Scala。

scala> Person.getSalary

res35: Double &＃61; 0.0

以上示例中确实验证了&＃xff1a;伴生对象会被执行一次&＃xff0c;仅此一次。

 

Scala中&＃xff0c;我们在定义类的对象时&＃xff0c;一般都不会用new类名&＃xff0c;再传入参数的方式来定义。而是直接用类名&＃xff0c;或者类名加参数的方式。例如&＃xff0c;我们重温下面的示例&＃xff1a;

我们构造一个数组&＃xff0c;其实是调用Array的伴生对象object Array的apply方法。

scala> val array&＃61;Array(1,2,3)

array: Array[Int] &＃61; Array(1, 2, 3)

 

scala> val array&＃61;Array.apply(1,2,3)

array: Array[Int] &＃61; Array(1, 2, 3)

以上两种定义数组的方式效果是一样的。apply方法就是当前类的伴生对象的工厂方法。延伸一下&＃xff0c;Java水平比较高才编程人员&＃xff0c;在构造Java对象时&＃xff0c;一般来说不会直接new一个类&＃xff0c;而是通过工厂方法模式来创建。而Scala语言中&＃xff0c;天生就支持这次模式&＃xff0c;所以在具体类对象构造时&＃xff0c;一般都是在伴生类的伴生对象的apply方法中去实现&＃xff01;这样可以控制对象的生成。

二、 Scala中的抽象类、接口实战详解

abstract

抽象类使用abstract关键字&＃xff0c;以Spark源码RDD类为示例&＃xff0c;如下图5所示&＃xff1a;

 

&＃xff08;图5&＃xff09;

子类去继承抽象类&＃xff0c;跟Java一样&＃xff0c;也是使用extends关键字。如JdbcRDD就继承了RDD抽象类&＃xff0c;如下&＃xff1a;

class JdbcRDD[T: ClassTag](

    sc: SparkContext,

    getConnection: () &＃61;> Connection,

    sql: String,

    lowerBound: Long,

    upperBound: Long,

    numPartitions: Int,

    mapRow: (ResultSet) &＃61;> T &＃61; JdbcRDD.resultSetToObjectArray _)

  extends RDD[T](sc, Nil) with Logging {

那么JdbcRDD就可以使用父类RDD所有它可以使用的属性和方法。

当然&＃xff0c;子类也可以覆盖父类的属性和方法。注意&＃xff0c;这里面有个前提&＃xff0c;父类的属性和方法没有加final。

 

一个抽象类&＃xff0c;那么里面肯定是定义了某个方法&＃xff0c;但是没有又实现体&＃xff0c;只有方法的说明。比如&＃xff1a;

 

&＃xff08;图六&＃xff09;

上图代码块中&＃xff0c;compute就是RDD抽象类的一个方法&＃xff0c;只有说明&＃xff0c;没有实现体。

 

override

在上面JdbcRDD子类中&＃xff0c;因为JdbcRDD继承了RDD抽象类&＃xff0c;那么在JdbcRDD中一定要复写compute方法。如下所示&＃xff1a;

 

使用override关键字表示复写父类的该方法。除了覆盖父类的方法&＃xff0c;也可以使用override来覆盖父类的val属性。父类在定义属性时没有给具体的值&＃xff0c;就是抽象属性&＃xff0c;在子类中&＃xff0c;子类必须覆盖该属性。

 

trait

相当于Java的接口。在trait定义的类中可以定义抽象方法&＃xff0c;但是又没有具体的实现。子类可以使用extends关键字来继承该父类。

 

以Spark源码中的RDD类为示例&＃xff0c;RDD继承了Serializable和Logging两个父类。一个子类如果继承多个父类&＃xff0c;那么继承的第一个父类前使用extends关键字&＃xff0c;后面的父类使用with关键字。RDD继承的这两个父类&＃xff0c;在定义时都使用trait关键字来定义。Scala语法中&＃xff0c;不允许一个子类同时继承多个抽象父类&＃xff0c;但是允许同时继承多个trait父类。

abstract class RDD[T: ClassTag](

    &＃64;transient private var _sc: SparkContext,

    &＃64;transient private var deps: Seq[Dependency[_]]

  ) extends Serializable with Logging {

 

 

下面是Serializable类的源码&＃xff1a;

 

 

trait的用途&＃xff0c;更多的是作为工具方法的容器。我们把通用的功能&＃xff0c;放在trait中。一个子类&＃xff0c;如果需要把很多通用的功能都混进来&＃xff0c;那么就需要继承多个trait父类&＃xff0c;继承的第一个父类使用extends&＃xff0c;后面的父类使用with。Spark源码Master类就是一个示例&＃xff0c;继承了多个父类。

 

 

三、 综合案例及Spark源码解析

 

阅读Spark源码中的SparkContext类&＃xff0c;熟悉第一课和本课的知识点。

DT大数据梦工厂