偏函数、部分函数、模式匹配、伴生类伴生对象、抽象类

最新推荐文章于 2023-02-02 21:47:52 发布

qzc_root

最新推荐文章于 2023-02-02 21:47:52 发布

阅读量338

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/qzc_root/article/details/116165931

本文详细介绍了Scala编程中的偏函数、部分应用函数、模式匹配以及抽象类的概念和用法。通过示例展示了如何定义和使用偏函数进行类型匹配和部分应用，解释了模式匹配的多种方式，包括按值匹配、类型匹配、样例类匹配等。此外，还探讨了伴生类和伴生对象的特性，并给出了抽象类的定义和使用示例。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

偏函数

在Scala中，偏函数是具有类型PartialFunction[-T,+V]的一种函数。T是其接受的函数类型，V是其返回的结果类型

例子：传入String,返回Int

def funPartition:PartialFunction[String,Int]={
  case "hello"=>1
  case "word"=>0
  case _=>3
}
println(funPartition("kb11")) //3

例子：传入Int ,返回String

def funpart:PartialFunction[Int,String]={
  case 1=>"优秀"
  case 2=>"良好"
  case 3=>"合格"
  case _=>"渣渣"
}
println(funpart(4))
val arr:Array[Int] = Array(1,2,3,4,5)
//collect 并行计算偏函数得到一个新的数组
val strings:Array[String] = arr.collect(funpart)
//使用foreach对数组遍历
arr.collect(funpart).foreach(println)

在这里插入图片描述

def fuc:PartialFunction[String,Int]={
  case "male"=>1
  case "female"=>0
  case "男"=>1
  case "女"=>0
  case _=>2
}
val arr: Array[String] = Array("male","female","男","女","zzz")
arr.collect(fuc).foreach(println)

在这里插入图片描述

部分函数

部分应用函数（Partial Applied Function)是缺少部分参数的函数，是一个逻辑上概念。
def sum(x: Int, y: Int, z: Int) = x + y + z, 当调用sum的时候，如果不提供所有的参数，或者只提供某些参数时，比如sum _ , sum(3, _: Int, :Int), sum(: Int, 3, 4), 这样就生成了所谓的部分应用函数。

例子：

def sumResult(a:Int,b:Int):Int={
  a+b
}
println(sumResult(2,3))  //5
//部分函数
val num1: Int = 5
def sum: Int =>Int = sumResult(num1,_:Int)
println(sum(3))  //这里的3是传递给_:Int  8

def showMsg(title:String,content:String,height:Double):Unit ={
  println(s"$title $content $height")
}
showMsg("警告","当前河床水位线",19.1) //警告 当前河床水位线 19.1
val title: String = "警告"
val content: String = "当前河床水位线"
def showAlarm = showMsg(title,_:String,_:Double)
showAlarm("当前河床水位线",20.2) //警告 当前河床水位线 20.2
def showAlarm1 = showMsg(title,content,_:Double)
showAlarm1(20.1) //警告 当前河床水位线 20.1

模式匹配

match关键字用于定义模式匹配块，该块包含的情况使得如果匹配将执行一组表达式(代码块)

1、按值匹配

def match1(x:Int):String={
  x match{
    case 1 => "one"
    case 2 => "two"
    case _ => "many"
  }
}
println(match1(3)) //many

2、类型匹配

def match2(x:Any):Unit={
  x match{
    case 1=>println("内容为1")
    case x:Int => println(s"内容是整型，值为$x")
    case s:String => println(s"这是一个字符串，内容为$s")
    case _=> println("我不知道是什么")
  }
}
match2("3")   //这是一个字符串，内容为3

3、样例类

case class Teacher(name:String,age:Int)
def match3(teacher:Teacher):Unit ={
  teacher match{
    case Teacher(name,21) => println(name)
    case Teacher("gree",32) => println("hello gree teacher")
    case Teacher("kb11",6) => println("hello kb11")
    case x:Teacher => println("hello"+x.name)
  }
}
match3(Teacher("zzz",21)) //zzz
match3(Teacher("zzz",32)) //hellozzz

4、两个参数匹配

def match4(x:String,name:String):Unit={
  x match{
    case "a" => println("优秀")
    case "b" => println("良好")
    case "c" => println("及格")
    case _ if name=="bob"=> println("特殊学生")
    case _=> println("学习不及格")
  }
}
match4("d","bob")  //特殊学生

5、exception类型匹配

def match5(e:Exception):Unit={
  e match{
    case e1:IndexOutOfBoundsException => println("IndexOutOfBoundsException")
    case e2:NullPointerException => println("NullPointerException")
    case _:Exception => println("Exception")
  }
}
match5(new NullPointerException)   //NullPointerException

6、数组匹配

