Scala--04

news2024/11/19 5:37:11

第 8 章 高级语法

Scala
//需求：制作一个计算器，实现你传一个字符串给我，比如 2+3，然后我返回一个结果5给你
def plus(str: String): String = {
  var res = ""
  if (str.contains("+")) {
    val arr: Array[String] = str.split("\\+")
    val add1: Int = arr(0).toInt
    val add2: Int = arr(1).toInt
    res = add1 + add2 +""
  }else{
    res = "臣妾不会算了！"
  }
  res
}

//需求：加法已经不能满足我的需求了，我现在还要减法
def plus(str: String): String = {
  var res = ""
  if (str.contains("+")) {
    val arr: Array[String] = str.split("\\-")
    val add1: Int = arr(0).toInt
    val add2: Int = arr(1).toInt
    res = add1 - add2 +""
  }else{
    res = "臣妾不会算了！"
  }
  res
}

//需求：又过了两天，不行，你还得给我加上乘法和除法
 

8.1高阶函数(方法)

8.1.1函数可以作为参数进行传递和返回值进行返回

代码示例：

Scala
//传一个a乘b 就返回一个函数，逻辑是实现两数相乘
//传一个a*b 返回一个函数，逻辑是实现两数相乘
//传一个axb 返回一个函数，逻辑是实现两数相乘
def funTest6(str:String,fun:(String)=>Int):(Int,Int)=>Int = {
  val i: Int = fun(str)
  i match {
    case 0 => (a,b)=>a+b
    case 1 => (a,b)=>a-b
    case 2 => (a,b)=>a*b
    case 3 => (a,b)=>a/b
  }
}

val function: (Int, Int) => Int = funTest6("a*b", (s) => {
  if (s.contains("*") || s.contains("乘")) {
    2
  } else {
    0
  }
})

println(function(2, 3))

8.1.4匿名函数

没有名字的函数就是匿名函数。

例如：

(x:Int)=>{函数体}

x：表示输入参数类型；Int：表示输入参数类型；函数体：表示具体代码逻辑

传递匿名函数至简原则：

  1. 参数的类型可以省略，会根据形参进行自动的推导
  1. 类型省略之后，发现只有一个参数，则圆括号可以省略；其他情况：没有参数和参数超过 1 的永远不能省略圆括号。
  1. 匿名函数如果只有一行，则大括号也可以省略
  1. 如果参数只出现一次，则参数省略且后面参数可以用_代替

练习1：传递的函数有一个参数

代码示例：

Scala
def main(args: Array[String]): Unit = {
 // （1）定义一个函数：参数包含数据和逻辑函数
def operation(arr: Array[Int], op: Int => Int): Array[Int] = {
  for (elem <- arr) yield op(elem)
}
 // （2）定义逻辑函数
 def op(ele: Int): Int = {
 ele + 1
 }
 // （3）标准函数调用
 val arr = operation(Array(1, 2, 3, 4), op)
 println(arr.mkString(","))
 
 
 // （4）采用匿名函数
 val arr1 = operation(Array(1, 2, 3, 4), (ele: Int) => {
 ele + 1
 })
 println(arr1.mkString(","))
 
 
 
 // （4.1）参数的类型可以省略，会根据形参进行自动的推导;
 val arr2 = operation(Array(1, 2, 3, 4), (ele) => {
 ele + 1
 })
 println(arr2.mkString(","))
 
 
 
 // （4.2）类型省略之后，发现只有一个参数，则圆括号可以省略；其他情
况：没有参数和参数超过 1 的永远不能省略圆括号。
 val arr3 = operation(Array(1, 2, 3, 4), ele => {
 ele + 1
 })
 println(arr3.mkString(","))
 
 
 
 // (4.3) 匿名函数如果只有一行，则大括号也可以省略
 val arr4 = operation(Array(1, 2, 3, 4), ele => ele + 1)
 println(arr4.mkString(","))
 //（4.4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 val arr5 = operation(Array(1, 2, 3, 4), _ + 1)
 println(arr5.mkString(","))
 
 }
}

练习二：传递的函数有两个参数

代码示例：

Scala
object TestFunction {
 def main(args: Array[String]): Unit = {
 def calculator(a: Int, b: Int, op: (Int, Int) => Int): Int
= {
 op(a, b)
 }
 // （1）标准版
 println(calculator(2, 3, (x: Int, y: Int) => {x + y}))
 // （2）如果只有一行，则大括号也可以省略
 println(calculator(2, 3, (x: Int, y: Int) => x + y))
 // （3）参数的类型可以省略，会根据形参进行自动的推导;
 println(calculator(2, 3, (x , y) => x + y))
 // （4）如果参数只出现一次，则参数省略且后面参数可以用_代替
 println(calculator(2, 3, _ + _))
 }
}

扩展练习

练习 1：

定义一个匿名函数，并将它作为值赋给变量 fun。函数有三个参数，类型分别为 Int，String，Char，返回值类型为 Boolean。要求调用函数 fun(0, “”, ‘0’)得到返回值为 false，其它情况返回true。

Scala
val fun = (a:String,b:Int,c:Char)=>{
  if(a == "" && b == 0 && c == '0'){
    false
  }else{
    true
  }
}

