scala面向对象

最新推荐文章于 2022-09-28 12:41:52 发布
最新推荐文章于 2022-09-28 12:41:52 发布
阅读量131 收藏
点赞数 1
分类专栏： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43457608/article/details/109392507
版权

Scala面向对象编程

1.课程目标

  • 掌握Scala中面向对象编程
  • 掌握Scala模式匹配
  • 掌握Scala泛型高级内容
  • 熟悉Scala中多线程编程模型

2.面向对象

2.1 类
  • 定义： class 类名{
    	成员变量
    	val/var 名称=值
    	成员方法
    	def 方法名称（参数列表）：返回值={
            方法体
        }
	}
创建对象：
	val 对象名称=new 类名（） //（） 可写可不写  （）没有参数的时候可以省略

/**
  * Person
  * name 不可变
  * age  可变
  * skill 数组
  * 方法：
  * def addSkill
  * def scanSkill
  */
class Person {
  val name = "itcast"  //不可变 不需要setter 
  var age = 13  //可变 需要setter getter
  val skill = new ArrayBuffer[String]()

  // def addSkill
  def addSkill(subject: String): Unit = {
    skill += subject
  }

  def scanSkill(): Unit = {
    skill.foreach((x: String) => println(x))
  }
}


object Scala_01_class {
  def main(args: Array[String]): Unit = {
    val person = new Person
    println(person.name)
    person.age=14
    println(person.age)
    person.addSkill("scala")
    person.addSkill("spark")
    person.scanSkill()
  }
}
2.2 setter getter
  • /**
  * Student类
  * name 不可变
  * age 可变
  *
  * 注意：
  *   1.如果一个方法 只返回结果 在方法内部不进行任何业务逻辑处理的话，就可以省略方法名称后边的小括号“（）”
  *   2.通过def 定义属性
  */

class Student {
  val name = "itcast" //不需要提供setter 和getter
  private var _age = 10 //可变变量定义格式 ： _名称
  //setter
  def age_(age: Int) = this._age = age

  //getter
  def  age=this._age
}

object Scala_02_class {
  def main(args: Array[String]): Unit = {
    val student = new Student
    student.age_(10)
    println(student.age)
  }
}
2.3 方法的调用原则

  • ​

    /**
  * Teacher 类
  *   teach方法
  *
  *   注意：teacher teach "spark" 这种调用方式只适用于一个参数的方法
  */
class Teacher{
  def teach(suject:String): Unit ={
    println(s"教学：$suject")
  }
}

object Scala_03_class {
  def main(args: Array[String]): Unit = {
    val teacher = new Teacher
    teacher.teach("hadoop")
    teacher teach("scala")
    teacher teach "spark"
    0 to 10 
    0 until 10
    1 + 2
  }
}
2.4 Scala构造器
  • 两种构造器方式
	主构造器
		class 类名（参数*）
	辅助构造器
		定义在类当中
		def this(参数*){
            //第一行代码必须代用主构造
            this（参数）
        }
/**
  * 定义： Animal
  * 主构造器 （name）
  * 辅助构造（color，legs）
  */
class Animal(val name: String) {
  var _color = "red"
  var _legs = 2

  //辅助构造（name,color，legs）
  def this(name: String, color: String, legs: Int) {
    this(name) //调用主构造器
    this._color = color
    this._legs = legs
  }
}

object Scala_04_class {
  def main(args: Array[String]): Unit = {
    val a=new Animal("dog")

    val b=new Animal("cat","white",2)

    println(a.name)
    println(b._legs)
  }
}
2.5 Scala中单例对象
  • 创建方式：
	object 名称{
        成员变量
        成员方法
    }
使用方式：
	可以通过 名称.成员变量/成员方法 形式使用。相当于java中static修饰变量和方法的调用
 应用场景：
	单例对象多应用于工具类或者工具对象
//创建工具对象
object CommonUtil {
  val PI = 3.14

  def getDate = new Date
}

object Scala_05_object {
  def main(args: Array[String]): Unit = {
    println(CommonUtil.PI)
    println(CommonUtil.getDate)
  }
}
2.6 伴生对象
  • 当单例对象的名称跟类名相同的时候，并且单例对象和类同时存在于同一个文件中， 这里这个对象就称之为类的伴生对象。类是对象的伴生类

/**
  * SoftEngineer 类
  * SoftEngineer  object
  * 1.伴生类和伴生对象之间可以互相访问 private属性和方法
  * 2.apply存于伴生对象中 能够实现伴生类创建对象的功能 ，相当于java中的工厂模式的定义
  */
