Scala----主构造 辅助构造 单例对象 apply 继承和实现特质 case calss和case object 模式匹配 OptionSomeNone

主构造器

package cn.doit.com.day03.demo2

//跟在类名的后面,跟类交织在一起,叫主造器  主构造会执行类定义中的所有语句
// 用val和var修饰的构造器参数,会成为这个类的成员变量 默认val修饰 会成为类的成员变量
class Student(val name:String , var age:Int) {
  val i = 100

  //代码块
  {
    try {
      println("hi ketty")
    } catch {
      case e: Exception =>   //可以进行try catch
    } finally {}
  }

  def m():Unit={
    println("hello world")
  }

  var j:Int = _  //给指定的类型的变量赋予默认值

  Student.sayHi()
}

object Student {
  private def sayHi(): Unit ={
    println("hi tom")
  }

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

  }
}

 

辅助构造器

package cn.doit.com.day03.demo3
//在主构造器中传递的参数可以用val var修饰
class Boy(val name: String , val age: Int) {

  var sal: Double = _  //对应类型变量的的默认初始值
  var gender:String = _

  /*
      定义辅助构造器,辅助构造器一定要用def this,辅助构造器一定要调用
      主构造器或其他的辅助构造器
      辅助构造器的方法中的参数不用加var val修饰
      构造器方法一定是this
                     */
  def this(name:String, age:Int, sal:Double){
    this(name ,age)
    this.sal = sal
  }

  def this(name:String ,age:Int ,sal:Double ,gender:String){
    //调用了辅助构造器 相当于间接调用了主构造
    this(name,age,sal)
    this.gender = gender
  }
}

//不用 var val修饰只是形参
class Boy2(name: String , age: Int){

}

//name weight子类可以继承 private private[this]继承不了 height只是个形参
class Boy3(val name:String , private var age:Int , private[this] val weight:Double , height:Double = 165.0){

}

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

    val b = new Boy("tom", 18, 12000.0)
    println(b.sal)
  }
}

单例对象   synchronzied同步锁

package cn.doit.com.day03.demo4
/*
    synchronized锁 为保证线程安全
 */
object SynchronizedDemo {
  def main(args: Array[String]): Unit = {

    var m: Int = 10
    test(10)
    test2(20)
    println(m)

    //为了保证线程安全,使用同步synchronized锁
    def test(i: Int): Int = synchronized{
      m = i + m
      //赋值之后重新返回成员变量
      m
    }

    def test2(i: Int): Int ={
      println("hello girl")
      synchronized{
        m = i + m
        m
      }
    }
  }
}

package cn.doit.com.day03.demo4
/*
  单例对象
 */
object ObjDemo  {

    println("hello")
    println("world")

    def abc(): Unit ={
      println("ketty")
    }

    println("jerry")

    abc()
}



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

    val obj = ObjDemo  //初始化静态对象的方式一
    println(obj)

    //单例对象,初始化两次只会执行一次,地址值相同
    val obj2 = ObjDemo
    println(obj2)

    //会执行两次,静态代码块类加载的时候执行一次 ,现在调用它又执行一次
    ObjDemo.abc()
  }
}

apply方法

package cn.doit.com.day03.demo4
/*
  通常我们会在类的伴生对象中定义apply方法,当遇到类名(参数一,...参数二)时,apply方法会被调用
  不仅仅可以在object中定义,class中也可以定义
 */
object ApplyDemo {

  def apply(): Unit = {
    println("no args apply")
  }

  def apply(i: Int , j: Int): Unit = {
    println("two int args apply")
  }

  /*
     方法名相同 参数列表不同
        方法的重载 根据调用时传入的参数区分是哪一个方法
   */
  def apply(i:Int , j:Double): Unit = {
    println("one int one Double args apply")
  }

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

//    ApplyDemo.apply(1 , 2.0)

    //.apply可以省略掉
    ApplyDemo(1 , 2.5)

    //可以 .apply 证明他是object
    val arr = Array.apply(1,2,3,4,5,6)
    val lst = List(1,2,3,4,5,6)

    val demo = new ApplyClassDemo
    //demo.apply()
    //省略apply
    demo()
  }
}

package cn.doit.com.day03.demo4

class ApplyClassDemo {

  def apply(): Unit={
    println("hello world")
  }
}

App

package cn.doit.com.day03.demo4
/*
    App特质 可以不写main方法也可以运行
    实际是通过反射调用了main方法
 */
object AppDemo extends App {

  println("hello")
  println("tom")
}

继承和实现特质

抽象类父类

package cn.doit.com.day03.demo05
//抽象类 父类
abstract class Animal {
  var name:String
  var age: Int
  def run(): Unit

  //已经实现了的方法
  def breach(): Unit ={
  println("呼吸氧气")
  }
}

子类继承父类 实现特质