println(fun("",0,'0'))

练习 2：

定义一个函数 func，它接收一个 Int 类型的参数，返回一个函数（记作 f1）。它返回的函数 f1，接收一个 String 类型的参数，同样返回一个函数（记作 f2）。函数 f2 接收一个 Char 类型的参数，返回一个 Boolean 的值。要求调用函数 func(0) (“”) (‘0’)得到返回值为 false，其它情况均返回 true。

Scala
private val func: Int => String => Char => Boolean = (i: Int) => {
  val f1 = (s: String) => {
    val f2 = (c: Char) => {
      if (i == 0 && s == "" && c == '0') {
        false
      } else {
        true
      }
    }
    f2
  }
  f1
}

8.2偏函数

偏函数是一个特质 ,用来专门处理某种数据类型! [注意可以同时处理多种数据类型]

8.2.1偏函数的定义：

Scala
val second: PartialFunction[List[Int], Option[Int]] = {
     case x :: y :: _ => Some(y)
}

注：该偏函数的功能是返回输入的 List 集合的第二个元素

案例：将集合中的所有的Int类型的数据都加上1

代码示例：

Scala
 //  方式一   过滤器形式
 val list = List(1, 2, 3, 4, "hello")
 val res: List[Int] = list.filter(x => x.isInstanceOf[Int]).map(x => x.asInstanceOf[Int] + 1)
 res.foreach(println)
 
 // 方式二   匹配模式
 val res2: List[Any] = list.map(x => x match {
   case x: Int => x + 1
   case _ =>
   })
 res2.filter(x => x.isInstanceOf[Int]).foreach(println)
 
 // 方式三  使用偏函数  泛型1 输入的数据类型 泛型2 要处理的数据类型
 val pp = new PartialFunction[Any,Int] {
   // 返回true
   override def isDefinedAt(x: Any) = {
     x.isInstanceOf[Int]
   }
   // 执行下一个方法
   override def apply(v1: Any) = {
     v1.asInstanceOf[Int]+1
   }
 }
 
   //  list.map(pp).foreach(println)
  list.collect(pp).foreach(println)
 

8.2.2偏函数原理

上述代码会被 scala 编译器翻译成以下代码，与普通函数相比，只是多了一个用于参数检查的函数——isDefinedAt，其返回值类型为 Boolean。

Scala
val second = new PartialFunction[List[Int], Option[Int]] {
 //检查输入参数是否合格
 override def isDefinedAt(list: List[Int]): Boolean = list match
{
 case x :: y :: _ => true
 case _ => false
 }
 //执行函数逻辑
 override def apply(list: List[Int]): Option[Int] = list match
{
 case x :: y :: _ => Some(y)
 }
}

8.2.3偏函数的执行流程

  1. 遍历list中的每个元素
  1. 调用 val e =  if (isDefinedAt) {apply}
  1. 每得到一个e 就会将e存储在一个新的集合中返回使用偏函数就不要使用map方法了

8.2.4偏函数的简写形式

Scala
val list = List(2, 4, 6, 8, "cat")

//定义一个偏函数
def myPartialFunction: PartialFunction[Any, Int] = {
  case x: Int => x * x
}
list.collect(myPartialFunction).foreach(println)
// 简写方式
list.collect({
  case x:Int=>x*x
}).foreach(println)

8.2.5偏函数总结

  1. 使用构建特质的实现类(使用的方式是PartialFunction的匿名子类)
  1. PartialFunction 是个特质(看源码)
  1. 构建偏函数时，参数形式 [Any, Int]是泛型，第一个表示参数类型，第二个表示返回参数
  1. 当使用偏函数时，会遍历集合的所有元素，编译器执行流程时先执行isDefinedAt()如果为true ,就会执行 apply, 构建一个新的Int 对象返回
  1. 执行isDefinedAt() 为false 就过滤掉这个元素，即不构建新的Int对象.
  1. map函数不支持偏函数，因为map底层的机制就是所有循环遍历，无法过滤处理原来集合的元素
  1. collect函数支持偏函数

8.3模式匹配

模式匹配语法中，采用 match 关键字声明，每个分支采用 case 关键字进行声明，当需要匹配时，会从第一个 case 分支开始，如果匹配成功，那么执行对应的逻辑代码，如果匹配不成功，继续执行下一个分支进行判断。如果所有 case 都不匹配，那么会执行 case _分支，类似于 Java 中 default 语句。

8.3.1基本语法

Scala
object TestMatchCase {
 def main(args: Array[String]): Unit = {
 var a: Int = 10
 var b: Int = 20
 var operator: Char = 'd'
 var result = operator match {
 case '+' => a + b
 case '-' => a - b
 case '*' => a * b
 case '/' => a / b
 case _ => "illegal"
  }
 println(result)
 }
}

说明：

  1. 如果所有 case 都不匹配，那么会执行 case _ 分支，类似于 Java 中 default 语句，若此时没有 case _ 分支，那么会抛出 MatchError。
  1. 每个 case 中，不需要使用 break 语句，自动中断 case。
  1. match case 语句可以匹配任何类型，而不只是字面量。
  1. => 后面的代码块，直到下一个 case 语句之前的代码是作为一个整体执行，可以使用{}括起来，也可以不括。