class SoftEngineer(val exp:Int){
  private var salary=1000
  def getHasGF()={
    SoftEngineer.hasGF //访问伴生对象中私有变量
  }
  val hasHair=SoftEngineer.hasHair()

}

object SoftEngineer{
  private var hasGF=false
  //定义方法 访问伴生类的私有变量
  def getSalary()={
    val engineer = new SoftEngineer(10)
    engineer.salary  //访问私有变量
  }
  private def hasHair()={
    true
  }

  def apply(exp:Int): SoftEngineer = new SoftEngineer(exp)
}


object Scala_06_object {
  def main(args: Array[String]): Unit = {
    val engineer = new  SoftEngineer(10)
    println(engineer.getHasGF())
    println(engineer.hasHair)
    println( SoftEngineer.getSalary())

    val engineer2 = SoftEngineer(10) //Array（“dd”） List("ddd")
  }
}
2.7 main函数
  • //通过继承App的方式可以省略掉main 
//本质上 还是没有省略 App中包含main函数
object Scala_07_object extends App {
  println("hello app")
  println(args(0))
}
2.8 继承
  • 格式：class 类名 extends 父类
1.scala单继承
2.子类可以继承父类的非私有的属性和方法
3.子类可以重写父类的方法和属性
4.子类可以通过super关键词调用父类的属性和方法

/**
  * 父类  BigDataEngineer
  *   不可变 name
  *   可变 age
  *   方法 study
  * 子类  HadoopEngineer
  *
  */
class BigDataEngineer{
  val  name="BigData"
  var age=10
  def study():Unit={
    println("学习和开发")
  }
}
class HadoopEngineer extends BigDataEngineer{
  //子类覆盖父类中的study方法  override
  override def study(): Unit = {
    age=12
    super.study()
    println("开发hadoop")
  }
}
object Scala_08_extends extends App{
     val engineer = new HadoopEngineer
     println(engineer.name)
     engineer.study()
}
问题：子类在创建对象的时候，是否调用了父类的构造器？ 
	scala中子类创建对象的时候也同样调用了父类的构造器

  • Scala中构造机制

    • /**
  * 类 Person_09
  * 子类 Sun_09
  */
class Person_09{
  println("Person_09")  //主构造器调用完成之后直接调用
}

class Sun_09 extends  Person_09{
  println("Sun_09")
}

object Scala_09_extends extends  App {
   val sun_0 = new Sun_09
   //根据打印结果
    //在子类创建对象的过程中，调用了父类的构造器的
}
2.9 子类调用父类的构造器
  • 子类主构造器没有参数，父类主构造器有参数
子类主构造器有参数，父类主构造器也有参数

/**
  * 父类PC 电脑（cup memory）
  *   子类 NotePC
  *    台式机：DeskPC（cup memory）
  */
class PC(val cpu:Int,val memory:Int)

class NotePC extends PC(cpu = 10,memory = 20)

class DeskPC(cpu:Int,memory:Int) extends PC(cpu,memory)

object Scala_10_extends {
  def main(args: Array[String]): Unit = {
    val n = new NotePC
    println(n.cpu)
    println(n.memory)
    println("----------------------")
    val deskPC=new DeskPC(30,60)
    println(deskPC.cpu)
    println(deskPC.memory)
  }
}
2.10 抽象类
  • 定义： abstract class 类名
1.可以定义抽象方法和抽象属性（没有初始化的属性）
2.可以有非抽象的方法和非抽象属性
3.如果方法或者属性被final修饰，不能够被重写

/**
  * Employee 员工
  * val name 抽象
  * var age 非抽象的
  * 抽象方法 work
  * 非抽象方法 study
  * final 方法：sleep
  */
abstract class Employee {
  val name: String //抽象属性 数据类型不能够省略
  var age = 25

  def work(): Unit //抽象方法返回值类型不能够省略
  def study(): Unit = {
    println("学习公司文化")
  }

  final def sleep(): Unit = {
    println("休息")
  }
}

class ScalaEmployee extends Employee {
  /**
    * override  如果覆盖的是非抽象的方法或者属性 这里不能够省略
    * 如果覆盖的是抽象方法或者属性 这里可以省略
    */
  override val name: String = "scala"

  override def work(): Unit = {
    println("开发scala应用程序")
  }

}

object Scala_11_extends extends App {
  private val employee = new ScalaEmployee
  println(employee.name)
  employee.work()
  employee.study()
}
2.11匿名内部类
  • 应用场景：
	ScalaProgramer  只会开发scala应用程序。python 

