全面深度剖析spark2课件面向对象

1、Lazy在Scala里面提供了lazy的特性，如果将一个变量设置为lazy，这个变量只有在第一次使用的时候才会发生计算。类、对象、继承、特质Scala的类与Java、C+的类比起来更简洁，学完之后你会更爱Scala！类类的定义/在Scala中，类并不用声明为public。/Scala源文件中可以包含多个类，所有这些类都具有公有可见性。class Student /用val修饰的变量是只读属性，有getter但没有setter /（相当与Java中用final修饰的变量） val id = 666 /用var修饰的变量既有getter又有setter var age: Int = 20 /类私有

2、字段,只能在类的内部使用 private var name: String = tom /对象私有字段,访问权限更加严格的，Person类的方法只能访问到当前对象的字段 privatethis val pet = 小强构造器注意：主构造器会执行类定义中的所有语句/* *每个类都有主构造器，主构造器的参数直接放置类名后面，与类交织在一起 */class Person(val name: String, val age: Int) /主构造器会执行类定义中的所有语句 println(执行主构造器) try println(读取文件) throw new IOException(io excepti

3、on) catch case e: NullPointerException = println(打印异常Exception : + e) case e: IOException = println(打印异常Exception : + e) finally println(执行finally部分) private var gender = male /用this关键字定义辅助构造器 def this(name: String, age: Int, gender: String) /每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始 this(name, age) println(执行辅助

4、构造器) this.gender = gender /在类名后面加private就变成了私有的class People private(val name: String, private var age: Int = 18) object People def main(args: ArrayString) /私有的构造器，只有在其伴生对象中使用 val q = new People(hatano, 20) 对象单例对象在Scala中没有静态方法和静态字段，但是可以使用object这个语法结构来达到同样的目的存放工具方法和常量高效共享单个不可变的实例=单例模式import scala.coll

5、ection.mutable.ArrayBufferobject SingletonDemo def main(args: ArrayString) /单例对象，不需要new，用【类名.方法】调用对象中的方法 val session = SessionFactory.getSession() println(session) object SessionFactory /该部分相当于java中的静态块 var counts = 5 val sessions = new ArrayBufferSession() while(counts 0) sessions += new Session co

6、unts -= 1 /在object中的方法相当于java中的静态方法 def getSession(): Session = sessions.remove(0) class Session总结：object里面的方法都是静态方法Object里面的字段都是静态字段它本身就是一个单例，(因为不需要去new)伴生对象在同一个文件中，在Scala的类中，与类名相同的对象叫做伴生对象，类和伴生对象之间可以相互访问私有的方法和属性class Dog val id = 1 private var name = xiaoqing def printName(): Unit = /在Dog类中可以访问伴生对

7、象Dog的私有属性 println(Dog.CONSTANT + name ) /* * 伴生对象 */object Dog /伴生对象中的私有属性 private val CONSTANT = 汪汪汪 : def main(args: ArrayString) val p = new Dog /访问私有的字段name = 123 p.printName() 总结：伴生对象和伴生类可以互相访问私有属性和私有方法。apply方法通常我们会在类的伴生对象中定义apply方法，当遇到类名(参数1,.参数n)时apply方法会被调用object ApplyDemo def main(ar

8、gs: ArrayString) /调用了Array伴生对象的apply方法 /def apply(x: Int, xs: Int*): ArrayInt /arr1中只有一个元素5 val arr1 = Array(5) println(arr1.toBuffer) /new了一个长度为5的array，数组里面包含5个null var arr2 = new Array(5) 应用程序对象Scala程序都必须从一个对象的main方法开始，可以通过扩展App特质，不写main方法。object AppObjectDemo extends App /不用写main方法 println(I love

9、 you Scala)继承/* * / Scala中，让子类继承父类，与Java一样，也是使用extends关键字/ 继承就代表，子类可以从父类继承父类的field和method；然后子类可以在自己内部放入父类所没有，子类特有的field和method；使用继承可以有效复用代码/ 子类可以覆盖父类的field和method；但是如果父类用final修饰，field和method用final修饰，则该类是无法被继承的，field和method是无法被覆盖的Java不支持多继承 为什么？ 子类不能继承父类的private属性(事实1)，但可以通过继承的方法(比如，public方法)访问到父类的pr

10、ivate属性。 */class Person private var name = leo def getName = nameclass Student extends Person private var score = A def getScore = scoreobject Test def main(args: ArrayString) val s=new Student(); println(s.getName) 7.2 override和super/*/ Scala中，如果子类要覆盖一个父类中的非抽象方法，则必须使用override关键字/ override关键字可以帮助我们尽

11、早地发现代码里的错误，比如：override修饰的父类方法的方法名我们拼写错了；比如要覆盖的父类方法的参数我们写错了；等等/ 此外，在子类覆盖父类方法之后，如果我们在子类中就是要调用父类的被覆盖的方法呢？那就可以使用super关键字，显式地指定要调用父类的方法 */class Person private var name = leo def getName = nameclass Student extends Person private var score = A def getScore = score override def getName = Hi, Im + super.get

