Scala(六)

最新推荐文章于 2023-09-17 11:33:10 发布
最新推荐文章于 2023-09-17 11:33:10 发布
阅读量514 收藏
点赞数 1
分类专栏： Scala 基础知识 文章标签： scala java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qcl108/article/details/122778229
版权

Scala 六

异常处理

  • 为了不让程序异常终止, 使用 try-catch语句. 将可能会出异常的代码封装在 try块中, 当发生异常时, catch捕获异常, 并处理
  1. Scala没有checked(编译期)异常, 而异常都是Runtime异常运行的时候捕获
  2. 当异常发生, catch子句, 是按顺序捕捉的. 因此, 范围小的异常类写在前面, 范围大的异常类写在后面, 一旦前面的异常被捕获, 写在后面的异常类, 即使也在范围内也不会被捕获
  3. finally子句是, 异常发生或未发生, 只要执行了 try语句, 最后肯定被执行的语句, 与 Java一样
  4. 所有异常类都是 Throwable的子类. 通过 throw关键字, 抛异常类对象, 接收类型设置为 Nothing
  5. 可能会抛异常的函数上方, 声明 @throws(classOf[Exception])异常类注解. 和 Java方法上的 throws关键字相同效果
package com.ex6.test1

object Test1 {
  def main(args: Array[String]): Unit = {
    try {
      val n = 10 / 0
    } catch {
      case e: ArithmeticException => println("发生算术异常！") // 捕获
      case e: Exception => {
        println("发生一般异常!")
      }
    } finally {
      println("处理结束")
    }

    def test1(): Nothing = {
      throw new Exception("发生异常!")
    }
    test1(); // java.lang.Exception: 自定义异常!

    @throws(classOf[NumberFormatException])
    def test2(arg: String) = {
      arg.toInt
    }
    println(test2("123")) // 123
    println(test2("abc")) // java.lang.NumberFormatException: For input string: "abc"
  }
}

