北京网站建设还公司,中国建设人才网络学院登录入口,发帖平台,网站导航素材下载1 单例对象
在编写 Java 程序时#xff0c;我们经常会通过编写静态方法代码#xff0c;去封装常用的 Utility 类。
在 Scala 中没有静态成员这一概念#xff0c;所以#xff0c;如果我们要定义静态属性或方法#xff0c;就需要使用 Scala 的单例对象 object。Scala 的对…1 单例对象
在编写 Java 程序时我们经常会通过编写静态方法代码去封装常用的 Utility 类。
在 Scala 中没有静态成员这一概念所以如果我们要定义静态属性或方法就需要使用 Scala 的单例对象 object。Scala 的对象跟 Javascript 中定义一个对象概念是差不多的。
下面定义一个球员对象并在 main 函数打印球员对象的相关属性
/*** 球员对象*/
object FootballPlayerObject {/*** 姓名*/var NAME: String Mohamed Salah/*** 年纪*/var AGE: Int 31/*** 所在俱乐部*/var CLUB: String Liverpool/*** 定义入口 main 函数打印球员对象相关属性* param args*/def main(args: Array[String]): Unit {System.out.println(FootballPlayerObject.NAME)System.out.println(FootballPlayerObject.AGE)System.out.println(FootballPlayerObject.CLUB)}
}2 工具类案例
我们可以利用单例对象实现工具类例如下面实现了一个简易的 DateUtils
import org.joda.time.format.DateTimeFormat/*** 日期时间工具类*/
object DateUtils {val TIME_FORMAT DateTimeFormat.forPattern(yyyy-MM-dd HH:mm:ss)/*** 判断一个时间是否在另一个时间之前** param time1 第一个时间* param time2 第二个时间* return 判断结果*/def before(time1: String, time2: String): Boolean {TIME_FORMAT.parseDateTime(time1).isBefore(TIME_FORMAT.parseDateTime(time2))}/*** 判断一个时间是否在另一个时间之后** param time1 第一个时间* param time2 第二个时间* return 判断结果*/def after(time1: String, time2: String): Boolean {TIME_FORMAT.parseDateTime(time1).isAfter(TIME_FORMAT.parseDateTime(time2))}/*** 计算时间差值单位为秒** param time1 时间1* param time2 时间2* return 差值*/def minus(time1: String, time2: String): Int {((TIME_FORMAT.parseDateTime(time1).getMillis - TIME_FORMAT.parseDateTime(time2).getMillis) / 1000).toInt}def main(args: Array[String]): Unit {println(DateUtils.before(2023-01-01 00:00:00, 2024-01-01 00:00:00))println(DateUtils.after(2023-01-01 00:00:00, 2024-01-01 00:00:00))println(DateUtils.minus(2024-01-01 00:00:00, 2023-01-01 00:00:00))}
}运行后控制台打印
true
false
315360003 伴生对象
如果想一个类既需要静态成员又需要实例成员在 Scala 中可以使用伴生对象companion object来实现。
3.1 伴生对象的定义
伴生对象有以下特点
(1) 伴生对象 和 类 必须要在同一个 class 文件中。
(2) 伴生对象名字要和类名字一致。
(3) 伴生类 和 伴生对象可以互相访问彼此的 private 属性。
/*** 球员信息类*/
class PlayerInfo(private var playerName: String, var age: Int, var club: String) {def hello(): String {sHey buddy, I am ${this.playerName} of ${this.club}, ${this.age} years old!}
}/*** PlayerInfo 类的共生对象*/
object PlayerInfo {/*** 定义球员梦想*/private var dream: String The dream of %s is achieving World Cup/*** 打印球员梦想*/def myDream(playerName: String): String {String.format(this.dream, playerName)}/*** main 方法* param args*/def main(args: Array[String]): Unit {// 定义球员信息对象val player: PlayerInfo new PlayerInfo(Erling Haaland, 23, Manchester City F.C.)println(player.hello())// 执行共生对象的 myDream 方法// 可以访问共生类的私有 playerNameprintln(this.myDream(player.playerName))}
}3.2 apply 及 unapply 方法
在 Scala 中apply 和 unapply 是两个特殊的方法它们通常与伴生对象一起使用并且在模式匹配、构造对象等方面发挥着重要作用。
3.2.1 apply 方法
apply 方法通常用于对象的构造。当你调用类似 ClassName(args) 的代码时实际上是调用了类的伴生对象的 apply 方法。这使得你可以像调用函数一样构造对象而不需要显式地使用 new 关键字。
例如我们在定义一个列表时并不需要使用 new: val list List(1, 2, 3)下面为球员信息类的共生对象定义了 apply 方法
/*** 球员信息类*/
class PlayerInfo(private var playerName: String, var age: Int, var club: String) {def hello(): String {sHey buddy, I am ${this.playerName} of ${this.club}, ${this.age} years old!}
}/*** PlayerInfo 类的共生对象*/
object PlayerInfo {/*** 定义球员梦想*/private var dream: String The dream of %s is achieving World Cup/*** 打印球员梦想*/def myDream(playerName: String): String {String.format(this.dream, playerName)}/*** 定义 apply 方法新建一个 PlayerInfo 对象** param playerName 球员名称* param age 年龄* return {link PlayerInfo} 对象*/def apply(playerName: String, age: Int): PlayerInfo new PlayerInfo(playerName, age, Manchester City F.C.)/*** main 方法* param args*/def main(args: Array[String]): Unit {// 定义球员信息对象有了 apply 方法后不再需要 new 关键字val player: PlayerInfo PlayerInfo(Erling Haaland, 23)println(player.hello())// 执行共生对象的 myDream 方法// 可以访问共生类的私有 playerNameprintln(this.myDream(player.playerName))}
}3.2.2 unapply 方法
unapply 方法通常用于模式匹配。它是 Extractor 模式的一部分允许你从对象中提取部分信息并将其与模式进行匹配。
例如
/*** 球员信息类*/
class PlayerInfo(private var playerName: String, var age: Int, var club: String) {def hello(): String {sHey buddy, I am ${this.playerName} of ${this.club}, ${this.age} years old!}
}/*** PlayerInfo 类的共生对象*/
object PlayerInfo {/*** 定义 apply 方法新建一个 PlayerInfo 对象** param playerName 球员名称* param age 年龄* return {link PlayerInfo} 对象*/def apply(playerName: String, age: Int): PlayerInfo new PlayerInfo(playerName, age, Manchester City F.C.)/*** 定义 unapply作为提取器提取球员 姓名年龄俱乐部* param playerInfo 球员信息对象* return*/def unapply(playerInfo: PlayerInfo): Option[(String, Int, String)] Some(playerInfo.playerName, playerInfo.age, playerInfo.club)/*** main 方法* param args*/def main(args: Array[String]): Unit {// 定义球员信息对象有了 apply 方法后不再需要 new 关键字val player: PlayerInfo PlayerInfo(Erling Haaland, 23)player match {case PlayerInfo(name, age, club) println(sname: ${name}, age: ${age}, club: ${club})case _ println(Not matched)}}
}在上面的代码中unapply 方法从 PlayerInfo 对象中提取了名字、年龄和俱乐部并将它们作为元组返回。在 match 表达式中case PlayerInfo(name, age, club) 部分使用了模式匹配它调用了 PlayerInfo 伴生对象的 unapply 方法来提取 PlayerInfo 对象的信息并与模式中的名字、年龄和俱乐部进行匹配。
