$06[Scala[模式匹配(下)_泛型_异常_隐式转换]]

已于 2022-07-10 15:19:27 修改
阅读量62 收藏
点赞数
分类专栏： # scala语法 文章标签： scala 开发语言 后端
于 2022-07-10 15:17:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52210776/article/details/125706267
版权

第一章.模式匹配

1.匹配元组

package com.atguigu.chapter08

import com.atguigu.chapter07.$07_Tuple.{Region, School, Student}

object $07_MatchTuple {
  /**
   * 匹配元组的时候,变量是几元元组,匹配条件就只能是几元元组
   */
  def main(args: Array[String]): Unit = {
    val t1:(Any,Any,Any) = ("zhangsan",20,"shenzhen")
    t1 match{
      case (x:String, y:Int, z:Int) =>println(s"1x=${x} y=${y} z=${z}")
      case (x,y,z)=>println(s"2x=${x} y=${y} z=${z}")
    }
    val list3 = List(
      new Region("宝安区1",new School("宝安中学1",new Student("张三1",21))),
      new Region("宝安区2",new School("宝安中学2",new Student("张三2",22))),
      new Region("宝安区3",new School("宝安中学3",new Student("张三3",23))),
      new Region("宝安区4",new School("宝安中学4",new Student("张三4",24)))
    )
    val list4 = for (elem <- list3) yield {
      (elem.name, (elem.school.name, (elem.school.student.name, elem.school.student.age)))
    }
    list4.foreach(x=>{
      x match{
        case(regionName,(schoolName,(stuName,age)))=> println(stuName)
      }
    })
  }

}

2.匹配对象与样例类

package com.atguigu.chapter08

object MatchClass {
  /**
   * 样例类,其实就是伴生类和伴生对象的封装
   *    语法: case class 类名([val/var] 属性名:类型,.....)
   *    属性不用val/var修饰的默认就是val修饰的
   *    创建对象: 类名(值,....)
   *    样例对象: case object object 名称
   *
   * 普通类默认不能直接用于模式匹配,如果想用模式匹配需要在伴生对象中定义unapply方法,unapply方法就是将对象解构成属性
   */
  case class Person(val name:String,var age:Int,address:String)
  abstract class Sex
  //样例对象
  case object Man extends Sex
  case object Woman extends Sex
  def xx(sex:Sex)={
    println(sex)
  }
  def main(args: Array[String]): Unit = {
     val person = Person("lisi",20,"shenzhen")
    println(person.address)
    println(person.name)
    println(person.age)
    person.age=100
    val student = Student("zhangsan",20,"beijing")
    println(student.name)
    println(student.address)
    println(student.age)
    xx(Man)

    person match {
      case Person(x,_,z)=> println(s"name=${x} address=${z}")
    }
    val stu:Student = new Student("lisi",20,"zz")
    stu match{
      case Student(x,y,z)=> println(s"${x} ${y} ${z}")
    }
  }

  class Student(val name:String,var age:Int, val address:String)
  object Student{
    def apply(name:String,age:Int,address:String)=new Student(name,age,address)
    def unapply(stu:Student):Option[(String,Int,String)]={
      if(stu == null) None
      else Some((stu.name,stu.age,stu.address))
    }
  }

}

3.变量声明与for循环的模式匹配

package com.atguigu.chapter08

object $09_MatchParam {
  def main(args: Array[String]): Unit = {
    val t =("zhangsan",20,"shenzhen")
    println(t._1)
    val (name,age,address)=("zhangsan",20,"shenzhen")
    println(name)
    val List(x,_*)=List(1,2,3,4,45,4)
    println(x)
    val Array(y,z)=Array("hello",1)
    println(y,z)
    val map = Map[String,Int]("aa"->1,"bb"->2)
    for ((k,v)<- map) {
      println(k)
      println(v)
    }
  }

}

4.偏函数

package com.atguigu.chapter08
import com.atguigu.chapter07.$07_Tuple.{Region, School, Student}
import scala.io.StdIn