12、Nameobject Test def main(args: ArrayString) val s=new Student(); println(s.getName) 抽象类/ 如果在父类中，有某些方法无法立即实现，而需要依赖不同的子来来覆盖，重写实现自己不同的方法实现。此时可以将父类中的这些方法不给出具体的实现，只有方法签名，这种方法就是抽象方法。/ 而一个类中如果有一个抽象方法，那么类就必须用abstract来声明为抽象类，此时抽象类是不可以实例化的/ 在子类中覆盖抽象类的抽象方法时，不需要使用override关键字abstract class Person(val name: Strin

13、g) def sayHello: Unitclass Student(name: String) extends Person(name) def sayHello: Unit = println(Hello, + name)扩展类在Scala中扩展类的方式和Java一样都是使用extends关键字重写方法在Scala中重写一个非抽象的方法必须使用override修饰符特质特质(有接口的特性)/特质里面的方法既可以实现，也可以不实现，那么跟抽象类有什么区别/抽象类，我们用的是extends，我们只能单继承，但是我们可以多实现。/实现特质，如果没有继承其它类，那么使用第一个特质使用extends

14、后面的使用with 。所以如果有考题说实现特质只能使用with，这是不对的。1 将特质作为接口使用/* * / Scala中的Triat是一种特殊的概念/ 首先我们可以将Trait作为接口来使用，此时的Triat就与Java中的接口非常类似/ 在triat中可以定义抽象方法，就与抽象类中的抽象方法一样，只要不给出方法的具体实现即可/ 类可以使用extends关键字继承trait，注意，这里不是implement，而是extends，在scala中没有implement的概念，无论继承类还是trait，统一都是extends/ 类继承trait后，必须实现其中的抽象方法，实现时不需要使用over

15、ride关键字/ scala不支持对类进行多继承，但是支持多重继承trait，使用with关键字即可 */trait HelloTrait def sayHello(name:String)trait MakeFriendsTrait def makeFriends(w:Worker)class Worker(var name:String) extends HelloTrait with MakeFriendsTrait def sayHello(name:String) = println(hello ,+name) def makeFriends(w:Worker)=println(he

16、llo, my name is+name+ you name is+)object Test def main(args: ArrayString) val p1=new Worker(xiaoma); val p2=new Worker(linghuchong) p1.sayHello(lihuchong) p1.makeFriends(p2) 2 在trait中定义具体方法/* / Scala中的Triat可以不是只定义抽象方法，还可以定义具体方法，此时trait更像是包含了通用工具方法的东西/ 有一个专有的名词来形容这种情况，就是说trait的功能混入了类/ 举例来说，tra

17、it中可以包含一些很多类都通用的功能方法，比如打印日志等等，spark中就使用了trait来定义了通用的日志打印方法 */trait Logger def log(message:String) = println(message)class Person(val name:String) extends Logger def makeFridends(p:Person): Unit = println(Im+name+ im glade to make friends with you+); log(makeFridends method invoked!) object Tes

18、t def main(args: ArrayString) val p1=new Person(linpingzhi) val p2=new Person(yuelingshan); p1.makeFridends(p2) 在trait中定义具体字段/* * / Scala中的Triat可以定义具体field，此时继承trait的类就自动获得了trait中定义的field/ 但是这种获取field的方式与继承class是不同的：如果是继承class获取的field，实际是定义在父类中的； 而继承trait获取的field，就直接被添加到了类中 */trait Person val eyeNum