def match6(arr:Array[String]):Unit={
  arr match {
    case Array("kb11") => println("hello kb11")
    //元素以kb12开头的数组
    case Array("kb12",_*)=> println("kb12")
    case Array("bbb",_,"aaa")=> println("bbb")
    //匹配数组有两个元素
    case Array(a,b)=> println(a,b)
    case Array(_,_,"bbb",_*)=> println("kb13")
    case Array(str1,str2,"bbb",_*)=> println(str1,str2)
    case Array(_,_,"ccc",_*)=> println(arr(0),arr(1))
    case _=> println("who are you")
  }
}
match6(Array("bbb","kb13","aaa"))  //bbb
match6(Array("111","222","bbb"))   //kb13

7、样例类继承

class Person
case class Teacher(name:String,age:Int) extends Person
case class Worker(name:String,age:Int) extends Person
case class Student(name:String,age:Int) extends
Person
def match7(person:Person):Unit={
  person match{
  case Teacher(name,21)=>println(name)
  case Worker(name,age) if name=="repairWorker"=>println(s"修理工 $age")
  case person:Student if person.name=="xiaoxuesheng"=>println("祖国的花朵")
  case _=>println("不知道是谁")
  }
}
match7(Teacher("zzz",21))   //zzz
match7(Worker("repairWorker",21))//修理工 21
match7(Student("xiaoxuesheng",6))//祖国的花朵

伴生类伴生对象

class Oop1(name:String,age:String){//默认的构造方法
  println("--oop1 class one-----")
  println(name+age)
  //定义属性同时通过默认构造方法赋值
  var uname:String = name
  var uage: Int = age
  var uaddress:String = ""
  //一个参数的构造方法
  def this(name:String){
    this(name,1)
    println("oop1 构造方法")
  }
  //无参构造方法
  def this(){
   this("meiyou",1)
  }
  //三个参数构造方法
  def this(name:String,age:Int,address:String){
    this(name,age)
    uaddress = address
  }
  def showInfo():Unit ={
    println("进入class oop1中的showInfo方法")
    println("访问object oop1中的showInfo方法")
    Oop1.showInfo()
    println("访问object oop1中的showInfo方法结束")
    println("name:"+uname+"age:"+uage+"address:"+uaddress+"country"+Oop1.country)
  }
}
object Oop1{
  println("---oop1 object one------")
  val country:String="中国"
  def showInfo():Unit={
    println("---oop1 object three---")
    println("this is oop1 object")
  }
  println("---oop1 object two----")
  def apply(name:String,age:Int):Oop1 = new Oop1(name,age)
  def apply(name:String,age:Int,address:String):Oop1 = new Oop1(name,age,address)
  def main(args:Array[String]):Unit ={
    //伴生对象的方法
    Oop1.showInfo()  //第一次从头到尾执行一下
    Oop1.showInfo()  
    val oopDemo1 = new Oop1("kb11",6,"andemen")
    val oopObject = Oop1("wanglei",18)
    oopObject.showInfo()
  }
}

看一下执行顺序

单独执行
Oop1.showInfo() //第一次从头到尾执行一下
Oop1.showInfo() //第二次只是单纯调用了方法
在这里插入图片描述
单独执行 val oopDemo3 = new Oop1()

单独执行 val oopDemo1 = new Oop1(“kb11”,6)

单独执行 val oopDemo2 = new Oop1(“kb11”)

单独执行 var oopDemo4 = new Oop1(“kb11”,6,“andemen”)

执行
var oopDemo4 = new Oop1(“kb11”,6,“andemen”)
oopDemo4.showInfo()
在这里插入图片描述
执行
val kb1 = Oop1(“kb11”,3,“安德门”)
kb1.showInfo()

抽象类

package cn.kgc.kb11

abstract class Car {
  def brand:String
  def engine:String
  def laba():Unit={
    println("鸣笛")
  }
}
trait Type1{
  def wheele:String={
    println("四个轮子")
    "四个轮子"
  }
}
trait Type2{
  def fly():Unit ={
    println("飞上天空")
  }
  def downSea():Unit ={
    println("下海")
  }
}
trait balance{
  def balance:String
}
class BMW extends Car with Type1 with Type2 {
  override def brand: String = {
    println("BWM X6")
    return "BWM X6"
  }

  override def engine: String = {
    println("3.0T 自吸")
    return "3.0T 自吸"
  }
}
class LinYun extends Car(){
  override def brand: String = {
    println("凌云汽车")
    "凌云汽车"
  }

  override def engine: String = {
    println("电动汽车")
    "电动汽车"
  }
}

object CarTest{
  def main(args: Array[String]): Unit = {
//    val bwm = new BMW
//    bwm.brand
//    bwm.engine
//    bwm.laba()
//    bwm.wheele
//    bwm.fly()
//    bwm.downSea()
    //混入特质
    val lin:LinYun with Type1 with Type2 with balance= new LinYun with Type1 with Type2 with balance {
  override def balance: String = {
    println("两轮 平衡汽车")
    "两轮 平衡汽车"
  }
}
    lin.fly()
    lin.downSea()
    lin.brand
    lin.engine
    lin.wheele
    lin.balance
  }
}