object $10_PartitalFunction {
  /**
   * 偏函数: 没有match关键字的模式匹配称之为偏函数
   *    语法: val 函数名:PartialFunction[IN,OUT]={
   *      case 条件=> ...
   *      case 条件=> ...
   *      case 条件=> ...
   *      ....
   *    }
   */
  def main(args: Array[String]): Unit = {
    val func:PartialFunction[String,Int]={
      case "hadoop"=>{
        println("hadoop..")
        10
      }
      case "spark"=>{
        println("spark..")
        20
      }
      case _ =>{
        println("其他..")
        30
      }
    }
    val wc = StdIn.readLine("请输入一个单词:")
    println(func(wc))
    val list = List("hello","spark","hadoop","flume")
    val func2:PartialFunction[String,Int]={
       case x =>x.length
    }
    //list.map(x=>x.length)
    println(list.map{
      case x => x.length
    })

    val list3 = List(
      ("宝安区1",("宝安中学1",("张三1",21))),
      ("宝安区2",("宝安中学2",("张三2",22))),
      ("宝安区3",("宝安中学3",("张三3",23))),
      ("宝安区4",("宝安中学4",("张三4",24)))
    )
    list3.foreach(x=>x match{
      case(regionName,(schoolName,(stuName,age)))=> println(stuName)
    })
    //偏函数的使用场景
    val func3:PartialFunction[(String,(String,(String,Int))),Unit]={
      case(regionName,(schoolName,(stuName,age)))=> println(stuName)
    }
    list3.foreach{
      case(regionName,(schoolName,(stuName,age)))=> println(stuName)
    }
  }

}

第二章.异常

package com.atguigu.chapter09

import scala.util.Try

object $01_Exception {
  /**
   * java的异常处理方式
   *      1.捕获异常: try{...}catch(Exception e){...}.. finally{...}
   *      2.抛出异常: throw new XXException[必须在方法名后面通过throws声明异常]
   *
   *
   * scala的异常处理方式
   *      1.捕获异常
   *          a.try{...}catch{case e:Exception => ...} finally{...}<一般用于获取外部资源链接的时候使用,可以通过finally关闭资源链接>
   *          b.Try(代码块).getOrElse(默认值)<常用>
   *              Try有两个子类:
   *                Success: 代表代码执行成功,代码执行结果封装在Success中
   *                Failture: 代表代码执行失败
   *              Try(代码块).getOrElse(默认值)  [此时如果代码执行成功,则返回执行结果,如果代码执行失败则返回默认值]
   *      2.抛出异常:throw new XXException [不需要在方法后面通过throws关键字声明异常]<不用>
   */
  def main(args: Array[String]): Unit = {
    //println(m1(10, 2))
    //println(m1(10, 0))
    println(m2(10, 0))
    val list= List("1 zhangsan 20 beijing","2  30 shenzhen","3 lisi  tianjin")
    val list2 = list.map(x=>{
      val arr = x.split(" ")
      val age = Try(arr(2).toInt).getOrElse(0)
      (arr.head,arr(1),age,arr(3))
    })
    println(list2)

  }


  //抛异常
  def m1(x:Int,y:Int):Int={
    if(y==0) throw new Exception("被除数不能为0")
    else x/y
  }
  //捕获异常
  def m2(x:Int,y:Int):Int={
    try{
      x/y
    }catch{
      case e:Exception =>
        println(e.getMessage)
        -1
    }
  }

}

第三章.隐式转换

1.隐式转换方法

package com.atguigu.chapter10

import java.io.File
import scala.io.{BufferedSource, Source}


class BB{
  //隐式转换方法
  implicit def double2Int(d:Double):Int={
    println(s"-------->${d}")
    d.toInt
  }
  //隐式转换方法
  implicit def file2SourceBuffer(file:File):BufferedSource={
    Source.fromFile(file,"utf-8")
  }
}

object $01_ImplicitMethod {
  /**
   * 隐式转换分为三类:
   *    1.隐式转换方法:悄悄的将一个类型转成另一个类型
   *      语法: implicit def 方法名(参数名:待转换类型):目标类型={....}
   *      隐式转换方法的调用时机:
   *        1.当前类型与目标类型不一致的时候,会自动调用隐式转换方法
   *        2.当对象使用了不属于自身的属性和方法的时候,会自动调用隐式转换方法
   *    2.隐式参数
   *    3.隐式类
   * 隐式转换的解析
   *    首先会从当前作用域和父作用域查找是否有符合条件的隐式转换,如果有直接使用,如果没有则报错
   *    如果隐式转换定义在其他的object/class中,使用的时候需要导入
   *        1.隐式转换定义在object中,此时可以通过import object名称._ \ import object名称.隐式转换名称
   *        2.隐式转换定义在class中,此时可以通过 import 对象名._ /import 对象名.隐式转换名称 导入
   *    如果有多个隐式转换都符合要求,需要明确指定需要使用哪一个隐式转换
   */
  def main(args: Array[String]): Unit = {
    val bb = new BB
    import bb._
    import bb.double2Int
    val a:Int=2.5
    val file = new File("C:\\Users\\admin\\IdeaProjects\\atguigu\\scala-study\\datas\\wc.txt")
    file.getLines().foreach(println(_))
  }



}

