Scala中的类型检查和转换,以及泛型,scala泛型的协变和逆变

这篇具有很好参考价值的文章主要介绍了Scala中的类型检查和转换,以及泛型,scala泛型的协变和逆变。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

Scala中的类型检查和转换,以及泛型

类型检查和转换

  1. 说明
    (1) obj.isInstanceOf[T]:判断 obj 是不是T 类型。
    (2) obj.asInstanceOf[T]:将 obj 强转成 T 类型。
    (3) classOf 获取对象的类名。
  2. 案例
class Person{

}

object Person {
def main(args: Array[String]): Unit = {

val person = new Person

//(1)判断对象是否为某个类型的实例
val boolPerson: Boolean = person.isInstanceOf[Person]

if ( boolPerson) {
//(2)将对象转换为某个类型的实例
val p1: Person = person.asInstanceOf[Person]
println(p1)
}

//(3)获取类的信息
val pClass: Class[Person] = classOf[Person]
println(pClass)
}
}

枚举类与应用类

1.说明
(1)枚举类:需要继承 Enumeration
(2)应用类:需要继承App
2. 案例

object Test {
def main(args: Array[String]): Unit = {

println(Color.RED)
}
}
// 枚举类
object Color extends Enumeration {
val RED = Value(1, "red")
val YELLOW = Value(2, "yellow")
val BLUE = Value(3, "blue")
}
// 应用类
object Test20 extends App {
println("xxxxxxxxxxx");
}

Type 定义新类型

1.说明
使用 type 关键字可以定义新的数据数据类型名称,本质上就是类型的一个别名.
2. 案例

object Test {
def main(args: Array[String]): Unit = {
//定义一个类型S
type S=String
var v:S="abc"
def test():S="xyz"
}
}

Scala的泛型

Scala 中的泛型可以通过类型参数来实现,用于增加代码的灵活性和重用性。在 Scala 中,泛型可以应用于类、特质和方法等不同的上下文。

下面是一些示例来说明 Scala 中如何使用泛型:

1. 类的泛型参数:

class Box[T](content: T) {
  def getContent: T = content
}

val intBox = new Box[Int](42)
val stringBox = new Box[String]("Hello")

val intValue: Int = intBox.getContent
val stringValue: String = stringBox.getContent

在上述示例中,Box 类使用一个类型参数 T,它可以接受不同类型的内容。在创建 intBoxstringBox 实例时,我们分别指定了 T 的具体类型为 IntString。通过 getContent 方法,我们可以获得相应的内容,并将其转换为对应的类型。

2. 方法的泛型参数:

def printContent[T](content: T): Unit = {
  println(content)
}

printContent(42)        // 输出:42
printContent("Hello")   // 输出:Hello

在上述示例中,printContent 方法也使用了一个类型参数 T。该方法可以接受任意类型的参数,并将其打印出来。

Scala 还支持上界(upper bounds)和视图界定(view bounds)等高级的泛型概念,用于对类型参数进行约束或扩展。例如,可以使用上界来限制类型参数必须是某个类型的子类,使用视图界定则可以通过隐式转换来实现对类型参数的扩展。

总之,Scala 中的泛型能够极大地提升代码的灵活性和重用性,使得我们可以编写更加通用和类型安全的代码。

3.泛型例子

import scala.reflect.ClassTag
 
//定义带泛型的类
class Triple[F, S, T](val first: F, val second: S, val third: T)
 
object Test extends App{
  val triple = new Triple("Spark", 3, 3.14)
  val bigData = new Triple[String, String, Char]("spark", "hadoop", 'd')
 
  //定义带泛型的函数
  def getData[T](list: List[T]) = list(list.length / 2)
  println(getData(List("spark", "hadoop", "r")))
 
  //讲泛型函数传递给一个函数, 必须指定类型和_
  val f = getData[Int] _
  println(f(List(1, 2, 3, 4)))
 
  def biuldArray[T: ClassTag](len: Int) = new Array[T](len)
  println(biuldArray[Int](5).toList)
 
  //f的输入参数是A类型,产出是List[A], b必须是A类型
  def foo[A, B](f: A => List[A], b: A) = f(b)
}

泛型的协变和逆变

  1. 语法

class MyList[+T]{ //协变
}

class MyList[-T]{ //逆变
}

class MyList[T] //不变

  1. 说明
  • 协变:
    Son 是 Father 的子类,则 MyList[Son] 也作为 MyList[Father]的“子类”。
  • 逆变:
    Son 是 Father 的子类,则 MyList[Son]作为 MyList[Father]的“父类”。
  • 不变:
    Son 是 Father 的子类,则 MyList[Father]与 MyList[Son]“无父子关系”。
  1. 案例
//泛型模板
//class MyList<T>{}
//不变
//class MyList[T]{}
//协变
//class MyList[+T]{}
//逆变
//class MyList[-T]{}

class Parent{}
class Child extends Parent{}
class SubChild extends Child{}

object Scala_TestGeneric {
def main(args: Array[String]): Unit = {
//var s:MyList[Child] = new MyList[SubChild]
}
}

Scala泛型上下限

  1. 语法
Class PersonList[T <: Person]{ //泛型上限
}
Class PersonList[T >: Person]{ //泛型下限
}
  1. 说明
    泛型的上下限的作用是对传入的泛型进行限定。
  2. 案例
class Parent{}
class Child extends Parent{}
class SubChild extends Child{}