8.3.2模式守卫

如果想要表达匹配某个范围的数据，就需要在模式匹配中增加条件守卫。

代码演示：

Scala
object TestMatchGuard {
 def main(args: Array[String]): Unit = {
 def abs(x: Int) = x match {
 case i: Int if i >= 0 => i
 case j: Int if j < 0 => -j
 case _ => "type illegal"
 }
 println(abs(-5))
 }
}

8.3.3 模式匹配类型

8.3.3.1 匹配常量

Scala 中，模式匹配可以匹配所有的字面量，包括字符串，字符，数字，布尔值等等

代码演示：

Scala
object TestMatchVal {
 def main(args: Array[String]): Unit = {
 println(describe(6))
 }
 def describe(x: Any) = x match {
 case 5 => "Int five"
 case "hello" => "String hello"
 case true => "Boolean true"
 case '+' => "Char +"
 }
}

8.3.3.2匹配类型

需要进行类型判断时，可以使用前文所学的 isInstanceOf[T]和 asInstanceOf[T]，也可使用模式匹配实现同样的功能。

代码实现：

Scala
object TestMatchClass {
 def describe(x: Any) = x match {
 case i: Int => "Int"
 case s: String => "String hello"
 case m: List[_] => "List"
 case c: Array[Int] => "Array[Int]"
 case someThing => "something else " + someThing
 }
 def main(args: Array[String]): Unit = {
    println(describe(List(1, 2, 3, 4, 5)))
    println(describe(Array(1, 2, 3, 4, 5, 6)))
    println(describe(Array("abc")))
 }
}

8.3.3.3匹配数组

scala 模式匹配可以对集合进行精确的匹配，例如匹配只有两个元素的、且第一个元素为 0 的数组

代码实现：

Scala
object TestMatchArray {
 def main(args: Array[String]): Unit = {
 for (arr <- Array(Array(0), Array(1, 0), Array(0, 1, 0),
Array(1, 1, 0), Array(1, 1, 0, 1), Array("hello", 90))) { // 对
一个数组集合进行遍历
 val result = arr match {
 case Array(0) => "0" //匹配 Array(0) 这个数组
 case Array(x, y) => x + "," + y //匹配有两个元素的数组，然后将将元素值赋给对应的 x,y
 case Array(0, _*) => "以 0 开头的数组" //匹配以 0 开头和
数组
 case _ => "something else"
 }
 println("result = " + result)
 }
 }

8.3.3.4匹配列表

方式一代码实现：

Scala
object TestMatchList {
 def main(args: Array[String]): Unit = {
 //list 是一个存放 List 集合的数组
 //请思考，如果要匹配 List(88) 这样的只含有一个元素的列表,并原值返回.应该怎么写
 for (list <- Array(List(0), List(1, 0), List(0, 0, 0), List(1,
0, 0), List(88))) {
 val result = list match {
 case List(0) => "0" //匹配 List(0)
 case List(x, y) => x + "," + y //匹配有两个元素的 List
 case List(0, _*) => "0 ..."
 case _ => "something else"
 }
 println(result)
 }
 }
}

方式二代码实现：

Scala
object TestMatchList {
 def main(args: Array[String]): Unit = {
 val list: List[Int] = List(1, 2, 5, 6, 7)
 list match {
 case first :: second :: rest => println(first + "-" +
second + "-" + rest)
 case _ => println("something else")
  }
 }
}

8.3.3.5匹配元组

代码实现：

Scala
object TestMatchTuple {
 def main(args: Array[String]): Unit = {
 //对一个元组集合进行遍历
 for (tuple <- Array((0, 1), (1, 0), (1, 1), (1, 0, 2))) {
 val result = tuple match {
 case (0, _) => "0 ..." //是第一个元素是 0 的元组
 case (y, 0) => "" + y + "0" // 匹配后一个元素是 0 的对偶元组
 case (a, b) => "" + a + " " + b
 case _ => "something else" //默认
 }
 println(result)
 }
 }
}

扩展案例

Scala
 object TestGeneric {
 def main(args: Array[String]): Unit = {
 //特殊的模式匹配 1 打印元组第一个元素
 for (elem <- Array(("a", 1), ("b", 2), ("c", 3))) {
 println(elem._1)
 }
 for ((word,count) <- Array(("a", 1), ("b", 2), ("c", 3))) {
 println(word)
 }
 for ((word,_) <- Array(("a", 1), ("b", 2), ("c", 3))) {
 println(word)
 }
 for (("a",count) <- Array(("a", 1), ("b", 2), ("c", 3))) {
 println(count)
 }
 println("--------------")
 //特殊的模式匹配 2 给元组元素命名
 var (id,name,age): (Int, String, Int) = (100, "zs", 20)
 println((id,name,age))
 println("--------------")
 //特殊的模式匹配 3 遍历集合中的元组，给 count * 2
 var list: List[(String, Int)] = List(("a", 1), ("b", 2), ("c", 3))
 //println(list.map(t => (t._1, t._2 * 2)))
 println(
 list.map{
 case (word,count)=>(word,count*2)
 }
 )
 var list1 = List(("a", ("a", 1)), ("b", ("b", 2)), ("c", ("c", 3)))
 println(
 list1.map{
 case (groupkey,(word,count))=>(word,count*2)
 }
 )
 }
}

8.3.3.6匹配对象及样例类

代码示例：

Scala
class User(val name: String, val age: Int)
object User{
 def apply(name: String, age: Int): User = new User(name, age)
 def unapply(user: User): Option[(String, Int)] = {
 if (user == null)
 None
 else
 Some(user.name, user.age)
 }
}
object TestMatchUnapply {
 def main(args: Array[String]): Unit = {
 val user: User = User("zhangsan", 11)
 val result = user match {
 case User("zhangsan", 11) => "yes"
 case _ => "no"
 }
 println(result)
 }
}

小结

