大數據學習——scala類相關操做

1 類的定義

package com

/**
  * Created by Administrator on 2019/6/3.
  */
//類並不用聲明爲public。
class Person {
  //用val修飾的變量是隻讀屬性，有getter但沒有setter
  //（至關與Java中用final修飾的變量）
  val id = "9527"
  //用var修飾的變量既有getter又有setter
  var age = 18
  //類私有字段,只能在類的內部使用
  private var name = "唐伯虎"
  //對象私有字段,訪問權限更加嚴格的，Person類的方法只能訪問到當前對象的字段

  private[this] val pet = "小強"

  
}

 

2構造器

package com


/**
  * Created by Administrator on 2019/6/4.
  */
//跟類名交織在一塊兒的叫主構造器
class Student(val name: String, var age: Int, faceValue: Double = 99.99, private var height: Int = 18) {

  private[this] var gender: String = null

  def show(): Unit = {
    //faceValue = 1000
    println(faceValue)
  }

  //輔助構造器  def this （參數）
  def this(name: String, age: Int, gender: String) {
    //輔助構造器第一行必定要先調用主構造器
    this(name, age)
    this.gender = gender
  }

}

object Student {

  def main(args: Array[String]) {
    val p = new Student("zx", 30, 100, 180)
    println(p.age)
    println(p.name)
    p.age = 18

    p.height = 199

    println(p.age)

    println(p.height)

    //val per = new Person
    //println(per)
  }
}

object Main {
  def main(args: Array[String]) {
    val s = new Student("zx", 30, 100)
    //s.height
  }
}

 

3 單例對象

在Scala中沒有靜態方法和靜態字段，可是可使用object這個語法結構來達到一樣的目的

1.存放工具方法和常量

2.高效共享單個不可變的實例

3.單例模式

package com

import scala.collection.mutable.ArrayBuffer

/**
  * Created by Administrator on 2019/6/4.
  */
object SingletonDemo {
  def main(args: Array[String]) {
    //單例對象不須要new，用 類名.方法 調用對象中的方法
    val session = SessionFactory.getSession()
    println(session)
  }


}

object SessionFactory {

  //該部分至關於java的靜態塊
  var counts = 5
  val sessions = new ArrayBuffer[Session]()
  while (counts > 0) {
    sessions += new Session
  }

  //在object中的方法至關於java的靜態方法
  def getSession(): Session = {
    sessions.remove(0)
  }
}

class Session {

}

 

4 伴生對象

在Scala的類中，與類名相同的對象叫作伴生對象，類和伴生對象之間能夠相互訪問私有的方法和屬性

package com

/**
  * Created by Administrator on 2019/6/4.
  */
class Dog {
  val id = 1
  private var name = "itcast"

  def printName(): Unit = {
    //在Dog類中能夠訪問伴生對象Dog的私有屬性
    println(Dog.CONSTANT)
  }
}

//伴生對象
object Dog {
  //伴生對象中的私有屬性
  private val CONSTANT = "汪汪汪汪汪汪："

  def main(args: Array[String]) {
    val p = new Dog
    //訪問私有的字段name
    p.name = "123"
    println(p.name)
    p.printName()
  }
}

 

5 apply方法

一般咱們會在類的伴生對象中定義apply方法，當遇到類名(參數1,...參數n)時apply方法會被調用

package com

/**
  * Created by Administrator on 2019/6/4.
  */
object ApplyDemo {
  def main(args: Array[String]) {
    //調用了Array伴生對象的apply方法
    //def apply(x: Int, xs: Int*): Array[Int]
    //arr1中只有一個元素5

    val arr1 = Array(5)
    println(arr1.toBuffer)
    //new了一個長度爲5的array，數組裏麪包含5個null
    var arr2 = new Array(5)
  }
}

 

 

6 應用程序對象

 

 

package com

/**
  * Created by Administrator on 2019/6/4.
  */
object AppObjectDemo extends App {
  //不用寫main方法
  println("i love you scala")
}

 

7 繼承

擴展類

在Scala中擴展類的方式和Java同樣都是使用extends關鍵字

重寫方法

在Scala中重寫一個非抽象的方法必須使用override修飾符

類型檢查和轉換

Scala	Java
obj.isInstanceOf[C]	obj instanceof C
obj.asInstanceOf[C]	(C)obj
classOf[C]	C.class

超類的構造

package com

/**
  * Created by Administrator on 2019/6/4.
  */
object ClazzDemo {
  def main(args: Array[String]) {

  }
}

trait Flyable {
  def fly(): Unit = {
    println(" I Can Fly")
  }

  def fight(): String
}

abstract class Animal {

  def run(): Int

  val name: String
}

class Human extends Animal with Flyable {
  val name = "abc"
  val t1, t2, (a, b, c) = {
    println("ABC")
    (1, 2, 3)
  }
  println(a)
  println(t1._1)

  //在Scala中重寫一個非抽象方法必須用override修飾
  override def fight(): String = {
    "fight with 棒子"
  }

  //在子類中重寫超類的抽象方法時，不須要使用override關鍵字，寫了也能夠
  def run(): Int = {
    1
  }
}

 

 

8 模式匹配和樣例類

Scala有一個十分強大的模式匹配機制，能夠應用到不少場合：如switch語句、類型檢查等。

而且Scala還提供了樣例類，對模式匹配進行了優化，能夠快速進行匹配

 

匹配字符串

package com

import scala.util.Random

/**
  * Created by Administrator on 2019/6/4.
  */
object CaseDemo01 extends App {

  val arr = Array("zhangsan", "lisi", "wangwu", "zhaoliu")

  val name = arr(Random.nextInt(arr.length))
  println(name)

  name match {

    case "zhangsan" => println("張三")
    case "lisi" => println("李四")
    case _ => println("王五")
  }
}

 

匹配類型

object CaseDemo02 extends App {

  val arr2 = Array("zhangsan", 1, 2.0, CaseDemo01)

  val v = arr2(Random.nextInt(arr2.length))
  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")
  }
}

 

匹配數組，元組

注意：在Scala中列表要麼爲空（Nil表示空列表）要麼是一個head元素加上一個tail列表。

9 :: List(5, 2)  :: 操做符是將給定的頭和尾建立一個新的列表

注意：:: 操做符是右結合的，如9 :: 5 :: 2 :: Nil至關於 9 :: (5 :: (2 :: Nil))

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, 7)
  tup match {
    case (1, x, y) => println(s"1, $x , $y")
    case (_, z, 5) => println(z)
    case _ => println("else")
  }

}

 

 

樣例類

在Scala中樣例類是一中特殊的類，可用於模式匹配。case class是多例的，後面要跟構造參數，case object是單例的

package com

import scala.util.Random

/**
  * Created by Administrator on 2019/6/4.
  */
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")
    }
  }

}

 

 

option類型

在Scala中Option類型樣例類用來表示可能存在或也可能不存在的值(Option的子類有Some和None)。Some包裝了某個值，None表示沒有值

object OptionDemo {
  def main(args: Array[String]) {
    val map = Map("a" -> 1, "b" -> 2)
    val v = map.get("b") match {
      case Some(i) => i
      case None => 0
    }
    println(v)
    //更好的方式
    val v1 = map.getOrElse("c", 0)
    println(v1)
  }
}

 

 

偏函數

被包在花括號內沒有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"))
  }
}