偏函数
在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
}
}