package cn.doit.com.day03.demo05
//子类继承父类  with实现接口,可以实现多个接口 中间不需要,
class Monkey extends Animal with Flyable with Fightable {

  //重写抽象 (未实现的方法) 可以加override,也可以不加
  override def run(): Unit = {
    println("蹦蹦跳跳的跑")
  }

  //重写已经实现了的方法 必须加上override关键字
  override def breach(): Unit = {
    println("呼吸新鲜的空气")
  }

  //重写特质中的方法
  override def fly(): Unit = {
    println("坐筋斗云飞")
  }

  //重写了特质中以实现的方法
  override def fight(): Unit = {
    println("金箍棒打你")
  }

  override var name: String = _
  override var age: Int = _
}

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

    val monkey = new Monkey
    monkey.breach()
    monkey.fight()
  }
}

特质

package cn.doit.com.day03.demo05
//特质 就是java8的接口
trait Flyable {

  def fly(): Unit
}

特质

package cn.doit.com.day03.demo05

trait Fightable {

  //已经实现了的方法
  def fight(): Unit ={
    println("打你")
  }
}

子类

package cn.doit.com.day03.demo05

//类不论是继承还是实现接口 第一次一定使用extends关键字,之后都是使用with关键字
class Pig extends Flyable with Fightable {

  //重写fly的方法
  override def fly(): Unit = {
    println("飞猪")
  }

  //重写fight的方法
  override def fight(): Unit = {
    println("用九齿钉耙搂你")
  }
}

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

    val pig = new Pig
    pig.fly()
    pig.fight()
  }
}

动态混入特质

package cn.doit.com.day03.demo05

class Dog {

}

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

    //动态混入特质  只有特质可以在new的时候实现特质
    val dog = new Dog with Fightable with Flyable {

      //在大括号中重写fight方法
      override def fly(): Unit = {
        println("哮天犬")
      }

      override def fight(): Unit ={
        println("咬你")
      }
    }
    dog.fly()
    dog.fight()
  }
}

多态 父类引用指向子类对象

package cn.doit.com.day03.demo05
//多态  父类引用指向子类对象
object DuoTaiDemo {
  def main(args: Array[String]): Unit = {

    val monkey: Animal = new Monkey
    //重写后的方法
    monkey.run()
    monkey.breach()
  }
}

case class 和 case object

package cn.doit.com.day03.cs

import java.io.{FileOutputStream, ObjectOutputStream}
import scala.beans.BeanProperty

//case可以用来模式匹配和封装案例
//也是一个特殊的class 可以创建多个实例,每个实例封装自己的数据
//可以用于模式匹配
//可以new 也可以不new 内部实现了apply方法
//默认实现序列化接口
//默认重写了toString方法
//case中的主构造器中的变量不加val var  默认就是val的 如果想重新赋值,要加上var
case class CStudent(
                    @BeanProperty  //get set方法   可以指定@beanGetter  @beanSetter
                    name:String ,  //默认val修饰 val可以省略
                    var age:Int
                   ) {
  //重写了toString方法  变量前面加$ , s必须要写
  override def toString: String = s"String: $name , Int $age"
}

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

    val cs = CStudent.apply("zss", 18)
    println(cs.name)
    println(cs.age)


    val oos = new ObjectOutputStream(new FileOutputStream("D:\\a.txt"))
    oos.writeObject(new User)
    oos.flush()
    oos.close()
  }
}

package cn.doit.com.day03.cs

import scala.beans.BeanProperty

//写出到磁盘需要实现序列化接口
class User extends Serializable {

  println("user constructor")

  @BeanProperty
  val name: String = "tom"
  @BeanProperty
  val age: Int = 10
}

模式匹配

package cn.doit.com.day04

import scala.util.Random

object CaseDemo01 extends App{

  val arr = Array("YoshizawaAkiho","YuiHatano","AoiSola")
  //生成随机数
  val name = arr(Random.nextInt(arr.length))
  println(name)
  name match {
    case "YoshizawaAkiho" => {
      println("吉泽***老师")
    }
    case "YuiHatano" => println("波多***老师")
      //通配" _ "
    case _ => println("这不是通往幼儿园的车,我要下车")
  }
}

package cn.doit.com.day04

import scala.util.Random

object CaseDemo02 extends App{
  //if else方法
  //val v = if(x >= 5) 1 else if(x < 2) 2.0 else "hello"
  //创建一个数组传不同类型的参数
  val arr: Array[Any] = Array("hello" , 1 , 2.0 , CaseDemo02)
  //数组生成随机数
  val v =arr(Random.nextInt(4))
  //val v: Any = 2.0
  println(v)

  // n match case => 固定格式
  v match {
      //int类型的值执行x
    case x: Int => {
      println("Int" + x)
    }
      //double类型的值且 y>= 3 执行y
    case y: Double if(y >= 3) => println("Double" + y)
      //string类型的值执行z
    case z: String => println("String" + z)
      //上面条件都不满足执行 _ 通配
    case _ => throw new Exception("not match exception")
  }
}