19、:Int=2class Student(val name:String) extends Person def sayHello()=println(Hi,Im +name +I have +eyeNum+eyes ! )object Test def main(args: ArrayString) val s=new Student(zhangsanfeng) s.sayHello(); 在trait中定义抽象字段/* * / Scala中的Triat可以定义抽象field，而trait中的具体方法则可以基于抽象field来编写/ 但是继承trait的类，则必须覆盖抽象field，提供具体的

20、值 */trait sayHello val msg:String def sayHello(name:String)=println(msg + , +name)class Person(val name:String) extends sayHello val msg:String = hello def makeFriends(p:Person): Unit = sayHello() println(Im+name + I want to make frieds with you) object Test def main(args: ArrayString) val p1=

21、new Person(zhangwuji) val p2=new Person(zhangsanfeng) p1.makeFriends(p2) 为实例对象混入trait/* * / 有时我们可以在创建类的对象时，指定该对象混入某个trait，这样，就只有这个对象混入该trait的方法，而类的其他对象则没有 */trait Logged def log(msg:String)trait AMyLogger extends Logged override def log(msg:String): Unit = println(test:+msg) trait BMyLogger extends

22、Logged override def log(msg:String): Unit = println(log:+msg) class Person(val name:String) extends AMyLogger def sayHello(): Unit = println(Hi ,im name) log(sayHello is invoked!) object Test def main(args: ArrayString) val p1=new Person(liudehua) p1.sayHello() val p2=new Person(zhangxueyou) with BM

23、yLogger p2.sayHello() trait调用链/* * / Scala中支持让类继承多个trait后，依次调用多个trait中的同一个方法，只要让多个trait的同一个方法中，在最后都执行super.方法 即可/ 类中调用多个trait中都有的这个方法时，首先会从最右边的trait的方法开始执行，然后依次往左执行，形成一个调用链条/ 这种特性非常强大，其实就相当于设计模式中的责任链模式的一种具体实现依赖 */trait Handler def handler(data:String)trait DataValidHandler extends Handler override d

24、ef handler(data:String): Unit = println(check data:+data) super.handler(data) trait SignatureValidHandler extends Handler override def handler(data:String): Unit = println(check signatrue:+data) super.handler(data) class Person(val name:String) extends SignatureValidHandler with DataValidHandler def

25、 sayHello= println(Hello +name) handler(name) object Test def main(args: ArrayString) val p=new Person(lixiaolong); p.sayHello 模式匹配和样例类Scala有一个十分强大的模式匹配机制，可以应用到很多场合：如switch语句、类型检查等。并且Scala还提供了样例类，对模式匹配进行了优化，可以快速进行匹配匹配字符串import scala.util.Randomobject CaseDemo01 extends App val arr = Array(Hadoop, HB

26、ase, Spark) val name = arr(Random.nextInt(arr.length) name match case Hadoop = println(哈肚普.) case HBase = println(H贝斯.) case _ = println(真不知道你们在说什么.) 匹配类型import scala.util.Randomobject CaseDemo01 extends App /val v = if(x = 5) 1 else if(x println(Int + x) case y: Double if(y = 0) = println(Double +

27、y) case z: String = println(String + z) case _ = throw new Exception(not match exception) 注意：case y: Double if(y = 0) = .模式匹配的时候还可以添加守卫条件。如不符合守卫条件，将掉入case _中匹配数组、元组object CaseDemo03 extends App val arr = Array(1, 3, 5) arr match case Array(1, x, y) = println(x + + y) case Array(0) = println(only 0)

28、case Array(0, _*) = println(0 .) case _ = println(something else) val lst = List(3, -1) lst match case 0 : Nil = println(only 0) case x : y : Nil = println(sx: $x y: $y) case 0 : tail = println(0 .) case _ = println(something else) val tup = (2, 3, 5) tup match case (2, x, y) = println(s1, $x , $y) case (_, z, 5) = println(z) case _ = println(else) 注意：在Scala中列表要么为空（Nil表示空列表）要么是一个head元素加上一个tail列表。9 : List(5, 2) : 操作符是将给定的头和尾创建一个新的列表注意：: 操作符是右结合的，如9 : 5 : 2 : Nil相当于 9 : (5 : (2 : Nil)样例类在Scala中样例类是一中特殊的类，可用于模式匹配。case class是多例的，后面要跟构造参数，case object是单例的import scala.util.Randomcase class Submit