大数据学习——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"))
  }
}