package cn.doit.com.day04

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

    //匹配数组
    val arr = Array(1,3,5,6)
    arr match {
        //数组首位为1且长度为3 执行
      case Array(1,x,y) => println(x + "" + y)
        //数组中只有0 执行
      case Array(0) => println("only 0")
        //数组中首位为0 _*代表可变参数  执行
      case Array(0,_*) => println("0 ...")
        //上述都不满足 执行
      case _ => println("something else")
    }

    //匹配集合
    val lst = List(0,1,2)
    lst match {
        // 0 :: Nil 把0放进空的list集合中lst(0)  :: 也可以写成 +:  Nil代表空的List集合
      case 0 :: Nil => println("only 0")
        // 把 x,y放进空的list集合中 lst(x,y)
      case x :: y :: Nil => println(s"x: $x , y: $y")
        /*
            list :+ 6   生成一个新的list,6在最后一位 并不是追加 原来的list依然存在
            6 +: list   生成一个新的list,6在首位 也不是追加 原来的list依然存在
            list1 ++ list2   两个list合并 list1和list2依然存在
            list1 :: list2   list1作为一个元素放进list中 List(List(1,2,3),4,5,6)
         */
      //把0放进去掉首位后的集合,代表首位为0
      //head为首位 tail代表去掉首位以外的 返回的是集合  tails返回的是迭代器
      case 0 :: tail => println("0 ...")
        //上述都不满足 执行
      case _ => println("something else")
    }

    //匹配元组
    val tup = (5,3,2)
    tup match {
        //首位为2且长度为3 执行元组中的三个元素
      case (2,x,y) => println(s"2, $x, $y")
        //最后一个元素为5,且长度为3 执行中间数z的值
      case (_,z,5) => println(z)
        //上述都不满足 执行
      case _ => println("else")
    }
  }
}

package cn.doit.com.day04

object WordCount {

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

    val lines = Array("hadoop,flink,spark,hadoop,Hive","hadoop,Flink,spark,Hadoop,spark")

    val grouped = lines.flatMap(_.split(",")).groupBy(a => a.toLowerCase)
    //元组中的元素特别多,容易混乱,使用模式匹配 match如果省略就要使用大括号
    val a = grouped.map{
      case (word , arr) => {
        (word , arr.length)
      }
    }
    println(a)
  }
}

样例类  样例对象  case class Demo   /   case object Demo

package cn.doit.com.day04

import scala.util.Random
/*
    样例类 样例对象: 专门用来模式匹配的,样例类可以创建多个实例,样例object是单例的
    样例类创建实例后可以封装数据,样例object不能保存数据
    样例类不需要new
 */
//样例类
case class SubmitTask(id:String , name:String)

case class HeartBeat(time:Long)

//样例对象 , 单例的 在一个JVM进程中只有一个实例
case  object CheckTimeOutTask

object CaseDemo04 extends App{

  val arr:Array[Product] = Array(CheckTimeOutTask , new HeartBeat(12333) , HeartBeat(5555) , SubmitTask("0001","task-0001"))

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

  r match {
    case SubmitTask(id , name) => {
      println(s"$id , $name")
    }
    case HeartBeat(time) => {
      println(time)
    }
    case CheckTimeOutTask => {
      println("check")
    }
  }
}

偏函数(PartialFunction) 专门用来做模式匹配的

package cn.doit.com.day04

object PartialFuncDemo {

  //PartialFunction类型的方法就叫做偏函数
  // String代表输入的类型  Int代表返回的类型
  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("two"))
    println(func2("two"))
  }
}

OptionSomeNone

package cn.doit.com.day03.demo06

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

   val mp = Map("a" -> 1 , "b" -> 2)
    //传入的参数如果找不到就会报错
//   val r:Int = mp.apply("c")
//    println(r)

    //option代表这个参数有可能有,有可能没有
//    val op:Option[Int] = mp.get("b")
//
//    val r =op match {
//        //如果有这个值返回这个值
//      case Some(x) => x
//        //如果没有这个值返回0
//      case None => 0
//    }

    //有b返回b,没有返回-1 底层就是optionSomeNode   推荐使用
    val r = mp.getOrElse("b",-1)
    println(r)
  }
}

模式匹配小案列

package cn.doit.com.day03.demo06

object WordCount {

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

    val lines = Array("hadoop,flink,spark,hadoop,Hive", "hadoop,Flink,spark,Hadoop,spark")

    val grouped = lines.flatMap(_.split(",")).groupBy(a => a.toLowerCase)
    //元组中的元素特别多,容易混乱,使用模式匹配 match如果省略就要使用大括号
    val a = grouped.map {
      case (word, arr) => {
        (word, arr.length)
      }
    }
    println(a)
  }
}