class ScalaProgrammer {
  def workerByScala(): Unit = {
    println("开发scala应用程序")
  }
}
class pyAndScaProgrammer extends ScalaProgrammer{
    def workerByPython(): Unit = {
        println("学习并开发python")
      }
}
object Scala_12_innerclass {
  def main(args: Array[String]): Unit = {
    //python项目 临时性需求
   val scala= new ScalaProgrammer {
      def workerByPython(): Unit = {
        println("学习并开发python")
      }
    }
    scala.workerByPython()
    scala.workerByScala()
    println(scala.getClass)
  }
}
2.12 超级父类
  • Any 超级分类
	AnyRef  所有引用类型对象的超级父类 ScalaProgrammer
	AnyVal  所有值类型对象的超级父类 Int Double...
2.13 类型转换和类型判断
  • 子类继承父类，父类的引用可以指向子类对象。父类的引用是多态的。多态的问题 ：类型转换异常

*  val worker = w.asInstanceOf[Worker]
	1. 对象.isInstanceOf[类型]  模糊判断 不精准
      * 2. 对象.getClass=classOf[类型]
class Worker {
  def work(): Unit = {
    println("工作")
  }
}

class JavaWorker extends Worker {
  def workByJava(): Unit = {
    println("开发java项目")
  }
}

object Scala_13_change {
  def boss(w: Any): Unit = {
    //将any对象转换成 worker对象
    //判断对象的类型
    /**
      * 1. 对象.isInstanceOf[类型]  模糊判断 不精准
      * 2. 对象.getClass=classOf[类型]
      */
    if (w.isInstanceOf[Worker]) {
      val worker = w.asInstanceOf[Worker]
      worker.work()
    } else {
      println("回家等消息")
    }
  }

  def boss2(w: Any): Unit = {
    //将any对象转换成 worker对象
    //判断对象的类型
    /**
      * 1. 对象.isInstanceOf[类型]  模糊判断 不精准
      * 2. 对象.getClass=classOf[类型]
      */
    if (w.getClass()==classOf[JavaWorker]) {
      val worker = w.asInstanceOf[JavaWorker]
      worker.workByJava()
    } else {
      println("回家等消息")
    }
  }

  def main(args: Array[String]): Unit = {
    val worker = new Worker
    /*boss(worker)
    boss(new Student)*/
    val javaWorker = new JavaWorker
    boss2(worker)
  }
}
2.14特质

  • 特质的功能

    • 格式：trait 名称
    • 功能：
      • 特质可以作为java中的接口使用
      • 特质可以作为抽象类使用
      • 特质可以扩展对象的方法（1 个方法 --》多个方法）
      • 特质可以扩展特定方法的功能

  • 特质作为接口使用

    • /**
  * 定义
  * trait  名称
  * 可以作为接口使用
  *   1.可以定抽象方法
  *   2.接口可以多实现
  */
格式：类 extends Tarit名称 with  Tarit名称2 with Tarit名称3

trait HelloTrait {
  def sayHellByChina(): Unit
}

trait HelloTraitHanguo {
  def sayHellByHanguo(): Unit
}

trait HelloTraitTaiguo {
  def sayHellByTaiguo(): Unit
}

class HelloTraitImpl extends HelloTrait with HelloTraitHanguo with HelloTraitTaiguo {
  override def sayHellByChina(): Unit = {
    println("你好")
  }

  override def sayHellByHanguo(): Unit = {
    println("阿尼哈沙有")
  }

  override def sayHellByTaiguo(): Unit = {
    println("萨瓦迪卡")
  }
}

object Scala_14_trait {
  def main(args: Array[String]): Unit = {
    val impl = new HelloTraitImpl
    impl.sayHellByChina()
    impl.sayHellByHanguo()
    impl.sayHellByTaiguo()
  }
}

  • 特质作为抽象类使用

    • trait AbstractTrait {
  //非抽象属性和方法
  val name = "itcast"

  def study(): Unit = {
    println("学习")
  }

  //抽象属性和方法
  val age: Int

  def work(): Unit

}

class AbstractTraitImpl extends AbstractTrait {
  override val age: Int = 10

  override def work(): Unit = {
    println("工作")
  }
}

object Scala_15_trait extends App {
  private val impl = new AbstractTraitImpl
  println(impl.age)
  println(impl.name)
  impl.work()
  impl.study()
}
特质和抽象类的区别
	1.抽象类可以有自己的主构造器以及初始化参数
    2.特质可以多实现但是抽象类只能进行单继承或者多重继承

  • 特质扩展对象的功能

    • package cn.itcast.day02

class Tank {
  def shoot(): Unit = {
    println("发射子弹")
  }
}