  1. val user = User("zhangsan",11)，该语句在执行时，实际调用的是 User 伴生对象中的apply 方法，因此不用 new 关键字就能构造出相应的对象。
  1. 当将 User("zhangsan", 11)写在 case 后时[case User("zhangsan", 11) => "yes"]，会默认调用 unapply 方法(对象提取器)，user 作为 unapply 方法的参数，unapply 方法将 user 对象的 name 和 age 属性提取出来，与 User("zhangsan", 11)中的属性值进行匹配
  1. case 中对象的 unapply 方法(提取器)返回 Some，且所有属性均一致，才算匹配成功,属性不一致，或返回 None，则匹配失败。
  1. 若只提取对象的一个属性，则提取器为 unapply(obj:Obj):Option[T]，若提取对象的多个属性，则提取器为 unapply(obj:Obj):Option[(T1,T2,T3…)]，若提取对象的可变个属性，则提取器为 unapplySeq(obj:Obj):Option[Seq[T]]

8.4函数柯里化&闭包

8.4.1闭包定义：

闭包：如果一个函数,访问到了它的外部（局部）变量的值，那么这个函数和他所处的环境,称为闭包

代码示例：

Scala
package cn.doitedu.data_export

import org.apache.commons.lang3.RandomUtils
object CloseTest {
  def main(args: Array[String]): Unit = {
    val fx = (a:Int,b:Int)=>{
      a+b
    }

    val fxx = (a:Int) => {
      (b:Int)=>a+b
    }

    val res = fxx(3)(10)

    val f = () => {
      var p = RandomUtils.nextInt(1,10)

      val inner = () => {
        p += 1
        p
      }
      inner
    }

    val x1= f()
    println(x1())
    println(x1())

    println("-----------")

    val x2 = f()
    println(x2())
    println(x2())
    println(x2())
  }
}

8.4.2柯里划函数的定义：

函数柯里化：把一个参数列表的多个参数,变成多个参数列表。

意义: 方便数据的演变, 后面的参数可以借助前面的参数推演 , foldLeft的实现

有多个参数列表的函数就是柯里化函数，所谓的参数列表就是使用小括号括起来的函数参数列表

curry化最大的意义在于把多个参数的function等价转化成多个单参数function的级联，这样所有的函数就都统一了，方便做lambda演算。 在scala里，curry化对类型推演也有帮助，scala的类型推演是局部的，在同一个参数列表中后面的参数不能借助前面的参数类型进行推演，curry化以后，放在两个参数列表里，后面一个参数列表里的参数可以借助前面一个参数列表里的参数类型进行推演。这就是为什么 foldLeft这种函数的定义都是curry的形式

8.5惰性加载

当函数返回值被声明为 lazy 时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。这种函数我们称之为惰性函数。

代码示例：

Scala
def main(args: Array[String]): Unit = {
 lazy val res = sum(10, 30)
 println("----------------")
 println("res=" + res)
}
def sum(n1: Int, n2: Int): Int = {
 println("sum 被执行。。。")
 return n1 + n2
}

运行结果：
----------------
sum 被执行。。。
res=40

注意：lazy 不能修饰 var 类型的变量

8.6隐式转换

8.6.1隐式函数

隐式转换可以在不需改任何代码的情况下，扩展某个类的功能

练习：通过隐式转化为 Int 类型增加方法。

Scala
//创建一个隐式方法，在def 前面加上关键字 implicit  让一个类型具有更加丰富的功能
implicit def stringWrapper(str:String)={
  new MyRichString(str)
}

class MyRichString(val str:String){
  def fly()={
    println(str+",我是字符串，我能飞！！")
  }

  def jump()={
    str + ":我能跳！"
  }
}

package com.doit.day02
import com.doit.day01.AnythingElse.Else._
/**
 * 隐式转换：说白了就是给一个函数，参数，类 赋予更加强大的功能
 */
object _10_隐式转换 {
  def main(args: Array[String]): Unit = {
    //1 本身是int 类型的，但是他却可以调用richInt这个类里面的方法
    /**
     *  implicit def intWrapper(x: Int)= {
     *  //相当于创建了一个 RichInt的对象
     *    new runtime.RichInt(x)
     *  }
     *  我写了一个隐式方法，传进去一个参数，返回给我的是一个对象， 并且在这个方法最前面加上了implicit 关键字 ，那么
     *  这个参数的类型 就具备了该类的方法
     */
    val str: String = "zss"
    str.fly()
  }
}

8.6.2隐式参数

普通方法或者函数中的参数可以通过 implicit 关键字声明为隐式参数，调用该方法时，

就可以传入该参数，编译器会在相应的作用域寻找符合条件的隐式值

说明：

