Scala学习之路 (六)Scala的类、对象、继承、特质
一、类
1、类的定义
scala语言中没有static成员存在,但是scala允许以某种方式去使用static成员
这个就是伴生机制,所谓伴生,就是在语言层面上,把static成员和非static成员用不同的表达方式,class和object,
但双方具有相同的package和name,但是最终编译器会把他们编译到一起,这是纯粹从语法层面上的约定。通过javap可以反编译看到。
另外一个小魔法就是单例,单例本质上是通过伴生机制完成的,直接由编译器生成一个class对象,这样至少在底层能够统一。
//在Scala中,类并不用声明为public。 //Scala源文件中可以包含多个类,所有这些类都具有公有可见性。 class ClassDemo { //用val修饰的变量是只读属性,有getter但没有setter //(相当与Java中用final修饰的变量) val id = 666 //用var修饰的变量既有getter又有setter var name = "huangbo" //类私有字段,只能在类的内部使用 var age = 24 //对象私有字段,访问权限更加严格的,ClassDemo类的方法只能访问到当前对象的字段 private[this] val address = "三里屯" }
2、构造器
注意:主构造器会执行类定义中的所有语句
/** *每个类都有主构造器,主构造器的参数直接放置类名后面,与类交织在一起 */ class Person(val name:String,val age:Int) { //主构造器会执行类定义中的所有语句 println("Hello Spark") val x = 1 if(x > 1){ println("666") }else if(x < 1){ println("哈哈。。。") }else{ println("呵呵。。。") } private var address = "BJ" //用this关键字定义辅助构造器 def this(name:String,age:Int,address:String){ //每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始 this(name,age) println("执行辅助构造器") this.address = address } } object Person{ def main(args: Array[String]): Unit = { val p = new Person("dengchao",33,"SH") } }
总结:
主构造方法:
1)与类名交织在一起
2)主构造方法运行,导致类名后面的大括号里面的代码都会运行
辅助构造方法:
1)必须名字叫this
2) 必须以调用主构造方法或者是其他辅助构造方法开始。
3)里面的属性不能写修饰符
对象
单例对象
在Scala中没有静态方法和静态字段,但是可以使用object这个语法结构来达到同样的目的
1.存放工具方法和常量
2.高效共享单个不可变的实例=单例模式
import scala.collection.mutable.ArrayBuffer object SingletonDemo { def main(args: Array[String]): Unit = { val session = SessionFactory.getSession() println(session) } } class Session{} object SessionFactory{ //该部分相当于java中的静态块 var counts = 5 val sessions = new ArrayBuffer[Session]() while (counts > 0){ sessions += new Session counts -= 1 } //在object中的方法相当于java中的静态方法 def getSession(): Session ={ sessions.remove(0) } }
总结:
1)object里面的方法都是静态方法
2)Object里面的字段都是静态字段
3)它本身就是一个单例,(因为不需要去new)
伴生对象
在同一个文件中,在Scala的类中,与类名相同的对象叫做伴生对象,类和伴生对象之间可以相互访问私有的方法和属性
class Dog { val id = 666 private var name = "道哥" def printName(): Unit ={ //在Dog类中可以访问伴生对象Dog的私有属性 println(Dog.CONSTANT + name) } } /** * 伴生对象 */ object Dog{ //伴生对象中的私有属性 private var CONSTANT = "汪汪汪。。。" //主方法 def main(args: Array[String]): Unit = { val dog = new Dog //访问私有的字段name dog.name = "道哥666" dog.printName() } }
总结:
伴生对象和伴生类可以互相访问私有属性和私有方法。
apply方法
通常我们会在类的伴生对象中定义apply方法,当遇到类名(参数1,...参数n)时apply方法会被调用
object ApplyDemo { def main(args: Array[String]): Unit = { //调用Array伴生对象的apply方法 val array = Array(1,2,3,4,5) println(array.toBuffer) //new了一个长度为9的数组,数组里面包含了9个null var arr = new Array(9) println(arr) } }
继承
Scala中,让子类继承父类,与Java一样,也是使用extends关键字
继承就代表,子类可以从父类继承父类的field和method;然后子类可以在自己内部放入父类所没有,子类特有的field和method;使用继承可以有效复用代码
子类可以覆盖父类的field和method;但是如果父类用final修饰,field和method用final修饰,则该类是无法被继承的,field和method是无法被覆盖的
class People { private var name = "始皇帝" def getName = name } class Student extends People{ private var score = 59 def getScore = score } object Test{ def main(args: Array[String]): Unit = { val student = new Student println(student.getName) } }
Scala中,如果子类要覆盖一个父类中的非抽象方法,则必须使用override关键字
override关键字可以帮助我们尽早地发现代码里的错误,比如:override修饰的父类方法的方法名我们拼写错了;比如要覆盖的父类方法的参数我们写错了;等等
此外,在子类覆盖父类方法之后,如果我们在子类中就是要调用父类的被覆盖的方法呢?那就可以使用super关键字,显式地指定要调用父类的方法
class People { private var name = "始皇帝" def getName = name } class Student extends People{ private var score = 59 def getScore = score override def getName: String = super.getName + ":嬴政" } object Test{ def main(args: Array[String]): Unit = { val student = new Student println(student.getName) } }
抽象类
如果在父类中,有某些方法无法立即实现,而需要依赖不同的子来来覆盖,重写实现自己不同的方法实现。此时可以将父类中的这些方法不给出具体的实现,只有方法签名,这种方法就是抽象方法。
而一个类中如果有一个抽象方法,那么类就必须用abstract来声明为抽象类,此时抽象类是不可以实例化的
在子类中覆盖抽象类的抽象方法时,不需要使用override关键字
abstract class AbstractDemo(name:String) { def sayHello:Unit } class StudentDemo(name:String) extends AbstractDemo(name){ def sayHello: Unit = println("Hello " + name) } object StudentDemo{ def main(args: Array[String]): Unit = { val li = new StudentDemo("Li") li.sayHello } }
扩展类
在Scala中扩展类的方式和Java一样都是使用extends关键字
重写方法
在Scala中重写一个非抽象的方法必须使用override修饰符
特质(trait)
1、将特质作为接口使用
/** * // Scala中的Triat是一种特殊的概念 // 首先我们可以将Trait作为接口来使用,此时的Triat就与Java中的接口非常类似 // 在triat中可以定义抽象方法,就与抽象类中的抽象方法一样,只要不给出方法的具体实现即可 // 类可以使用extends关键字继承trait,注意,这里不是implement,而是extends,在scala中没有implement的概念,无论继承类还是trait,统一都是extends // 类继承trait后,必须实现其中的抽象方法,实现时不需要使用override关键字 // 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("hello, my name is"+name+" you name is"+w.name) } object Test{ def main(args: Array[String]) { val p1=new Worker("xiaoma"); val p2=new Worker("linghuchong") p1.sayHello("lihuchong") p1.makeFriends(p2) } }
2、在trait中定义具体方法
/** // Scala中的Triat可以不是只定义抽象方法,还可以定义具体方法,此时trait更像是包含了通用工具方法的东西 // 有一个专有的名词来形容这种情况,就是说trait的功能混入了类 // 举例来说,trait中可以包含一些很多类都通用的功能方法,比如打印日志等等,spark中就使用了trait来定义了通用的日志打印方法 */ trait Logger { def log(message:String) = println(message) } class Person(val name:String) extends Logger{ def makeFridends(p:Person): Unit ={ println("I'm"+name+" i'm glade to make friends with you"+p.name); log("makeFridends method invoked!!") } } object Test{ def main(args: Array[String]) { val p1=new Person("linpingzhi") val p2=new Person("yuelingshan"); p1.makeFridends(p2) } }
3、在trait中定义具体字段
/** * // Scala中的Triat可以定义具体field,此时继承trait的类就自动获得了trait中定义的field // 但是这种获取field的方式与继承class是不同的:如果是继承class获取的field,实际是定义在父类中的; 而继承trait获取的field,就直接被添加到了类中 */ trait Person { val eyeNum:Int=2 } class Student(val name:String) extends Person{ def sayHello()=println("Hi,I'm "+name +"I have "+eyeNum+"eyes !" ) } object Test{ def main(args: Array[String]) { val s=new Student("zhangsanfeng") s.sayHello(); } }
4、 在trait中定义抽象字段
/** * // Scala中的Triat可以定义抽象field,而trait中的具体方法则可以基于抽象field来编写 // 但是继承trait的类,则必须覆盖抽象field,提供具体的值 */ 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(p.name) println("I'm"+name +" I want to make frieds with you") } } object Test{ def main(args: Array[String]) { val p1=new Person("zhangwuji") val p2=new Person("zhangsanfeng") p1.makeFriends(p2) } }
5、为实例对象混入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 Logged{ override def log(msg:String): Unit ={ println("log:"+msg) } } class Person(val name:String) extends AMyLogger{ def sayHello(): Unit ={ println("Hi ,i'm name") log("sayHello is invoked!") } } object Test{ def main(args: Array[String]) { val p1=new Person("liudehua") p1.sayHello() val p2=new Person("zhangxueyou") with BMyLogger p2.sayHello() } }
6、trait调用链
/** * // Scala中支持让类继承多个trait后,依次调用多个trait中的同一个方法,只要让多个trait的同一个方法中,在最后都执行super.方法 即可 // 类中调用多个trait中都有的这个方法时,首先会从最右边的trait的方法开始执行,然后依次往左执行,形成一个调用链条 // 这种特性非常强大,其实就相当于设计模式中的责任链模式的一种具体实现依赖 */ trait Handler { def handler(data:String){} } trait DataValidHandler extends Handler{ override def 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 sayHello={ println("Hello "+name) handler(name) } } object Test{ def main(args: Array[String]) { val p=new Person("lixiaolong"); p.sayHello } }
模式匹配
Scala有一个十分强大的模式匹配机制,可以应用到很多场合:如switch语句、类型检查等。
并且Scala还提供了样例类,对模式匹配进行了优化,可以快速进行匹配
1、匹配字符串
import scala.util.Random object CaseDemo01 extends App{ val arr = Array("Hadoop", "HBase", "Spark") val name = arr(Random.nextInt(arr.length)) name match { case "Hadoop" => println("哈肚普...") case "HBase" => println("H贝斯...") case _ => println("真不知道你们在说什么...") } } }
2、匹配类型
import scala.util.Random object CaseDemo01 extends App{ //val v = if(x >= 5) 1 else if(x < 2) 2.0 else "hello" val arr = Array("hello", 1, 2.0, CaseDemo01) val v = arr(Random.nextInt(4)) println(v) v match { case x: Int => println("Int " + x) case y: Double if(y >= 0) => println("Double "+ y) case z: String => println("String " + z) case _ => throw new Exception("not match exception") } }
注意:case y: Doubleif(y >= 0) => ...
模式匹配的时候还可以添加守卫条件。如不符合守卫条件,将掉入case _中
3、匹配数组、元组、集合
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") 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(s"x: $x y: $y") case 0 :: tail => println("0 ...") case _ => println("something else") } val tup = (2, 3, 5) tup match { case (2, x, y) => println(s"1, $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))
4、样例类
在Scala中样例类是一中特殊的类,可用于模式匹配。case class是多例的,后面要跟构造参数,case object是单例的
import scala.util.Random case class SubmitTask(id: String, name: String) case class HeartBeat(time: Long) case object CheckTimeOutTask object CaseDemo04 extends App{ val arr = Array(CheckTimeOutTask, HeartBeat(12333), SubmitTask("0001", "task-0001")) arr(Random.nextInt(arr.length)) match { case SubmitTask(id, name) => { println(s"$id, $name") } case HeartBeat(time) => { println(time) } case CheckTimeOutTask => { println("check") } } }
总结
本质上来讲,class case class用起来就是一样的:
最不一样的一个东西:如果我们scala要做模式匹配,去匹配类型的话,建议使用case case 因为scala的底层对它做了优化,匹配起来性能较好。* 1:case class 自动生成伴生对象,自动实现了apply方法
* 2:case class 用于做匹配,性能较好(scala的底层做过优化)
* 3:case class 默认实现了序列化 Serializable
* 4: case class 默认实现了toString equals等方法
* 5:case class 主构造函数 里面没有修饰符,默认的是val
偏函数
被包在花括号内没有match的一组case语句是一个偏函数,它是PartialFunction[A, B]的一个实例,A代表参数类型,B代表返回类型,常用作输入模式匹配
object PartialFuncDemo { def func1: PartialFunction[String, Int] = { case "one" => 1 case "two" => 2 case _ => -1 } def func2(num: String) : Int = num match { case "one" => 1 case "two" => 2 case _ => -1 } def main(args: Array[String]) { println(func1("one")) println(func2("one")) } }
总结:
偏函数就是用来做模式匹配的。