2.隐式参数

package com.atguigu.chapter10

object $02_ImplicitParam {
  /**
   * 隐式参数:调用方法的时候自动传参
   *   语法:
   *    1.在定义方法的时候,指定哪个参数后续会自动传值:
   *      def 方法名(参数名:类型,..)(implicit 参数名:类型)={...}
   *    2.定义隐式参数的值:
   *      implicit val 参数名:类型 = 值
   */
  def main(args: Array[String]): Unit = {
     import com.atguigu.chapter10.AA.z1
    println(m1(10, 20)(50))
    println(m2)
  }
  def m1(x:Int,y:Int)(implicit z:Int)=x+y+z
  def m2(implicit z:Int)=z

}

3.隐式类

package com.atguigu.chapter10

import java.io.File

object $03_ImplicitClass {
  /**
   * 隐式类:
   *    语法: implicit class 目标类名称(属性名:待转换类型){...}
   * 隐式类其实就是一种特殊形式的隐式转换方法
   * 隐式类不能置于最顶层,必须放在object/class中
   * 隐式类其实就是自动调用主构造器进行类型的转换
   */
  implicit class RichFile(file:File){
    def m1(x:Int,y:Int)=x+y
    val name = "zhansan"
  }

  def main(args: Array[String]): Unit = {
    val file = new File("C:\\Users\\admin\\IdeaProjects\\atguigu\\scala-study\\datas\\wc.txt")
    println(file.m1(20, 30))
  }
/*  implicit def file2RichFile( file:File ):RichFile = {
    new RichFile
  }*/
}

第四章.泛型

1.泛型方法

package com.atguigu.chapter11

object $01_GenericMethod {
  /**
   * 泛型方法:
   *    语法: def 方法名[T,U,...](参数名:T):U={...}
   */
  def main(args: Array[String]): Unit = {
    m1[String](Array("aa","bb"))
  }
  def m1[T](x:Array[T])={
    println(x.length)
  }
}

2.泛型类

package com.atguigu.chapter11

import java.beans.BeanProperty

object $02_GenericClass {
  /**
   * 泛型类语法:
   *      class 类名[T,U,...](属性名:T,...){
   *          def 方法名(x:T):U=..
   *      }
   * @param args
   */
  class Person[T,U](@BeanProperty var name:T, @BeanProperty var age:U)
  def main(args: Array[String]): Unit = {
    val person = new Person[String,Int]("lisi",20)
    println(person.getName)
  }

}

3.非变,逆变,协变

package com.atguigu.chapter11

/**
 * 非变[T]:同一个类,如果泛型不一样创建出来的对象没有任何关系
 * 协变[+T]:同一个类,如果泛型之间有父子关系,创建出来的对象继承了泛型的父子关系
 * 逆变[-T]:同一个类,如果泛型之间有父子关系,创建出来的对象颠倒了泛型的父子关系
 */

object $03_GenericChange {
  class Animal
  class Dog extends Animal
  //非变
  class Parent[T]
  //逆变
  class Parent2[+T]
  //协变
  class Parent3[-T]

  def main(args: Array[String]): Unit = {
    var list1 = List[Animal](new Animal,new Animal)
    println(list1)
    var list2 = List[Dog](new Dog,new Dog)
    list1 = list2
    println(list1)

    //非变
    var b1 = new Parent[Animal]
    var b2 = new Parent[Dog]
    //b1 = b2
    //协变
    var b3 = new Parent2[Animal]
    var b4 = new Parent2[Dog]
    b3 = b4
    println(b3)
    //逆变
    var b5 = new  Parent3[Animal]
    var b6 = new  Parent3[Dog]
    b6 = b5
    println(b6)

  }

}

4.上下限

package com.atguigu.chapter11

object $04_GenericLowHight {
  class Parent
  class Sub1 extends Parent
  class Sub2 extends Sub1
  class Sub3 extends Sub2