  1. 同一个作用域中，相同类型的隐式值只能有一个
  1. 编译器按照隐式参数的类型去寻找对应类型的隐式值，与隐式值的名称无关。
  1. 隐式参数优先于默认参数

代码示例：

Scala
//定义了一个方法，方法中的参数设置的是隐式参数
def add(implicit a: Int, b: String) = {
  a + b.toInt
}

//定义两个变量，前面用implicit  修饰  变成隐式的
implicit val a:Int = 10
implicit val b:String = "20"

//调用方法的时候，如果没有传参数，那么他会去上下文中找是否又隐式参数，如果有
//他就自己偷偷的传进去了，如果没有，会直接报错
add

8.6.3隐式类

在 Scala2.10 后提供了隐式类，可以使用 implicit 声明类，隐式类的非常强大，同样可

以扩展类的功能，在集合中隐式类会发挥重要的作用。

说明：

  1. 其所带的构造参数有且只能有一个
  1. 隐式类必须被定义在“类”或“伴生对象”或“包对象”里，即隐式类不能是顶级的。

代码示例：

Scala
implicit class snake(ant:Ant){
  def eatElephant()={
    println("i can eat elephant!!")
  }
}

val ant: Ant = new Ant
ant.eatElephant()

8.6.4隐式解析机制

