제네릭 및 암시 적 변환

제네릭

일반적인 클래스 [T]

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

    // 通过传递的参数自动推断泛型类型 (参数中用到了所有的泛型)
    val s1 = new Student("丽萨",1)
    // 直接指定泛型类型
    val s2 = new Student[String,Int]("明明",2)
    // 指定参数类型的父类为泛型
    val s3 = new Student[Any,Any]("小刚",3)
}

// 泛型类
class Student[T,S](info1: T, info2: S){
    println(info1,info2)
}

일반 함수 [T]

def fun[T](field: T): Unit ={
    println(field)
}

일반 경계 [T <: 부모] [T> 서브]

• <: 상한 지정 일반적인 유형은 "특정 유형"또는 "서브 클래스"의 몇몇 유형이어야 표현
• > : 일반 타입이 "어떤 종류의"또는 "부모"의 일종해야합니다, 하한 표현 된 나타냅니다

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

    up[C2](new C2)
    // 报错! 超出上边界
    // up(new C1)


    // 必须需要指定[class], new C3会自动转为匹配的的父类
    down[C3](new C3)

}

// 指定泛型上限
def up[T <: C2](field: T): Unit = {
    println("Up")
}

// 指定泛型下限
def down[T >: C2](field: T): Unit = {
    println("Down")
}


class C1 {}

class C2 extends C1 {
    println("C2 < C1")
}

class C3 extends C2 {
    println("C3 < C2 < C1")
}

class C4 {
    println("C4")
}

보기 정의

// 视图界定,希望跨越类继承层次结构时，可以使用视图界定来实现的
def view[T <% Comparable[T]](first: T, second: T): Unit = {
    println(first.compareTo(second))
}

// 泛型视图界定
// Int隐式转换成RichInt，RichInt是Comparable[Int]的子类
view[Int](4, 2)

공분산 및

공변

class C1 {}

class C2 extends C1 {
    println("C2 < C1")
}

// 协变, 子类可以赋值给父类型
val child = new C5[C2](new C2)
val parent: C5[C1] = child

// 协变泛型
class C5[+T](field: T) {}

인버터

class C1 {}

class C2 extends C1 {
    println("C2 < C1")
}

// 逆变泛型
class C6[-T](field: T) {}

// 逆变, 父类可以赋值给子类
val parent1 = new C6[C1](new C1)
val child1: C6[C2] = parent1

암시 적 변환

// 定义Double类型 隐式转换为 Int类型
implicit def doubleToInt(d: Double) = d.toInt

val i: Int = 3.14
println(s"i = $i")

i = 3

설명 : 암시 데프 메소드 명 (변수 명 변환 타입) : 변환 결과를 반환 =

// 调入隐式转换
import spark.implicits._

타이밍 암시 적 변환이 발생

일관성없는 형식 매개 변수 및 유형의 실제 요구

def fun(x: Int) = {}

fun(3.14)

메소드가 호출 될 때 오브젝트가 존재하지 않습니다

class C1 {
    def fun() = {}
}

val c = new C1()
c.read()

암시 적 매개 변수

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

    // 定义隐式变量, 使用时会隐式返回 C1类的对象
    implicit val c = new C1()

    funC("log!")
}

def funC(info: String)(implicit c1: C1): Unit = {
    c1.fun(info)
}

class C1 {
    def fun(info: String) = {
        println("fun info = " + info)
    }
}

fun info = log!

참조 : https://www.cnblogs.com/jacksu-tencent/p/4979666.html