trait Aim {
  def aim(): Unit = {
    println("瞄准")
  }
}

trait Scan {
  def scan(): Unit = {
    println("扫描")
  }
}

trait Fly{
  def fly():Unit
}

object Scala_16_trait {
  def main(args: Array[String]): Unit = {
    val tank = new Tank with Aim with Scan with Fly{
      override def fly(): Unit = {
        println("飞上天")
      }
    }
    tank.scan()
    tank.aim()
    tank.shoot()
    tank.fly()
  }
}

  • 特质扩展特定方法的功能

    • super： 线性调用的标志符，线性是动态过程 是根据特质的混入顺序有关的
线性执行顺序：自右向左的过程

class Tank2 {
  def shoot(): Unit = {
    println("发射")
  }
}

trait Aim2 extends Tank2 {
  override def shoot(): Unit = {

    println("瞄准")
    super.shoot()
  }
}

trait Scan2 extends Tank2 {
  override def shoot(): Unit = {
    println("扫描")
    super.shoot()
  }
}
class SuperTank extends Tank2 with Aim2 with Scan2

object Scala_17_trait {
  def main(args: Array[String]): Unit = {
    val tank = new SuperTank
    tank.shoot()
  }
}

  • 特质构造机制

    • 构造机制的执行原则：  从左往右  自上而下

trait T0{
  println(0)
}
trait T1{
  println(1)
}
trait T2{
  println(2)
}
trait T3 extends T1{
  println(3)
}
class Timpl extends T0 with T3 with  T2 with  T1{
  println("Timpl")
}

object Scala_18_trait extends App {
  //1 2 1 3 0
  // Timpl  1 2 1 3 0
  new Timpl  // 从左往右  自上而下
}

3. 模式匹配

  • 功能类似于java中switch结构，但是要比swith强大的多

    • 数值
    • 数据类型
    • Array
    • List
    • Tuple
    • Map
    • 自定义数据类型
  • 结构：
	value match {
        case 需要匹配值或者类型 =>{ 执行逻辑}
        case _ => {执行逻辑} //默认的匹配
    }

  • 模式匹配值匹配

    • //值匹配
val arr = Array("hadoop", "scala", "spark")
var value = arr((math.random * arr.size).toInt)
//println("value:" + value)
value="java"

/**
  * value match {
  * case 需要匹配值或者类型 =>{ 执行逻辑}
  * case _ => {执行逻辑} //默认的匹配
  * }
  */
value match {
  case "hadoop" => println("匹配Hadoop")
  case "scala" => println("匹配scala")
  case "spark" => println("匹配spark")
  case _ =>println("默认匹配")
}

  • 数据类型匹配

    • object DataType {
  def main(args: Array[String]): Unit = {
    val arr=Array("hadoop",1.34,10,true)
    var value = arr((math.random * arr.size).toInt)
    println("value:"+value)
    value match {
      case s:String => println(s+"-------------")
      case d:Double => println(d+"-------------")
      case i:Int => println(i+"-------------")
      case b:Boolean =>println(b+"-------------------")
    }
  }
}

  • 模式匹配数组

    • object MatchArray{
  def main(args: Array[String]): Unit = {
    val arr=Array("hadoop",1.34,10,true)
    arr match {
       //能否有个配所有array
      
      //非精确匹配
      case Array("hadoop1",_*) =>println("333333")
      //占位符匹配
      case Array("hadoop",1.34,_,_) =>println("222222222")
       //精确匹配
      case Array("hadoop",1.34,10,true) =>println("111111")
        case Array(_*) =>println("4444444")
    }
  }
}

  • 模式匹配列表

    • object MatchList{
  def main(args: Array[String]): Unit = {
    val list=List("hadoop","spark","scala")
    list match {
      case "hadoop"::"spark"::"scala"::Nil =>println("sfsfsfdsfsdsdfd")
       //模糊匹配
      case List(x,_*) =>println(x)
      case List(x,y,_) =>println(x+"\t"+y)
      //精确匹配
      case List(x,y,z) =>println(x+"\t"+y+"\t"+z)
      case List("hadoop","spark","scala") => println("精确匹配list")
    }
  }
}

  • 模式匹配Tuple

    • object MatchTuple {
  def main(args: Array[String]): Unit = {
    val t = ("hadoop", 1.23, 10, true)

    t match {
      case (x,_,_,_) =>println("sdfdsfds")
      case _ =>println("默认匹配。。。。")
      //case ("hadoop",_*) =>println("")
      case ("hadoop",_,_,_) =>println("匹配占位符tuple")
      case  ("hadoop", 1.23, 10, true) =>println("精确匹配tuple")
    }

  }
}

  • 模式匹配Map

    • object  MatchMap{
  def main(args: Array[String]): Unit = {
    val map=Map("hadoop"->100,"scala"->50)
    val value=map.get("java")
    value match  {
      case Some(x) =>println(x)
      case None =>println("没有值")
    }
  }
}

  • 模式匹配自定数据类型

    • 样例类 case class 名称

      • 样例类跟普通类区别：样例类能够自动构建apply方法

    • 样例对象

      • case object 名称 ：应用场景 只是作为标志
    • case class Task(name: String)