object Scala_TestGeneric {
def main(args: Array[String]): Unit = {

//test(classOf[SubChild])
//test[Child](new SubChild)
}
//泛型通配符之上限
//def test[A <: Child](a:Class[A]): Unit ={
// println(a)
//}

//泛型通配符之下限
//def test[A >: Child](a:Class[A]): Unit ={
// println(a)
//}

//泛型通配符之下限 形式扩展
def test[A >: Child](a:A): Unit ={
println(a.getClass.getName)
}
}

上下文限定

  1. 语法
def f[A : B](a: A) = println(a) //等同于 def f[A](a:A)(implicit arg:B[A])=println(a)
  1. 说明
    上下文限定是将泛型和隐式转换的结合产物,以下两者功能相同,使用上下文限定[A :Ordering]之后,方法内无法使用隐式参数名调用隐式参数,需要通过 implicitly[Ordering[A]]获取隐式变量,如果此时无法查找到对应类型的隐式变量,会发生出错误。
implicit val x = 1
val y = implicitly[Int]
val z = implicitly[Double]

3、例子文章来源地址https://www.toymoban.com/news/detail-689691.html

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)

到了这里,关于Scala中的类型检查和转换,以及泛型,scala泛型的协变和逆变的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • IntelliJ IDEA下基于Scala实现的Git检查工具

    本文使用Scala实现自定义的Git检查工具,读者可以基于本文的示例进行扩展与实现,也可以进行其他应用方向的尝试。 在实现Git检查工具之前需要知道程序究竟要做什么。我们知道,在管理Git分支时可以进行代码合并操作,这样可以将其他开发者提交的内容同步到当前分支中,当用

    2024年02月12日
    浏览(39)
  • 【Java 基础篇】Java类型通配符:解密泛型的神秘面纱

    在Java中,类型通配符(Type Wildcard)是泛型的重要概念之一。它使得我们能够更加灵活地处理泛型类型,使代码更通用且可复用。本文将深入探讨Java类型通配符的用法、语法和最佳实践。 类型通配符是一个用问号 ? 表示的通配符,它可以用于泛型类、方法和通配符边界。类型

    2024年02月07日
    浏览(51)
  • Scala-隐式转换

    精度小的类型可以自动转换为精度大的类型,这个转换过程无需开发人员参与,由编译器自动完成,这个转换操作我们称之为隐式转换。 如果程序编译出错,编译器会尝试在整个的作用域中查找能够让程序编译通过的方式 如果找到,那么编译器会尝试二次编译,让之前编译

    2024年01月20日
    浏览(42)
  • scala array类型参数

    在Scala中,数组(Array)是一种用于存储相同类型元素的数据结构。数组可以用于保存基本数据类型和自定义数据类型的元素。当定义数组类型参数时,您通常是在函数、类或方法签名中使用它们。以下是一些有关Scala数组类型参数的示例: 在函数中使用数组类型参数: def

    2024年02月11日
    浏览(26)
  • 【Scala入门】Scala下载及安装(Windows)以及Idea创建第一个scala项目

    目录 一、安装准备 二、Scala下载安装 三、Idea 创建Scala项目 在安装之前,确保你的电脑上装有Jdk 8(Jdk 1.8),且环境变量配置正确。如果没有安装Jdk,请参照其他文章先安装Jdk 8(Jdk 1.8)。 (1)确认环境变量方法:使用Win + R 快捷键调出下面窗口,输入“cmd”,按下回车。

    2024年02月05日
    浏览(52)
  • Scala之模式匹配与隐式转换

    目录 模式匹配: 基础语法如下: 模式守卫: 类型匹配: 对象匹配 样例类: 偏函数: 偏函数的化简写法: 偏函数的使用: 隐式转换: 官方定义: 个人理解: 隐式函数: 隐式转换的步骤: 隐式参数: 参数对比样例: 隐式类: Scala中的模式匹配相当于Java中的switch 在Ja

    2024年02月04日
    浏览(40)
  • Java调用scala中map转换问题处理

    网上代码 把Javamap转为scala的map代码 我自身是用scala2.11.8, jdk8, 同样代码在本机报错如下: toSeq()方法就一个方法还会不明确也是奇葩, 遂去翻源码,然后发现seq和其他集和对象关系  那么算了不去转到seq了, 我转到他的子类总改明确吧, 遂把代码改成以下两种方式分别实验:  另外

    2024年02月11日
    浏览(41)
  • Scala 如何调试隐式转换--隐式转换代码的显示展示

    在需要隐式转换的地方,把需要的参数显示的写出。 在terminal中 利用 scalac -Xprint:typer xxx.scala 方法打印添加了隐式值的代码示例。 对于复杂的工程来说,直接跑到terminal执行 scalac -Xprint:typer xxx.scala 会报很多库不存在的错误。 可在idea的设置中,找到如下配置,写入 -Xprint:ty

    2024年02月12日
    浏览(42)
  • Scala语言入门以及基本语法

    scala在一种简洁的高级语言中结合了面向对象和函数式编程。Scala的静态类型有助于避免复杂应用程序中的错误,它的JVM和JavaScript运行时使您可以构建高性能系统,并轻松访问庞大的库生态系统。 几大特性 Scala运行在JVM上,因此Java和Scala实现完全无缝集成。 类型推理。 并发

    2024年02月01日
    浏览(44)
  • 【Scala中的package】

    2024年04月15日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包