  /**
   * 上限[T<:类型]:要求传入的类型必须是指定类型或者是其子类
   * 下限[T>:类型]:要求传入的类型必须是指定类型或者是其父类
   */
  //上限
  def m1[T<:Sub1](t:T)={
    println(t)
  }
  //下限
  def m2[T>:Sub1](t:T)={
    println(t)
  }

  def main(args: Array[String]): Unit = {
    //上限
    //m1(new Parent)
    m1(new Sub3)
    //下限
    m2(new Parent)
    val p:Any = new Sub3
    m2(p)
    val x:Any = 10
    m2(x)
  }

}

5.上下文

package com.atguigu.chapter11

import java.beans.BeanProperty

object $05_GenericContext {
  /**
   * 上下文:
   *     语法: T:类型
   */
  class Person[T]{
    @BeanProperty var name:T=_
  }
  def main(args: Array[String]): Unit = {
    implicit val p:Person[String] = new Person[String]
    val person = m1[Int](10)(new Person[Int])
    val person2 = m1[String]("zhangsan")
    println(person.getName)
    println(person2.getName)
    val person3 = m2[String]("wangwu")
    println(person3.getName)
  }
  def m1[U](x:U)(implicit p:Person[U])={
    p.setName(x)
    p
  }
  def m2[U:Person](x:U)={
    val person =implicitly[Person[U]]
    person.setName(x)
    person
  }

}
ly的学习笔记
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
大数据课程-Scala编程基础-5.Scala模式匹配_lk_edit.ppt
01-01
本课程内容涵盖多个关键概念，如模式匹配、样例类、隐式函数和异常处理及泛型，这些都是Scala语言强大特性的体现。 首先，Scala的模式匹配是一种强大的控制流构造，类似于Java中的switch语句，但更为灵活。它允许...
scala_2.11.8
02-26
此外，Scala的类型系统允许定义类型类和隐式转换，提供了一种优雅的方式处理泛型和模式匹配，这些特性使得代码更易于理解和测试。 总的来说，Scala_2.11.8是开发者手中一个强大的工具，它结合了现代编程语言的多种...
learning_scala：通过学习Scala中的示例进行工作
02-17
每个章节的示例可能是一个独立的Scala文件，通过它们，你可以学习如何声明变量、定义函数、操作集合、使用模式匹配、处理异常、实现 Actors（一种并发模型）以及更多高级概念，如类型系统、隐式转换和类型推断。...
ScalaTutorial-zh_CN-p22.7z
12-07
3. 隐式转换：可以定义隐式转换，使得两种类型之间可以互相转换，增强代码的灵活性。 综上所述，Scala教程可能涵盖了这些主题，帮助学习者理解和掌握Scala语言的各个方面，从基础到高级特性，包括面向对象编程、...
programming in Scala_ch
09-22
- **隐式转换**: 学习如何使用隐式转换来简化代码。 - **隐式参数**: 理解隐式参数的作用和如何使用它们。 #### 实现列表 - **自定义列表**: 探索如何实现自己的列表类。 #### 重访for表达式 - **for表达式**: ...
Scala学习笔记20: Future 和Promise
Taerge0110的博客
07-26 277
在 Scala 中, `Future` 和 `Promise` 是用于处理异步操作的强大工具 ; 它们就像一对搭档, 协同工作, 优雅地管理着那些需要花费时间的任务 .
探索Perl的图形用户界面开发：工具、技巧与实践
2402_85762143的博客
07-23 1126
Perl的GUI开发提供了多种工具和方法，允许开发者根据项目需求和个人偏好选择合适的工具包。通过遵循最佳实践和利用Perl的强大功能，开发者可以创建出既美观又实用的GUI应用程序。随着技术的不断发展，Perl社区也在不断推出新的工具和库，以支持更高效、更现代的GUI开发。本文只是一个入门指南，深入学习Perl GUI开发还需要阅读更多的文档、参与社区讨论和实践项目。希望本文能为你的Perl GUI开发之旅提供一些帮助和启发。
Spark实时（三）：Structured Streaming入门案例
Lansonli（蓝深李）的博客
07-24 654
我们使用Structured Streaming来监控socket数据统计WordCount。
探索Perl的奇妙世界：入门学习与实战指南
sinner小屋
07-25 1414
《探索Perl的奇妙世界：入门学习与实战指南》为大家提供了一个全面的Perl编程学习路径，从基础知识到高级技巧，涵盖了Perl在Web开发、数据库操作和生物信息学中的实际应用。通过详实的代码案例和实战演练，本书帮助大家深入理解Perl的强大功能和灵活性。同时，文中还探讨了Perl的优势与局限，以及其在未来的发展潜力，适合所有希望提升Perl编程技能的读者。
主流开发语言和开发环境介绍
weixin_44215445的博客
07-23 1275
主流开发语言和开发环境介绍
实现一个全栈模糊搜索匹配的功能
前端原创分享，常年坚持记录和分享，全网阅读量超百万
07-27 170
提供一个全栈实现的方案，包括 Vue 3 前端、Express 后端和 MySQL 数据库的分类模糊搜索功能。
SpringCloud+Vue3多对多，多表联查
小宋和大家一起在学习和前进的道路上分享、努力
07-27 787
♥️作者：小宋1021🤵‍♂️：小宋1021主页♥️坚持分析平时学习到的项目以及学习到的知识，和大家一起努力呀！！！🎈🎈加油！加油！加油！加油目的：多表联查数据库：学员表(study_student) 字段：学生姓名（sts_student_name）、手机号(sts_phone)班级管理（teach_class_manage）字段：班级名称（teach_class_manage）、id（id）教师管理（hr_teacher_manage）字段：教师姓名（teacher_name）
后端采用SpringBoot框架开发的：ADR药物不良反应智能监测系统源码，用于监测和收集药品在使用过程中发生的不良反应的系统
baina666的博客
07-26 388
ADR药物不良反应智能监测系统的优势在于其能够快速、准确地识别潜在的不良反应事件，并及时采取相应的措施，从而减少药害事故的发生，保障公众用药安全。该系统基于医院临床数据中心，运用信息技术实现药品不良反应的智能监测、报告管理、知识库查询、统计分析等功能，旨在提高药品使用的安全性和患者的用药安全。：系统能够自动从各个数据源（如电子病历、实验室信息系统、药房管理系统等）收集相关的患者数据、药品使用信息和不良反应报告，并进行整合和清洗，以确保数据的准确性和一致性。
@NotNull、@NotEmpty 和 @NotBlank 区别
lw的博客
07-24 207
NotNull、@NotEmpty 和 @NotBlank 是 Java Bean Validation (JSR 380)规范中定义的注解，通常用于验证对象的属性是否满足特定的条件。这些注解常用于后端验证，确保接收到的数据符合预期。
后端解决跨域（Cross-Origin Resource Sharing）(三种方式)
最新发布
weixin_53515812的博客
07-27 140
控制层的类上或者方法上加注解@CrossOrigin。
探索扫描二维码登录的奥秘：从前端到后端的无缝连接
to_the_Future的博客
07-23 1174
在数字化时代，我们几乎每天都会接触到各种各样的二维码，尤其是在登录网站或应用程序时。扫描二维码登录不仅提升了用户体验，还极大地简化了登录流程，增强了安全性。本文将深入探讨这一技术背后的原理，以及前后端如何协同工作，实现这一看似简单的功能。
chrome 接口请求等待时间(installed 已停止)过长问题定位
汤一飞
07-26 357
消息通知有个接口, 最长有可能等 1 分钟再返回, 而浏览器对同一个域名的并发请求数限制为最多 6 个(针对 http1.1 而言), 导致开 6 个标签页后, 6 个并发请求基本全被这个接口占着了, 其他接口只能排队等某个标签页的这个接口请求完毕退出并发后才能请求, 因此速度变慢。推测是并发请求窗口数量的问题, 屏蔽部分一直 pending 的接口, 发现速度正常了, 搜到上面的参考文章, 看接口请求协议, 果然是 http1.1。测试反馈系统开 6 个标签页后, 反应变的很慢。
THS配置keepalive（yjm）
weixin_39938069的博客
07-24 213
启动完THS管理控制台和THS后，登录控制台，进入实例管理==》节点管理，可以分别使用界面配置和编辑配置设置长连接......
后端开发工程师vue2初识的学习
音符犹如代码的博客
07-24 1034
快速认识vue
Scala编程基础：模式匹配与异常处理
内容包括Scala模式匹配的概念、样例类、隐式函数和异常及泛型的使用。课程材料全面，包含教学大纲、教案、实训文档等，适合教师进行教学使用。" 在Scala编程中，模式匹配是一种强大的控制流构造，它允许我们根据值...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值