case object TaskObject

object MatchCaseClass {
  def main(args: Array[String]): Unit = {
    val arr = Array(Task("itcast"), TaskObject)
    val value = arr((math.random * arr.size).toInt)
    println("value:" + value)
    Task("lisi") match {
      case Task(name) => println("name：" + name)
      case TaskObject => println("匹配样例对象")
    }
  }
}

4. 偏函数 x=>y

  • 把模式匹配这种形式 放在一个方法或者一个函数中，就构成一种新的函数，偏函数
//方法
def 名称(参数)= value math{
    case 操作
}
//函数
val 名称:PartialFunction[输入数据类型，返回值数据类型] ={
    case 操作
}

object Scala_20_pianhanshu {

  def intMatch(x: Int) = x match {
    case 10 => println("10")
    case 100 => 100
  }
 
  def main(args: Array[String]): Unit = {
    intMatch(10)
    println(intMatch(100))

    val matchFuncion: PartialFunction[Int, String] = {
      case x:Int => x + " is even"
    }
    println(matchFuncion(10))
  }
}

5.逆变协变非变

  • class Apple
class RedApple  extends Apple
class Box[T]
问题：RedApple 是 Apple 子类， Box[RedApple] 是不是 Box[Apple]子类？ 假如  Box[RedApple] 是 Box[Apple]子类
 val box：Box[Apple] =new Box[RedApple] 则成立 ，反之则不成立  
答案 ：以上假设不成立

要想让以上操作成立 需要协变操作




RedApple extends Apple
class Box[T]  
a=Box[Apple]  b=Box[RedApple]


class Box[+T]  
a=Box[Apple]  b=Box[RedApple]

class Box[-T]  
a=Box[Apple]  b=Box[RedApple]
逆变：class Box[-T]  
	val box：Box[RedApple] =new Box[Apple] 


class RedApple extends Apple

class Box[+T]  //协变

class Box2[-T]

object Scala_21_fanxin {
  def main(args: Array[String]): Unit = {
    val box: Box[Apple] = new Box[RedApple]

    val box2:Box2[RedApple] =new Box2[Apple]
  }
}
Son extends Person

总结：a=ArrayList<Person> b=ArrayList<Son>
    
C[T]:	A是B的子类 C[A]与C[B]之间没有任何关系  非变操作
C[+T]: A是B的子类  C[A]是C[B]的子类  协变操作
C[-T]： A是B的子类  C[A]是C[B]的父类  逆变操作

6.上下界

  • 上下界 影响的是方法的入参

U>:Class U 带表的class本身以及其父类 下界操作 下界限制不住
U<:Class U 代表class 本身以及其子类  上界操作

class OldMan extends Man

class  OldOldMan extends  OldMan

class YoungMan extends Man

class ChildMan extends YoungMan

class Sport {
  //添加下界操作 U 代表的是 OldMan 本身 或者是其父类  下界操作 其实是无下界
  def guangchangwu[U >: OldMan](man: U): Unit = {
    println("广场舞")
  }
  //U 带表示 YoungMan本身以及其子类
  def qiaodaima[U<:YoungMan](man: U): Unit = {
    println("敲代码")
  }
}

object Scala_22_upanddown {
  def main(args: Array[String]): Unit = {
    val sport = new Sport
    val yman = new YoungMan
    val oman = new OldMan
    val ooman=new OldOldMan
    val cman = new ChildMan
 /*   sport.guangchangwu(yman)
    sport.guangchangwu(oman)
    sport.guangchangwu(ooman)*/

    sport.qiaodaima(cman)

  }
}

7.Scala并发操作

  • 格式：	
	class 线程类 extends Actor{
        def act（）
    }
//启动线程
	actor.start()

/**
  * 创建线程类 MyActor
  */
class MyActor(val name: String) extends Actor {
  override def act(): Unit = {
    for (i <- 0 to 10) {
      println(name + ":" + i)
    }
  }
}

