Scala中的类型检查和转换，以及泛型，scala泛型的协变和逆变
Scala中的类型检查和转换，以及泛型
类型检查和转换
- 说明
（1） obj.isInstanceOf[T]：判断 obj 是不是T 类型。
（2） obj.asInstanceOf[T]：将 obj 强转成 T 类型。
（3） classOf 获取对象的类名。 - 案例
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，它可以接受不同类型的内容。在创建 intBox 和 stringBox 实例时，我们分别指定了 T 的具体类型为 Int 和 String。通过 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)
}
泛型的协变和逆变
- 语法
class MyList[+T]{ //协变
}
class MyList[-T]{ //逆变
}
class MyList[T] //不变
- 说明
- 协变：
Son 是 Father 的子类，则 MyList[Son] 也作为 MyList[Father]的“子类”。 - 逆变：
Son 是 Father 的子类，则 MyList[Son]作为 MyList[Father]的“父类”。 - 不变：
Son 是 Father 的子类，则 MyList[Father]与 MyList[Son]“无父子关系”。
- 案例
//泛型模板
//class MyList{}
//不变
//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泛型上下限
- 语法
Class PersonList[T <: Person]{ //泛型上限
}
Class PersonList[T >: Person]{ //泛型下限
}
- 说明
泛型的上下限的作用是对传入的泛型进行限定。 - 案例
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)
}
}
上下文限定
- 语法
def f[A : B](a: A) = println(a) //等同于 def f[A](a:A)(implicit arg:B[A])=println(a)
- 说明
上下文限定是将泛型和隐式转换的结合产物，以下两者功能相同，使用上下文限定[A :Ordering]之后，方法内无法使用隐式参数名调用隐式参数，需要通过 implicitly[Ordering[A]]获取隐式变量，如果此时无法查找到对应类型的隐式变量，会发生出错误。
implicit val x = 1
val y = implicitly[Int]
val z = implicitly[Double]
3、例子
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)