大数据系列 : Scala之旅(四) 面向对象

Scala单例对象

在Scala中 , 没有static关键字 , 但是它也提供了单例模式的实现方法。就是使用关键字object , object对象不能带参数。

object ScalaTest1 {
  def main(args: Array[String]): Unit = {
    ScalaSingleton.saySomething("hello kitty")
    println(ScalaSingleton)
  }
}


object ScalaSingleton {
  def saySomething(msg: String) = {
    println(msg)
  }
}

Scala中的类

object ScalaTest2 {
  val name: String = "laoli"

  def main(args: Array[String]): Unit = {
    val student = new Student()
    student.name = "laozhang"
    println(s"student name ===${student.name}")
    println("Test.name====" + ScalaTest2.name)

    var s2 = new Student2("laohuang", 68)
    println(s"${s2.name} , ${s2.age} , ${s2.gender}")
    var s3 = new Student2("laoma", 89, "male")
    println(s"${s3.gender}")
  }
}

/**
  * 在Scala中 , 类并不用声明为public
  * 如果没有定义构造函数 , 默认会有一个空参构造
  *
  * var 修饰的变量 , 这个变量对外提供getter , setter方法
  * val 修饰的变量 , 对外提供getter方法 , 不提供setter方法
  */
class Student {
  //_表示占位符 , 编译器会根据变量的具体类型赋予相应的初始值
  //使用占位符 , 变量类型必须指定
  //val修饰的常量不能使用占位符
  var name: String = _
  var age: Int = 10
}

/**
  * 定义在类后面的为类的主构造器 , 一个类可以有多个辅助构造器
  */
class Student2(val name: String, var age: Int) {
  var gender: String = _

  def this(name: String, age: Int, gender: String) {
    this(name, age)
    this.gender = gender
  }
}

访问权限

object ScalaTest3 {

  def main(args: Array[String]): Unit = {
    var s2 = new Student2("laozhang", 55, "male")
    println(s"${s2.name} ${s2.age} ${s2.gender}")
  }

  /**
    * private 加在主构造器前面标识这个主构造器是私有的 , 外部不能访问这个构造器
    */
  class Student2 private(val name: String, var age: Int) {
    var gender: String = _

    //辅助构造器中 , 必须先调用类的主构造器
    def this(name: String, age: Int, gender: String) {
      this(name, age)
      this.gender = gender
    }
  }

}

成员权限 , 类访问权限

object ScalaTest4 {

  def main(args: Array[String]): Unit = {
    var s = new Student("laozhang", 55, "male")
    println(s"${s.gender}")
  }

  /**
    * private[包名]class 放在类声明最前面 , 是修饰类的访问权限
    * private[sheep]class 代表类在sheep包及其子包下可见 , 其它包不可见
    */
  private[this] class Student private(val name: String, private var age: Int) {
    var gender: String = _

    def this(name: String, age: Int, gender: String) {
      this(name, age)
      this.gender = gender
    }

    //private[this]关键字标识该属性只能在类的内部访问
    private[this] val province: String = "北京"

    def getAge = 18
  }

}

伴生类/apply方法

在Scala中 , 当单例对象和某个类共享同一个名称时 , 它被称作是这个类的伴生对象 , 必须在同一个源文件里定义类和它的伴生对象 , 类被称为是这个单例对象的伴生类 , 类和它的伴生对象可以互相访问其私有成员。

object ScalaTest5 {
  def main(args: Array[String]): Unit = {
    val anim=Cat()
    println(anim.gender)
  }

  object Cat{
    def apply(): Animal = new Animal(100,"Cat","male")
  }

  class Animal(var height: Int, var tp: String) {
    var gender: String = _

    def this(height: Int, tp: String, gender: String){
      this (height, tp)
      this.gender = gender
    }
  }
}

特质

Scala Trait(特质)相当于Java的接口 , 实际上它比接口的功能要强大

与接口不同的是 , 它可以定义属性和方法的实现

一般情况下Scala的类只能集成单一父类 , 但是如果是Trait(特质)的话 , 可以集成多个 , 实现了多重继承。