  1. 首先会在当前代码作用域下查找隐式实体（隐式方法、隐式类、隐式对象）。
  1. 如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找。类型的作用域是指与该类型相关联的全部伴生对象以及该类型所在包的包对象。

代码示例：

Scala
package com.chapter10
import com.chapter10.Scala05_Transform4.Teacher
//（2）如果第一条规则查找隐式实体失败，会继续在隐式参数的类型的作用域里查找。
类型的作用域是指与该类型相关联的全部伴生模块，
object TestTransform extends PersonTrait {
 def main(args: Array[String]): Unit = {
 //（1）首先会在当前代码作用域下查找隐式实体
 val teacher = new Teacher()
 teacher.eat()
 teacher.say()
 }
 class Teacher {
 def eat(): Unit = {
 println("eat...")
 }
 }
}
trait PersonTrait {
}
object PersonTrait {
 // 隐式类 : 类型 1 => 类型 2
 implicit class Person5(user:Teacher) {
 def say(): Unit = {
 println("say...")
 }
 }
}

8.7泛型

8.7.1泛型的定义

Scala
object _11_泛型 {
  def main(args: Array[String]): Unit = {
    //[A]  这个代表的就是泛型  ==》 在创建对象的时候，可以指定需要传进去的类型
    //作用就是在创建对象的时候，可以对传进去的参数一个约束，当设置泛型位int之后，那么传进去的值就必须是int
    //apply[A](xs: A*): List[A] = xs.toList
    val ints: List[Int] = List[Int](1, 2, 3, 4)

    //自己写一个？  单纯演示泛型语法的定义，没有什么实际的意义
    /**
     * 将泛型定义在类上，那么在整个类中，都可以使用该泛型，作用域是整个类
     * @tparam T
     */
    class TestFanXin[T](){
      def max(a:T,b:T)= a
    }
    //如果设置泛型位Int类型，那么方法的参数就只能传Int类型
    new TestFanXin[Int]().max(1,2)
    //如果设置泛型位String类型，那么方法的参数就只能传String类型
    new TestFanXin[String]().max("aa","bb")

    /**
     * 泛型也可以定义在方法上，如果定义在方法上，那么该泛型的作用域只能作用在该方法中
     * 出了该方法便不能生效
     */
    class TestFanXin1(){
      def max[T](a:T,b:T)= a
      def min[A](a:A,b:A)= b
    }
  }
}

8.7.2泛型上下限

泛型的上下限的作用是对传入的泛型进行限定。

语法：

Scala
//泛型上限  只能够传Person 这个类和他的的子类
Class PersonList[T <: Person]{
}
//泛型下限 只能够传Person 这个类和他的的父类
Class PersonList[T >: Person]{
}

代码示例：

Scala
package com.doit.day02


object _12_泛型的上下限 {
  def main(args: Array[String]): Unit = {

    def sayHi[A <: Father](a:A): Unit ={
      println("test")
    }

    def sayHello[A >: Father](a:A): Unit ={
      println("test")
    }

    //调用sayHi的时候，传进去的参数因为有泛型的上界约定，所以只能传入Father和Father的子类
    sayHi(new Son())
    sayHi(new Father())
    //这边编译的时候虽然不报错，但是运行的时候会报错
//    sayHi(new GrandFather())

    //如果泛型是定义在方法上的，如果没有加泛型，是限制不住的，但是加了泛型，还是可以限制住的
//    sayHello[ABC](new ABC)
//    sayHello[Son](new Son)
    sayHello(new Father)
    sayHello(new GrandFather)


    class Test[A >:Father]{
      def sayHi(a:A) ={
        println("hello")
      }
    }

    new Test[Father].sayHi(new Father)
    //如果定义在类上的话，就能约束住了
//    new Test[Son].sayHi(new Son)
    new Test[GrandFather].sayHi(new GrandFather)




  }
}

class Son extends Father

class Father extends GrandFather

class GrandFather

class ABC

8.7.3视图限定

约束本质：存在一个隐式转换，能够将T类型转换成B类型

泛型视图限定：T <% B

Scala
package com.doit.day02

object _13_视图限定 {
  def main(args: Array[String]): Unit = {

    class Bird(val name:String){
      def fly()={println(name + "飞走了")}
    }

    class ToyBird

    def bitBird[T <% Bird](b:T)=b.fly()

    bitBird[Bird](new Bird("小鸟"))

    implicit def toy2Bird(toyBird: ToyBird)= new Bird("玩具鸟")

    bitBird[ToyBird](new ToyBird)
  }
}

8.7.4上下文限定

上下文限定是将泛型和隐式转换的结合产物，以下两者功能相同，使用上下文限定[A : Ordering]之后，方法内无法使用隐式参数名调用隐式参数，需要通过 implicitly[Ordering[A]]获取隐式变量，如果此时无法查找到对应类型的隐式变量，会发生出错误。

Scala
implicit val x = 1
val y = implicitly[Int]
val z = implicitly[Double]

语法：

Scala
def f[A : B](a: A) = println(a)
//等同于 def f[A](a:A)(implicit arg:B[A])=println(a)

代码示例：

Scala
package com.doit.day02

object _14_上下文界定 {
  def main(args: Array[String]): Unit = {

    /**
     * 泛型的上下文界定
     */

    case class Tiger(age:Int,weight:Int)
    case class Cat(age:Int,weight:Int)
    //我想比较两个老虎的大小  单纯的老虎，没有实现compare方法的话，是没有办法调用compare来比较的
    //两个办法，第一个办法，在类上实现Ordered 特质，重写 compareTo方法
    //第二个方法，传一个比较器进去，这样他们就可以用比较器来比较了
    def bigger(tiger: Tiger,tiger1:Tiger,cmp:Ordering[Tiger]):Tiger={
      if (cmp.compare(tiger,tiger1)> 0) tiger else tiger1
    }

    //上面这种方法确实是可以比较，但是只能比较老虎，我想比较个猫好像就比较不了了
    //想比较猫，得重新在写一个
    def bigger1(cat: Cat,cat1:Cat,cmp:Ordering[Cat]):Cat={
      if (cmp.compare(cat,cat1)> 0) cat else cat1
    }

    //不过回头想比较狗狗，又要写一个，比较麻烦，不通用
    //这时候就可以定义泛型了
    def bigger2[T](t: T,t1:T,cmp:Ordering[T]):T={
      if (cmp.compare(t,t1)> 0) t else t1
    }

    //方法的调用  这样是没什么问题的
    //但是在马大爷眼里，这么写代码，多low啊，不符合马大爷的气质，他就开始搞事情了
    bigger2[Cat](Cat(10,100),Cat(20,80),new Ordering[Cat] {
      override def compare(x: Cat, y: Cat) = x.age - y.age
    })

    //咱们不是有隐式转换嘛，能不能把这个比较器呢？
    //我上下文中找找，有没有什么隐式的比较器可以拿过来用，如果有我就直接拿过来，这样就不用传比较器了，去偷一个不香嘛
    //bigger3[T :Ordering]  注意：如果想让他自己偷一个，那么需要实现上下文界定，不然是没办法使用的
    def bigger3[T :Ordering](t: T,t1:T):T={
      if(implicitly[Ordering[T]].compare(t,t1)>0) t else t1
    }

    /**
     * 两种创建隐式比较器对象的写法
     */
    //    implicit val value: Ordering[Cat] = new Ordering[Cat] {
//      override def compare(x: Cat, y: Cat) = x.age - y.age
//    }

    implicit val value1 = Ordering.by[Cat,Int](cat=>cat.age)

    bigger3[Cat](Cat(10,100),Cat(20,80))
  }
}

8.7.5逆变，协变，不变

语法：

不变：默认
协变： +T
逆变： -T

Scala
package com.doit.day02

/**
 *
 * 不变：默认
 * 协变： +T
 * 逆变： -T
 */
object _15_逆变协变不变 {
  def main(args: Array[String]): Unit = {

    class Box[T](t:T)
    class Pencil
    class YZPencil extends Pencil

    /**
     * 本身我的pencil 和YZpencil 是父子关系
     * 那么按照常理来说，我装笔的盒子也是圆珠笔的盒子的父类，这样的话咱们能够理解
     * 我盒子既然能装笔，而且圆珠笔又是笔的父类，所以我这个盒子应该能装圆珠笔
     * 毕竟有多态的存在，我的笔本身可以接收圆珠笔的 ==>理解 ?
     */
    val box1: Box[Pencil] = new Box[Pencil](new Pencil)
    val box2: Box[YZPencil] = new Box[YZPencil](new YZPencil)
    //但是在代码中，却不能这么操作  虽然圆珠笔和笔存在父子关系，但是一旦把他们装在盒子中，就不存在这样的关系了
    //这种的关系我们称他为不变
//    val box3: Box[Pencil] = new Box[YZPencil](new YZPencil)  //报错

    //如果想让他们依然有关系，可以的，scala给我提供了另外一种方式叫协变和逆变
    class Box1[+T](t:T)
    class Pencil1
    class YZPencil1 extends Pencil1
    //本身圆珠笔是笔的子类，加上了协变这么一个操作  那么装笔的盒子就是装圆珠笔的父类了
    val box3: Box1[Pencil1] = new Box1[YZPencil1](new YZPencil1)


    // 逆变
    //如果想让他们依然有关系，可以的，scala给我提供了另外一种方式叫协变和逆变
    class Box2[-T](t:T)
    class Pencil2
    class YZPencil2 extends Pencil2
    //本身圆珠笔是笔的子类，加上了逆变这么一个操作  那么装笔的盒子就是装圆珠笔的子类了(父子关系颠倒过来了)
    val box4: Box2[YZPencil2] = new Box2[Pencil2](new Pencil2)

  }

}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/654127.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Halcon 循环找出多张电路板上的焊盘 (PCB板的有效区域在图中位置不一样)

Halcon 循环找出多张电路板上的焊盘 (PCB板的有效区域在图中位置不一样)

文章目录 1 问题描述2 关键代码演示2.1 缩减范围，提高效率2.2 求差，去掉矩形块，只剩下圆3.3 最终效果3 完整代码1 问题描述 如图，循环找出下面四张电路板上的 焊盘； 四张图的有效区域在图中的位置不一样； 且图中还有和焊盘区域相近的矩形黑块； 为了提高效率，先找到产…
阅读更多...
[数据分析与可视化] Python绘制数据地图3-GeoPandas使用要点

[数据分析与可视化] Python绘制数据地图3-GeoPandas使用要点

本文主要介绍GeoPandas的使用要点。GeoPandas是一个Python开源项目&#xff0c;旨在提供丰富而简单的地理空间数据处理接口。GeoPandas扩展了Pandas的数据类型&#xff0c;并使用matplotlib进行绘图。GeoPandas官方仓库地址为&#xff1a;GeoPandas。GeoPandas的官方文档地址为…
阅读更多...
模糊聚类在负荷实测建模中的应用(Matlab代码实现)

模糊聚类在负荷实测建模中的应用(Matlab代码实现)

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
Python如何把列表自定义分组后并重复2次

Python如何把列表自定义分组后并重复2次

一、问题的由来 之前&#xff0c;我写过一篇调用同花顺机器翻译api&#xff0c;批量翻译字幕的文章。 在调用机器翻译api过程中&#xff0c;我遇到一个问题&#xff0c;就是网站给的Python样例代码中只接收字符长度少于5000的列表&#xff0c;所以我想&#xff0c;如果我们一…
阅读更多...
Docker常用命令（+仓库，镜像，容器的关系）

Docker常用命令（+仓库，镜像，容器的关系）

一、仓库&#xff08;repository&#xff09;&#xff0c;镜像&#xff08;image&#xff09;&#xff0c;容器&#xff08;container&#xff09;的关系 Docker 是一个开源的C/S架构应用容器引擎&#xff08;客户端&#xff08;client&#xff09;和服务端&#xff08;server&…
阅读更多...
Android实现一个可拖拽带有坐标尺的进度条

Android实现一个可拖拽带有坐标尺的进度条

拿到上边的UI效果图&#xff0c;给我的第一印象就是这实现起来也太简单了吧&#xff0c;SeekBar轻轻松松就搞定了&#xff0c;换个thumb&#xff0c;加个渐变不就完成了&#xff0c;说搞就搞&#xff0c;搞着搞着就抑郁了&#xff0c;底部坐标尺还能搞&#xff0c;等比例分割后…
阅读更多...
Springboot开发微信小游戏后台-玩家登录流程

Springboot开发微信小游戏后台-玩家登录流程

最近使用Springboot开发了一个微信小游戏的后台服务&#xff0c;为小游戏提供接口&#xff0c;其中登录需要前后端与微信服务端配合。 注意使用自己开发的服务作为小游戏后端&#xff0c;前提条件是必须要有域名证书&#xff0c;提供https服务&#xff0c;否则在微信正式环境下…
阅读更多...
QT Creator写一个简单的电压电流显示器

QT Creator写一个简单的电压电流显示器

前言 本文主要涉及上位机对接收的串口数据处理&#xff0c;LCD Number控件的使用。之前的一篇写一个简单的LED控制主要是串口发出数据&#xff0c;这里再看一下怎么接收数据处理数据&#xff0c;这样基本就对串口上位机有简单的认识了。 LCD Number显示时间 这一小节通过用一…
阅读更多...
从实现到原理，我总结了11种延迟任务的实现方式

从实现到原理，我总结了11种延迟任务的实现方式

延迟任务在我们日常生活中比较常见&#xff0c;比如订单支付超时取消订单功能&#xff0c;又比如自动确定收货的功能等等。 所以本篇文章就来从实现到原理来盘点延迟任务的11种实现方式&#xff0c;这些方式并没有绝对的好坏之分&#xff0c;只是适用场景的不大相同。 DelayQu…
阅读更多...
【python】js逆向基础案例——有道翻译

【python】js逆向基础案例——有道翻译

前言 嗨喽&#xff0c;大家好呀~这里是爱看美女的茜茜呐 课程亮点: 1、爬虫的基本流程 2、反爬的基本原理 3、nodejs的使用 4、抠代码基本思路 环境介绍: python 3.8 pycharm 2022专业版 >>> 免费使用教程文末名片获取 requests >>> pip install req…
阅读更多...
Vue 配置正向代理的使用

Vue 配置正向代理的使用

浏览器对于用户的安全考虑&#xff0c;设置了同源策略。同源策略就是指协议、域名、端口都要相同的情况下&#xff0c;才能请求资源。 跨域&#xff1a; 跨域指的是&#xff1a;在浏览器中&#xff0c;从一个域名去请求另一个域名的资源时&#xff0c;如果协议、域名、端口任意…
阅读更多...
深入理解 SpringBoot 日志框架：从入门到高级应用——（六）Log4j2 输出日志到 QQ邮箱

深入理解 SpringBoot 日志框架：从入门到高级应用——（六）Log4j2 输出日志到 QQ邮箱

文章目录 获取 QQ 邮箱授权码添加依赖编写 SMTPAppender运行结果 要实现将 log4j2 输出日志到 QQ 邮箱&#xff0c;需按照以下步骤进行&#xff1a; 在 QQ 邮箱中设置 SMTP 服务&#xff0c;开启 POP3/SMTP 服务&#xff0c;获取 SMTP 服务地址、端口号、登录邮箱账号和密码。 …
阅读更多...
拿捏指针（二）---对指针的进阶认识（中级）

拿捏指针（二）---对指针的进阶认识（中级）

文章目录 字符指针指针数组数组指针数组指针的定义&数组名与数组名的区别数组指针的使用 数组参数、指针参数一维数组传参二维数组传参一级指针传参二级指针传参 字符指针 我们知道&#xff0c;在指针的类型中有一种指针类型叫字符指针char * 。 字符指针的一般使用方法为…
阅读更多...
Pytest自动化测试的三种运行方式

Pytest自动化测试的三种运行方式

目录 1、主函数模式 2、命令行模式 3、通过读取pytest ini配置文件运行 &#xff08;最主要运用的方式&#xff09; 总结&#xff1a; Pytest 运行方式共有三种&#xff1a; 1、主函数模式 运行所有 pytest.main() 指定模块 pytest.main([-vs],,./testcase/test_day1.py)…
阅读更多...
组合逻辑电路设计---多路选择器

组合逻辑电路设计---多路选择器

目录 1、多路选择器简介 2、硬件设计 3、实验任务 4、程序设计 4.1、模块设计 4.2、绘制波形图 4.3、编写代码 &#xff08;1&#xff09;assign 中条件运算符&#xff08;三目运算符&#xff09;实现方法&#xff1a; &#xff08;2&#xff09;always 语句块中使用 …
阅读更多...
逍遥自在学C语言 | 指针的基础用法

逍遥自在学C语言 | 指针的基础用法

前言 在C语言中&#xff0c;指针是一项重要的概念&#xff0c;它允许我们直接访问和操作内存地址。 可以说&#xff0c;指针是C语言一大优势。用得好&#xff0c;你写程序如同赵子龙百万军中取上将首级&#xff1b;用得不好&#xff0c;则各种问题层出不穷&#xff0c;有种双…
阅读更多...
.gitignore 忽略文件和目录

.gitignore 忽略文件和目录

1. .gitignore 简介2. .gitignore 注释3. / 开头或结尾的忽略4. glob 模式匹配忽略5. .gitignore 全局忽略6. 忽略已提交到远程仓库的内容7. 使用各种框架下的忽略规则 1. .gitignore 简介 .gitignore 文件的作用就是告诉 git 哪些文件不需要添加到版本管理中&#xff08;定义…
阅读更多...
Python如何制作图标点选验证码

Python如何制作图标点选验证码

本文讲解如何使用python中的opencv库来制作图标点选验证码 图标点选验证码制作起来非常简单，你只需要准备两部分数据集，数据集数量都不用很多，背景图我选择了20个左右，大小为（300， 500）左右，图标我抓取了100多个，图标大小为（40,40）左右，图标由不同大小的透明度构成…
阅读更多...
html实现好看的个人介绍，个人主页模板1(附源码)

html实现好看的个人介绍，个人主页模板1(附源码)

文章目录 1.设计来源1.1 主界面1.2 关于我界面1.3 自我介绍界面1.4 项目演示界面1.5 个人成就界面1.6 联系我界面 2.效果和源码2.1 动态效果2.2 源代码 源码下载 作者&#xff1a;xcLeigh 文章地址&#xff1a;https://blog.csdn.net/weixin_43151418/article/details/13125310…
阅读更多...
01-Maven 安装

01-Maven 安装

一. 下载 apache官网下载 Maven&#xff1a;Maven – Download Apache Maven &#xff0c;根据需要下载不同压缩包。 二. 安装和配置 因为是压缩包不是可执行文件&#xff0c;直接将压缩包进行解压即可&#xff0c;最好放在无中文目录下解压。 1. 配置maven本地仓库 打开解压…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023