隐式转换

  • 当编译器第一次编译失败时, 编译器会尝试在当前作用域范围内查找能调用的转换规则, 如果找到了, 则会二次编译. 这个过程是由编译器完成的, 所以称之为隐式转换

  • 隐式转换是 Scala独有的功能, 后续 Akka并发编程会经常用到它

  • 值, 参数, 方法或函数和类, 都可以通过 implicit关键字声明为隐式(implicit关键字是在 Scala的2.10版本开始出现的

  • 隐式函数案例 1:

package com.ex6.test2

class MyRichInt(val self: Int) {
  def myMax(n: Int): Int = if (n < self) self else n
  def myMin(n: Int): Int = if (n < self) n else self
}

object Test2 {
  def main(args: Array[String]): Unit = {
    // 普通方式
    val new12 = new MyRichInt(12)
    println(new12.myMax(15)) // 15

    // 隐式函数(一个参数列表中只能有一个参数
    implicit def test1(num: Int): MyRichInt = new MyRichInt(num)
    // 通过隐式转换给 Int类型增加方法
    println(12.myMax(15)) // 15
  }
}
  • 隐式函数案例 2:
package com.ex6.test3

import java.io.File
import scala.io.Source

object Test3 {
  class RichFile(file: File) {
    def read() = Source.fromFile(file).mkString
  }
  // 单例对象中定义隐式转换
  object ImplicitDemo {
    // 隐式函数(一个参数列表中只能有一个参数
    implicit def file2RichFile(file: File) = new RichFile(file)
  }

  def main(args: Array[String]): Unit = {
    import ImplicitDemo.file2RichFile
    val file = new File("chapter06/test.txt")
    println(file.read())
  }
}
//hello world
//hello scala
//你好 Shawn!
//函数式编程!
  • 隐式参数:
  • 调用声明隐式参数的方法时, 编译器会在当前作用域内寻找符合条件的隐式值
  1. 同一个作用域中, 相同类型的隐式值只能有一个, 因为, 编译器是按照隐式参数的类型去寻找对应的隐式值, 与隐式值的名称无关
  2. 隐式参数优先于默认参数
    *通过 implicitly函数获取隐式变量(标准库提供的泛型的 type class interface), 在当前作用域内查找对应类型的隐式变量
package com.ex6.test4

object Test4 {
  def main(args: Array[String]): Unit = {
    // 隐式值
    implicit val name: String = "Shawn"
    implicit val num: Int = 18
    // 隐士参数
    def sayHello()(implicit arg: String): Unit = {
      println("hello, " + arg)
    }
    sayHello // hello, Shawn
    sayHello()("Sam") // hello, Sam

    def sayHi(implicit arg: String = "Mia"): Unit = {
      println("hi, " + arg)
    }
    sayHi // hi, Shawn
    sayHi("Tom") // hi, Tom

    // 代码简化
    def hiAge(): Unit = {
      println("hi, " + implicitly[Int])
    }
    hiAge() // hi, 18
  }
}


package com.ex6.test5

object Test5 {
  // 1. 接收一个姓名, 在接受一个前缀, 后缀信息(隐式参数
  def show(name: String)(implicit delimit: (String, String)) = delimit._1 + name +
    delimit._2

  // 2. 定义一个单例对象, 给隐式参数设置默认值
  object ImplicitParam {
    implicit val delimit_defalut = "<<<" -> ">>>"
  }

  def main(args: Array[String]): Unit = {
    // 3. 导入隐式参数.
    import ImplicitParam.delimit_defalut
    println(show("Shawn")) // <<<Shawn>>>
    println(show("Mia")("(((" -> ")))")) // (((Mia)))
  }
}


package com.ex6.test6

object Test6 {
  // 1. 接收一个姓名, 在接受一个前缀, 后缀信息(隐式参数
  def show(name: String)(implicit delimit: (String, String)) = delimit._1 + name +
    delimit._2

  def main(args: Array[String]): Unit = {
    // 2. 自动导入隐式参数
    implicit val delimit_defalut = "<<<" -> ">>>"
    println(show("Shawn")) // <<<Shawn>>>
    println(show("Mia")("(((" -> ")))")) // (((Mia)))
  }
}
  • 隐式类:
  1. 隐式类的构造器必须有参, 且只能有一个
  2. 隐式类必须被定义在“类”或“伴生对象”或“包对象”里, 即隐式类不能是顶级类
package com.ex6.test7

object Test7 {
  def main(args: Array[String]): Unit = {
    // 隐式类
    implicit class MyRichInt(val self: Int) {
      // 自定义比较大小的方法
      def myMax(n: Int): Int = if (n < self) self else n
      def myMin(n: Int): Int = if (n < self) n else self
    }
    println(12.myMin(15)) // 12
  }
}
  • 列表加获取所有元素平均值的方法
package com.ex6.test8

object Test8 {
  class RichList(list: List[Int]) {
    // 1. 定义 avg()方法, 用来获取 List列表中所有元素的平均值
    def avg() = {
      if (list.size == 0) None else Some(list.sum / list.size)
    }
  }

  def main(args: Array[String]): Unit = {
    // 2. 定义隐式转换方法.
    implicit def list2RichList(list: List[Int]) = new RichList(list)
    val list1 = List(1, 2, 3, 4, 5)
    println(list1.avg()) // Some(3)
  }
}

泛型

协变和逆变

  • 用于泛型参数的类的父子级关系, 通过协/逆变影响当前类的父子关系
    *不变(非变): Child是 Parent的子类, 则 MyList[Parent]与 MyList[Child]“无父子关系”
    *协变: Child是 Parent的子类, 则 MyList[Child]也作为 MyList[Parent]的“子类”
    *逆变: Child是 Parent的子类, 则 MyList[Child]作为 MyList[Parent]的“父类”

  • 语法:
    class MyList[T] {} // 不变(非变; 默认
    class MyList[+T] {} // 协变
    class MyList[-T] {} // 逆变

  • 列子 1:

package com.ex6.test9

object Test9 {
  def main(args: Array[String]): Unit = {
    // 协变和逆变
    val child: Parent = new Child // OOP的多态向上转型
    //    // 不变 [T] 默认( MyList[SubChild]和 MyList[Child]无父母关系
    //    val childList3: MyList[Parent] = new MyList[Child]

    //    // 协变 [+T] ( MyList[Parent]是 MyList[Child]的父类
    //    val childList1: MyList[Parent] = new MyList[Child]

    // 逆变 [-T] ( MyList[Child]是 MyList[Parent]的父类
    val childList2: MyList[Child] = new MyList[Parent]
  }
}
// 定义继承关系
class Parent {}
class Child extends Parent {}
// 定义带泛型的集合类型
class MyList[-E] {}
  • 列子 2:
package com.ex6.test10

object Test10 {
  class Super
  class Sub extends Super

  class Temp1[T] // 非变
  class Temp2[+T] // 协变
  class Temp3[-T] // 逆变

  def main(args: Array[String]): Unit = {
    // 演示非变
    val t1: Temp1[Sub] = new Temp1[Sub]
    //val t2:Temp1[Super] = t1 // 编译报错, 因为非变是 Super和 Sub有父子类关系, 但是 Temp1[Super]和 Temp1[Sub]之间没有关系

    // 演示协变
    val t3: Temp2[Sub] = new Temp2[Sub]
    val t4: Temp2[Super] = t3 // 不报错, 因为协变是 Super和 Sub有父子类关系, 所以 Temp2[Super]和 Temp2[Sub]之间也有父子关系
    // Temp2[Super]是父类型, Temp2[Sub]是子类型

    // 演示逆变
    val t5: Temp3[Super] = new Temp3[Super]
    val t6: Temp3[Sub] = t5 // 不报错, 因为逆变是 Super和 Sub有父子类关系, 所以 Temp3[Super]和 Temp3[Sub]之间也有子父关系
    // Temp3[Super]是子类型, Temp3[Sub]是父类型
  }
}

泛型上下限(上下界)

  • 泛型的上下限的作用是对传入的泛型进行限定(限定该泛型必须从哪个类继承, 或必须是哪个类的父类或子类等)
  • 如果泛型, 既有上界, 又有下界. 则下界写在前面, 上界写在后面. 即: [T >: 类型1 <: 类型2]
  • 语法:
    Class PersonList[T <: Person] {} // 泛型上限(上界)(泛型 T的数据类型, 必须为 Person类型或 Person的子类型
    Class PersonList[T >: Person] {} // 泛型下限(下界)(泛型 T的数据类型, 必须为 Person类型或 Person的父类型
  • 例子 1:
package com.ex6.test11

object Test11 {
  def main(args: Array[String]): Unit = {
    // 上限(泛型必须为 Child或是它的子级
    def test1[A <: Child](a: A): Unit = {
      println(a.getClass.getName) // 查看当前类型
    }
    test1[Child](new SubChild) // com.ex6.test11.SubChild
    test1[Child](new Child) // com.ex6.test11.Child
    //test1[Parent](new Child) // 限制

    // 下限(泛型必须为 Child或是它的父级
    def test2[A >: Child](a: A): Unit = {
      println(a.getClass.getName) // 查看当前类型
    }
    test2[Parent](new Child) // com.ex6.test11.Child
    test2[Child](new Child) // com.ex6.test11.Child
    test2[Child](new SubChild) // com.ex6.test11.SubChild

    def test3[A <: Child](a:Class[A]): Unit = {
      println(a)
    }
    test3(classOf[SubChild]) // class com.ex6.test11.SubChild
    test3(classOf[Child]) // class com.ex6.test11.Child
    //test3(classOf[Parent]) // 限制
  }
}
// 定义继承关系
class Parent {}
class Child extends Parent {}
class SubChild extends Child {}

*一般函数设置泛型时, 这个泛型都会出现在参数里面, 用于设置参数的类型

  • 例子 2: 上界
package com.ex6.test12

object Test12 {
  class Person
  class Student extends Person
  // 限定 Array元素类型只能是 Person或 Person的子类
  def demo[T <: Person](arr: Array[T]) = println(arr)
  def main(args: Array[String]): Unit = {
    //demo(Array(1, 2, 3)) // 会报错, 因为只能传入 Person或者它的子类型
    demo(Array(new Person()))
    demo(Array(new Student()))
  }
}
  • 例子 3: 下界
package com.ex6.test13

object Test13 {
  class Person
  class Policeman extends Person
  class Superman extends Policeman
  // 限定 Array元素类型只能是 Person或 Policeman
  //          下界          上界
  def demo[T >: Superman <: Policeman](arr: Array[T]) = println(arr)
  def main(args: Array[String]): Unit = {
    demo(Array(new Policeman))
    demo(Array(new Superman))
    //demo(Array(new Person)) // 会报错
  }
}

上下文限定


// 上下文限定是将泛型和隐式转换的结合产物, 以下两者功能相同，使用上下文限定[A : Ordering]之后, 方法内无法使用隐式参数名调用隐式参数, 需要通过 implicitly[Ordering[A]]
def f[A:Ordering](a:A,b:A) =implicitly[Ordering[A]].compare(a,b)
def f[A](a: A, b: A)(implicit ord: Ordering[A]) = ord.compare(a, b)

// 这里 A是泛型名称, 后面 B是隐式参数类型名称
def f[A : B](a: A) = println(a) 
// 等同于
def f[A](a:A)(implicit arg:B[A]) = println(a)

如果您觉得有帮助，欢迎点赞哦 ~ 谢谢!!

Shawn Jeon
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Scala研究
02-17
六、Scala与大数据 Scala在大数据领域有着广泛的应用，尤其是Apache Spark框架就是用Scala编写的。Spark提供了高效的分布式计算能力，其API设计简洁，与Scala的语法风格相得益合，使得开发大规模数据处理应用更为...
idea-scala插件
06-17
### 六、版本控制集成 Idea-Scala插件无缝集成了Git和其他版本控制系统，可以进行提交、合并、解决冲突等操作，无需离开IDE。这对于团队协作开发尤其重要。 ### 七、构建工具支持 对于SBT（Scala Build Tool）...
myeclipse连接数据库报空指针
weixin_44244909的博客
06-17 383
myeclipse连接数据库报空指针 package com.unit6.test; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class Test1 { public static void main(String[] args) { Connection conn=null; String address="jdbc:mysql://localhost
Scala六大特性及常用知识点总结（一）
StandbyTheSea的博客
04-15 4426
百度百科中对Scala这门语言的简介是这个样子：“Scala是一门多范式的编程语言，一种类似java的编程语言 ，设计初衷是实现可伸缩的语言 、并集成面向对象编程和函数式编程的各种特性。” 作为一门基于JVM的编程语言，Scala和Java在很多方面有相似之处。 Scala官网总结了它的六大特性，翻译成中文它们分别对应着以下六点： 1).Java和Scala可以混编： Scala基于JVM平台...
初学者入门Scala讲解!!!Scala六大特性,Scala高阶语法讲解二【小二讲堂】
Mirror_w的博客
04-19 917
上篇入门级Scala介绍主要是对scala基本语法介绍下面继续高级语法的讲解 本篇博文主要针对新手入门Scala的详细介绍。主要是语法的介绍，代码案例全是小二手工操作出来的野生代码！！！ 小二推荐：https://blog.csdn.net/Mirror_w/article/details/89348834 一、Scala介绍 Scala是一门多范式的编程语言，一种类似java的编程语言，设计初衷...
scala
2201_75376805的博客
09-13 335
当编译的文件和类文件不在一个路径时，可以使用scalac -cp 命令强制指定类文件所在的目录，输入 scalac -cp C:\test\classes HelloWorld.scala。如果我们想反编译scala那么使用scala命令，如果我们想知道scala命令对应的java文件那么我们使用javap完成反编译。第三步切换相应文件存放路径，然后再启动scala解释器，输入new Person("scala")。第四步使用Javap反编译生成Scala的类文件，让我们能够理解Scala的运行机制。
Scala
weixin_61399281的博客
07-27 848
Scala使用def关键字告诉编译器这是一个方法。返回值类型与返回值在参数后面加一个冒号和类型来显式地指定返回类型。方法可以写返回值的类型也可以不写，会自动推断，但是如果有显式的Return有时候不能省略，必须写，Scala中函数有返回值时，可以写return，也可以不写return，不写return时会把函数中最后一行当做结果返回。如果去掉方法体前面的等号，那么这个方法返回类型必定是Unit的。scala可以把任意类型转换为Unit。会被丢弃。}中的所有集合。不变的。...
一文速通Scala
成功唯有积累，没有奇迹。
04-26 2059
一文速通scala
Scala安装配置
W_chuanqi的博客
02-20 3325
Scala(斯嘎拉)这个名字来源于"Scalable Language(可伸缩的语言)"，它是一门基于JVM的多范式编程语言，通俗的说：Scala是一种运行在JVM上的函数式的面向对象语言。之所以这样命名，是因为它的设计目标是：随着用户的需求一起成长。Scala可被广泛应用于各种编程任务, 从编写小型的脚本到构建巨型系统，它都能胜任。正因如此, Scala得以提供一些出众的特性, 例如: 它集成了面向对象编程和面向函数式编程的各种特性, 以及更高层的并发模型。
Scala集合
Markble
08-26 6285
一、集合的简介 1）Scala的集合有三大类：序列Seq、集Set、映射Map，所有的集合都扩展自Iterable特质。 2）对于几乎所有的集合类，Scala都同时提供了可变和不可变的版本，分别位于以下两个包 不可变集合：scala.collection.immutable 可变集合：scala.collection.mutable 3）Scala不可变集合，就是指该集合对象不可修改，每次修改就会返回一个新对象，而不会对原对象进行修改。类似于java中的String对象 4）可变集合，就是这个集
Scala编程语言
最新发布
IT小小白的博客
09-17 4451
Scala是一门多范式编程语法，所谓多范式指的就是多种编程风格的语法，Scala主要是一门面向对象编程语言和函数式编程语言。
大数据-scala（六）
海恋北斗星
04-27 283
大数据-scala（六） 函数式编程 排序 - sort sorted默认排序 //定义一个List集合 scala> val list=List(5,1,2,4,3) list: List[Int] = List(5, 1, 2, 4, 3) //默认就是升序 scala> list.sorted res30...
scala-2.12.6.tgz
08-09
例如，2.12.6是在2.12基础上的第六个次要更新，可能包含了性能优化、新的API、错误修复和对Java平台的改进支持。 3. 安装与配置： 下载scala-2.12.6.tgz后，你需要解压到合适的目录。这可以通过命令行工具如tar来...
Scala Design Patterns
04-14
#### 六、总结 《Scala Design Patterns》不仅涵盖了传统设计模式的理论知识，还深入探讨了如何在Scala语言中有效应用这些模式。这对于任何想要提高自己的Scala编程技能并构建高质量软件系统的开发者来说，都是一本...
Scala in action
12-19
#### 六、使用 Scala 构建 Web 应用 1. **Play 框架**：Play 是一个流行的 Scala/Java Web 框架，它采用轻量级、无配置的方法来构建 Web 应用。Play 支持异步处理、热重载等功能，非常适合快速开发 RESTful API 和 ...
对称加密和非对称加密(关于中间人攻击, 数字签名)
Shawn Jeon`s blog
10-27 4071
关于对称加密和非对称加密关于对称加密和非对称加密目前加密方式主要有两种: 对称加密和非对称加密通信过程(非对称加密关于中间人攻击(非对称加密关于数字签名(非对称加密关于RSA签名(数字签名证书认证机构 CA(Certificate Authority) 关于对称加密和非对称加密 目前加密方式主要有两种: 对称加密和非对称加密 对称加密做加密和解密使用的是同一个密钥, 通信双方需通过电话或邮件等...
算法-最小生成树算法(普里姆算法 Prim`s algorithm)
Shawn Jeon`s blog
11-10 3713
Prim’s algorithm概述修路问题 概述 普里姆算法(Prim’s algorithm)是求出最小生成树的算法, 也就是在包含 n个顶点的带权无向连通图中, 找出(n-1)条边的最小耗费生成树(Minimum Cost Spanning Tree), 简称 MST 普里姆算法的时间复杂度为: 邻接矩阵 O(v^2), 邻接表 O(elog2v) e为网中的边数 修路问题 有叫(A,B,C,D,E,F,G)的7个村庄, 现在需要将这7个村庄通过修路连通. 各个村庄的距离用边线权值来表示, 比如
Mysql分库分表
Shawn Jeon`s blog
02-01 2954
Mysql分库分表垂直分表水平分表垂直或水平分库 对于大型互联网应用的数据库架构上, 首先做好主从分离提升读写性能, 还有通常查询操作远多于增删改, 因此从库充分的做好水平扩展来进一步提升读性能. 然后按单库或单表数据量过于庞大导致单个服务器的内存, 磁盘空间, IO等的有限性要做垂直或水平分库分表来改善相关表读写整体性能 垂直分表 一般是在有较多字段的表内, 将不常用的字段, 特别是长度较...
Java自带 JVM监控工具
Shawn Jeon`s blog
12-04 2921
Jdk自带工具之监控工具默认路径常用工具jpsjps -l 输出完整的包名称jps -m 输出所有预加载包和启动类名jps -v 输出启动类名和 JVM参数jstackjinfojmapjmap -heap <pid> 输出进程内堆详细信息jmap -histo:live <pid> 输出堆中对象的统计信息jmap -clstats <pid> 输出类加载器信息...
Scala编程指南：第一版第六版
"Scala编程.pdf" 本书是一本关于Scala编程的中文版指南，由Scala的创始人Martin Odersky、Lex Spoon和Bill Venners合作撰写。Scala是一种多范式编程语言，设计目标是融合面向对象编程和函数式编程的特性。作者们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值