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，它可以接受不同类型的内容。在创建 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)
}

泛型的协变和逆变

1. 语法

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

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

class MyList[T] //不变

2. 说明

• 协变：
  Son 是 Father 的子类，则 MyList[Son] 也作为 MyList[Father]的"子类"。
• 逆变：
  Son 是 Father 的子类，则 MyList[Son]作为 MyList[Father]的"父类"。
• 不变：
  Son 是 Father 的子类，则 MyList[Father]与 MyList[Son]"无父子关系"。

3. 案例

//泛型模板
//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]{ //泛型下限
}

2. 说明
   泛型的上下限的作用是对传入的泛型进行限定。
3. 案例

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)

2. 说明
   上下文限定是将泛型和隐式转换的结合产物，以下两者功能相同，使用上下文限定[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)