object ScalaTest6 {
  def main(args: Array[String]): Unit = {
    var t:T2=new Clzz()
    t.teacherSay("laozhang")
    t.doSomething()
  }

  class Clzz extends T2{
    override def teacherSay(name: String): Unit = {
      println(s"${name} : 自由活动")
    }
  }

  trait T2 {
    val className: String = "后进班"

    def teacherSay(name: String)

    def doSomething():Unit = {
      println("先吃饭 , 再睡觉")
    }
  }
}

抽象类

在Scala中 , 使用abstract修饰的类称为抽象类。在抽象类中可以定义属性、未实现的方法和具体实现的方法。

object ScalaTest7 {
  def main(args: Array[String]): Unit = {
    
  }

  abstract class Animal {
    println("Animal's constructor ...")

    val name: String = "animal"

    def sleep()

    def eat(f: String) = {
      println(s"$f")
    }
  }

}

type关键字

Scala里的类型 , 除了在定义class , trait , object时会产生类型 , 还可以通过type关键字来声明类型。

type相当于声明一个类型别名 :

object ScalaTest8 {
  type S=String
  
  def main(args: Array[String]): Unit = {
    var name:S="小星星"
    println(name)
  }
}

样例类/样例对象

object ScalaTest9 {

  case class Message(msgConent: String)

  case object CheckHeartBeat

  object TestCaseClass extends App{
    val msg=Message("hello")
    println(msg.msgConent)
  }

  def main(args: Array[String]): Unit = {

  }
}

模式匹配 match case

匹配字符串/类型/守卫

object ScalaTest10 {

  val arr = Array("laohuang", "laozhang", "laoliu")

  def main(args: Array[String]): Unit = {
    val i = Random.nextInt(arr.length)
    println(i)
    val name = arr(i)
    println(name)

    name match {
      case "laohuang" => println("黄老师")
      case "laozhang" => println("张老师")
      case _ => println("what the fuck")
    }

    val arr2: Array[Any] = Array("hello123", 1, 2.0, ScalaTest10, 2L)
    val elem = arr2(2)
    elem match {
      case x: Int => println("Int" + x)
      case y: Double if y >= 0 => println("Double" + y)
      case _ => println("what the fuck")
    }
  }
}

匹配数组

object ScalaTest11 {
  def main(args: Array[String]): Unit = {
    val arr = Array(1, 1, 7, 0, 2, 3)
    arr match {
      case Array(0, 2, x, y) => println(x + " " + y)
      case Array(2, 1, 7, y) => println("only 0 " + y)
      case Array(1, 1, 7, 0, x, y) => println(x + " " + y)
      case _ => println("something else")
    }
  }
}

匹配集合

object ScalaTest12 {
  def main(args: Array[String]): Unit = {
    val lst = List(0, 3, 4)
    println(lst.head)
    println(lst.tail)

    lst match {
      case 0 :: Nil => println("only 0")
      case x :: y :: Nil => println(s"x $x y $y")
      case 0 :: a => println(s"value : $a")
      case _ => println("something else")
    }
  }
}

匹配样例类/样例对象

object ScalaTest14 {

  /**
    * 样例类 , 模式匹配 , 封装数据(多例) , 不用new即可创建实例
    */
  case class SubmitTask(id: String, name: String)

  case class HeartBeat(time: Long)

  /**
    * 样例对象
    */
  case object CheckTimeOutTask

  var arr = Array(CheckTimeOutTask, new HeartBeat(123), HeartBeat(888), SubmitTask("0001", "task-0001"))

  def main(args: Array[String]): Unit = {
    val i = Random.nextInt(arr.length)
    val ele = arr(i)
    println(ele)
    ele match{
      case sub:SubmitTask=>println(s"${sub.id},${sub.name}")
      case heartBeat: HeartBeat=>println(heartBeat.time)
      case CheckTimeOutTask=>println("check")
    }

  }
}

大数据系列 : Scala之旅(四) 面向对象

猜你喜欢