object Scala_23_actor {
  def main(args: Array[String]): Unit = {
    val itcast = new MyActor("itcast")
    val tian = new MyActor("Tian")
    itcast.start()
    tian.start()
  }
}

  • Actor基于消息机制的并发

    • actor能够发送消息 和接受消息，根据消息的不同，去执行不同的业务逻辑

    • ！ 发送消息

    • class MyActor2 extends Actor {
  override def act(): Unit = {
    var flag = true
    while (flag)
      receive { //阻塞
        case "start" => println("启动成功") //执行逻辑完成后自动退出
        case "test" => println("测试")
        case "end" => {
          println("退出")
          flag = false
        }
      }
  }
}

object Scala_24_actor {
  def main(args: Array[String]): Unit = {
    val actor = new MyActor2()
    actor.start()
    actor ! "start"
    actor!"test"
    actor ! "end"
  }
}

  • loop react

    • class MyActor2 extends Actor {
  override def act(): Unit = {
    loop{
      react{
        case "start"=>println("启动成功过")
        case "test" =>println("测试")
        case "end"=> exit()
      }
    }
  }
}

object Scala_24_actor {
  def main(args: Array[String]): Unit = {
    val actor = new MyActor2()
    actor.start()
    actor ! "start"
    actor!"test"
    actor ! "end"
  }
}

  • Actor发送消息的三种方式

    • ！ 异步消息 并且无返回值

    • !? 同步消息 有返回值

    • !! 异步消息 有返回值 Future[Any]

    • 同步消息和异步消息

      • 同步消息：发送消息后，会等待消息执行逻辑完成，再返回
      • 异步消息：发送消息后直接返回，返回会在将来的某一时刻返回 Future[Any]

    • 总和案例：

      • 结合样例类方式 来整同步消息和异步消息以及返回值
      • 需要构建3个样例类
    • /**
  * 消息模型
  * 同步消息
  * 异步消息
  * 返回值消息
  */
case class SynMsg(msg: String, time: Long)

case class AsynMsg(msg: String, time: Long)

case class ReplayMsg(msg: String)

class MsgActor extends Actor {
  override def act(): Unit = {
    loop {
      react {
        case SynMsg(msg, time) => {
          Thread.sleep(time)
          println(msg)
          sender ! ReplayMsg(msg + "---SynMsg-----")
        }
        case AsynMsg(msg, time) => {
          Thread.sleep(time)
          println(msg)
          sender ! ReplayMsg(msg + "---AsynMsg-----")
        }
      }
    }
  }
}

object Scala_25_actor {
  def main(args: Array[String]): Unit = {
    val actor = new MsgActor
    actor.start()
    /*val msg1=actor!?SynMsg("itcast",5000)
    val msg2=actor!?SynMsg("itcast2",1000)
     println(msg1)
     println(msg2)*/

    val msg1 = actor !! AsynMsg("itcast", 5000)
    val msg2 = actor !! AsynMsg("itcast2", 1000)

    val list = ListBuffer[Future[Any]]()
    list += msg1
    list += msg2

    while (list.size > 0) {
      for (msg <- list) { //msg:Future[Any]
        //判断future是否接收到数据
        if (msg.isSet) { //ture 代表已经接受到数据
          val replayMsg = msg.apply().asInstanceOf[ReplayMsg]
          println(replayMsg.msg)
          list -= msg
        }
      }
    }
  }
}

  • 基于Actor的wordcount案例

    • 操作步骤：

      • 准备文件 a.txt b.txt c.txt
      • 构建actor
      • 通过样例类 构建消息的载体 case FilePathMsg（path：String）
      • actor接受消息 并且处理文件数据
      • 接受返回值 并且将返回值放在ListBuffer进行管理
      • 对ListBuffer进行循环操作，拿到文件处理数据，把文件处理数据放在一个集合中
      • 对集合进行汇总处理
    • package cn.itcast.day02

import java.io.File

import scala.actors.{Actor, Future}
import scala.collection.mutable.{ArrayBuffer, ListBuffer}
import scala.io.Source

/**
  * 样例类方式构建消息载体
  */
case class FilePathMsg(path: String)

//返回值消息
case class FileResultMsg(result: Map[String, Int])

class FileActor extends Actor {
  override def act(): Unit = {
    loop {
      react {
        case FilePathMsg(path) => {
          //读取文件数据 并且进行处理 Map
          val map: Map[String, Int] = Source.fromFile(new File(path)).getLines().mkString(",").split(",")
            .map((x: String) => (x, 1)).groupBy((t: Tuple2[String, Int]) => t._1)
            .mapValues((arr: Array[Tuple2[String, Int]]) => arr.length)
          sender ! FileResultMsg(map)
        }
      }
    }
  }
}

object Scala_26_wordcount {
  def main(args: Array[String]): Unit = {
    val arr = Array("d:/a.txt", "d:/b.txt", "d:/c.txt")
    val list = ListBuffer[Future[Any]]()
    //数组封装了每个文件处理好的数据
    val fileDataArray = ArrayBuffer[Map[String, Int]]()

    for (path <- arr) {
      val actor = new FileActor
      actor.start()
      //发送异步消息 并且接受到每个文件的处理结果
      val result = actor !! FilePathMsg(path)
      list += result
    }

    while (list.size > 0) {
      for (f <- list if f.isSet) {
        val fileResult = f.apply().asInstanceOf[FileResultMsg]
        fileDataArray += fileResult.result
        list -= f
      }
    }
    val wordcount = fileDataArray.flatten.groupBy((t: Tuple2[String, Int]) => t._1)
      .mapValues((arr: ArrayBuffer[Tuple2[String, Int]]) => {
        arr.map((t: Tuple2[String, Int]) => t._2).sum
      })
    println(wordcount)
  }
}

​

半度、
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Scala面向对象.docx
04-05
Scala面向对象
Scala面向对象编程课件.rar
03-09
Scala面向对象编程课件.rar
scala 单例对象 伴生对象
bitcarmanlee的博客
11-18 1530
1.单例对象Scala中没有静态方法或静态字段，但可以使用object这个语法结构来实现相同的功能。Object与class在语法层面上很相似，除了不能提供构造器参数外，object可以拥有class的所有特性。废话不多说，直接上代码object Singleton { var count = 0 def addCount:Long = { count += 1 count
Scala语言基础（四）面向对象（一）定义类、定义构造器
pageniao的博客
11-02 507
面向对象 重要的两个概念 类：相同的事物组成的一个类或裙（抽象概念：描述一类相同的事物） 对象：一个类或群体里的单个实体 面向对象的四大特征 抽象，封装，继承，多态 构建实例对象的五种方法： 1，调用构造器（公开） 2，静态工厂方法（构造器私有） 3，反射 4，克隆（object.clone()） 5，反序列化 定义类 //伴生类 class Student{ /** * 1，在scal...
Scala面向对象类的定义
weixin_48143996的博客
04-12 148
Scala面向对象类的定义 Scala面向对象类的定义 类的定义 关键字：class 普通的类，通过new来构建类的实例 全局多例的：在一个程序中可以构建多个实例 成员属性的定义 直接在类的内部声明每个成员属性，可以为var类型也可以为val类型 注意：Scala中会自动为每个成员属性构建getter and setter方法，不用自己申明 var有get and set val只有get，因为val不可变 成员方法的定义 与Java中定义普通的方法时一致的 只需要根据语法定义即
面向对象2
qq_41737952的博客
05-27 166
一：属性Python的属性分为实例属性和类属性实例属性是以self作为前缀的属性类属性是在类内部定义的属性，可以被类中的所有实例共享注意：如果属性的名字以两个下划线开始，就表示私有属性(方法也一样)二：方法__init__()方法：构造方法,用来初始化新创建的对象__str__(self)方法：返回一个字符串，实现了__str__(self)方法后，可以直接使用print语句输出对象，也可以通过s...
pythond的小黑屋实验
qq_53376823的博客
01-05 112
利用函数进行赋值，在利用可变函数与关键字参数输入参数值， 最后利用随机函数进行原则，根据原则结果的不同，最后的输出结果也会不同 在这里插入代码片 import random import time EVENT = ["衣衫褴褛的人","陷阱","xxx"] SOURCE = ["木材","肉","布"] SKILL = ["葵花宝典","打狗棒法","金钟罩铁布衫","九阴真经","吸星大法"] def Init(): person = {"HP":100, "Hungry":100, "IQ":1
Scala基础
qq_50209297的博客
09-28 79
第二章 Scala基础
Scala基础学习03
数据攻城狮的博客
03-12 1994
文章目录scala类Scala object scala类 一般，Scala类名的第一个字母要大写，几个单词拼成一个类名，每个单词首字母大写。Scala中的类不声明为public,一个Scala类中可以有多个源文件，并且Scala类可以有参数。 定义一个类Point来计算二维坐标移动后的坐标 scala> :paste // Entering paste mode (ctrl-D to finish) class Point(xc:Int,yc:Int){
Scala面向对象基础--类和对象
耐心的小黑的博客
07-25 1120
一、类的定义与对象创建 在Scala里，类是用关键字“class”开头的代码定义，它是用于创建对象的蓝图。一个类就是一个类型，不同的类就是不同的类型，一个对象的类型就是创建它用的那个类。 在类里可以定义val或var类型的变量，它们被称为“字段”；还可以定义函数，它们被称为“方法”；此外还可以定义：常量、类型、对象、特质、类等等，这些在类里定义的东西统称为“成员”。 外部想要访问对象的成员时，可以使用句点符号“ . ”，通过“对象.成员”的形式来访问。此外，用new构造出来的对象可以赋给变量，让变量名成为该
Scala 【 8 面向对象编程 – 继承 】
01-20
面向对象编程 – 继承 复用 ~ 可扩展性 ~ 可维护性 extends 使用 extends 关键字表示继承。 继承就代表，子类可以从父类继承父类的 field 和 method 。子类可以在自己内部放入父类所没有的子类特有的 field 和 ...
Scala考试题1
08-08
1.var，val和def三个关键字之间的区别 2.trait（特质）和abstract class（抽象类）的区别 3.object和class的区别 4.c
17面向对象
01-07
scala语言是一门面向函数编程的语言, 并且兼容面向对象的思想 Scala中类分为两种：描述类class，执行类object。 类不需要使用public修饰，一个文件可存在多个类。 2.创建类 class Student{ //var修饰的属性相当于...
JavaScript介绍.zip
最新发布
04-23
javascript,JavaScript 最初由 Netscape 公司的 Brendan Eich 在 1995 年开发，用于 Netscape Navigator 浏览器。随着时间的推移，JavaScript 成为了网页开发中不可或缺的一部分，并且其应用范围已经远远超出了浏览器，成为了全栈开发的重要工具。
上位机开发罗克韦尔abcip通信协议详解
04-23
上位机开发罗克韦尔abcip通信协议详解 1.注册会话命令详解 6500 0400 00000000 00000000 0000000000000000 00000000 0100 0000 响应 6500 0400 05000400 00000000 0000000000000000 00000000 0100 0000 6500：注册请求命令 0400：服务长度（0100 0000） 00000000：会话句柄 （由PLC生成） 00000000：状态默认 0000000000000000：发送方描述，默认0 00000000：选项，默认0 0100：协议版本，默认1 0000：选项标记，默认0
Microsoft SPY++ 工具及使用教程
04-23
Spy++ (SPYXX.EXE) 是一个基于 Win32 的实用工具，提供系统进程、线程、窗口和窗口消息的图形视图。 Spy++ 有两个版本。 第一个版本，名为 Spy++ (spyxx.exe)，用于显示发送到在 32 位进程中运行的窗口的消息。 例如，在 32 位进程中运行的 Visual Studio。 因此，可以使用 Spy++ 来显示发送到“解决方案资源管理器” 中的消息。 由于 Visual Studio 中大多数生成的默认配置都是在 32 位进程中运行的，因此如果已安装所需组件，则第一个版本的 Spy++ 就是在 Visual Studio 中的“工具”菜单上可用的那一个。 第二个版本，名为 Spy++（64 位）(spyxx_amd64.exe)，用于显示发送到在 64 位进程中运行的窗口的消息。 例如，在 64 位操作系统上，记事本在 64 位进程中运行。 因此，可以使用 Spy++（64 位）来显示发送到记事本的消息。 详细的使用说明请见：https://blog.csdn.net/huang1600301017/article/details/138137
js导出excel封装【原生、配置式】 示例
04-23
导出excel示例
HTML2-iOs-App模板官网落地页APP主页产品宣传页源码 landing静态页面.zip
04-23
HTML2-iOs-App模板官网落地页APP主页产品宣传页源码 landing静态页面
围绕talib-ruby项目的更高级别的包装-Ruby
04-23
计算机技术是指评价计算机系统的各种知识和技能的总称。它涵盖了计算机硬件、软件、网络和信息安全等方面。计算机技术的发展使我们能够进行高效的数据处理、信息存储和传输。现代计算机技术包括操作系统、数据库管理、编程语言、算法设计等。同时，人工智能、云计算和大数据等新兴技术也在不断推动计算机技术的进步。计算机技术的应用广泛，涵盖了各个领域，如商业、医疗、教育和娱乐等。随着计算机技术的不断革新，我们可以更加高效地实现预期自动化、标准化
scala 是完全面向对象的语言吗
06-10
Scala 是一种混合了函数式编程和面向对象编程的编程语言。尽管 Scala 支持面向对象编程，但它并不是一种完全的面向对象编程语言。 Scala 中的函数是一等公民，可以像其他数据类型一样进行传递和操作。Scala 还支持...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值