Scala高级语法

最新推荐文章于 2023-04-29 10:54:50 发布
最新推荐文章于 2023-04-29 10:54:50 发布
阅读量182 收藏
点赞数
分类专栏： Scala
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoyaGrace/article/details/105240601
版权

柯里化

  • 柯里化是一个过程
  • 把一个参数列表中的多个参数， 转换为多个参数列表
  • 科里化可以支持隐式转换
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
object Currying {
  "正常方法"
  def m1(a: Int, b: Int): Int = a + b
 
  "柯里化方法"
  def m2(a: Int)(b: Int) = a + b
  def m3(a: Int)(b: Int, c: Int) = a + b + c
  def m4(a: Int, b: Int)(c: Int, d: Int) = a + b + c + d
 
  def main(args: Array[String]): Unit = {
    println("正常方法调用：" + m1(10, 20))
    println("柯里化方法调用：" + m2(10)(20))
    println("柯里化方法调用：" + m3(10)(20, 30))
    println("柯里化方法调用：" + m4(10, 20)(30, 40))
  }
}


隐式参数

  • 用 implicit 关键字修饰的参数，就是隐式参数
  • 隐式参数的值从哪儿取
    • 从上下文环境中，最多找到一个和隐式参数类型一致，且用implicit修饰的变量，如果找到多个则报错
    • 如果上下文环境中没有，则使用默认值
    • 如果找不到，也没有默认值，则报错
  • implicit 只能作用于最后一个参数列表，一个参数列表中只能由一个 implicit 关键字
    • 关键字只能放在最后一个参数列表中，而且修饰该参数列表中的所有参数
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
object ImpDemo {
  implicit val defalut1: Int = 20
  // implicit val defalut2: Int = 30
  implicit val defalut3: Double = 10
 
  def m1(a: Int)(implicit b: Int = 10): Int = {
    if (a > b) a else b
  }
 
  def m2(a: Int)(implicit b: Int, c: Double): Double = a + b + c
 
  def main(args: Array[String]): Unit = {
    println(m1(5))
    println(m1(5)(30))
    println(m2(10))
  }
}


隐式转换

  • 主要指隐式方法和隐式函数
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
object ImpMethod {
  implicit def str2int(str: String): Int = Integer.parseInt(str)
 
  def main(args: Array[String]): Unit = {
    println(1 to 3)
    "这里发生了隐式转换,这里调用了RichInt的方法"
    "implicit 修饰的方法，方法参数是Int，返回值是RichInt"
    "当Int 类型上调用to方法，Int上没有这个方法，但是RichInt上有，发现有隐式方法从Int->RichRint"
    println(1.to(3))
    val x: Int = "123"
    println(x)
  }
}

 

[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
import java.io.File
import scala.io.Source
class RichFile(f: File) {
  def read(): String = Source.fromFile(f).getLines().mkString("\r\n");
}
object RichFile {
  // 隐式转换
  implicit def file2RichFile(f: File): RichFile = new RichFile(f)
  def main(args: Array[String]): Unit = {
    val path: String = "C:/Users/unkonw_yu/Desktop/scala/rating.json"
    val f = new File(path)
    val lines = f.read()
    println(lines)
  }
}

 

  • 如果隐式方法和隐式函数都存在，优先使用函数
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
class RichFile(f: File) {
  def read(): String = Source.fromFile(f).getLines().mkString("\r\n");
}
object RichFile {
  // 隐式转换
  implicit def file2RichFile(f: File): RichFile = new RichFile(f)
  implicit val file2RichFile2 = (f: File) => {
    println("调用函数")
    new RichFile(f)
  }
  def main(args: Array[String]): Unit = {
    val path: String = "C:/Users/unkonw_yu/Desktop/scala/rating.json"
    val f = new File(path)
    val lines = f.read()
    println(lines)
  }
}

 

  • 可以导入外部的隐式转换 ，类和object导入方式不一样
[Scala] 纯文本查看 复制代码
?
1
2
3
4
5
6
7
import java.io.File
class MyImpl {
  implicit def file2RichFile(f: File): RichFile = new RichFile(f)
}
object MyImpl {
  implicit def file2RichFile(f: File): RichFile = new RichFile(f)
}

 

[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
class RichFile(f: File) {
  def read(): String = Source.fromFile(f).getLines().mkString("\r\n");
}
object RichFile {
  "引入 object 的隐式方法"
  import MyImpl.file2RichFile
 
  "引入 class 的隐式方法"
  private val imp = new MyImpl
  import imp.file2RichFile
 
  def main(args: Array[String]): Unit = {
    val path: String = "C:/Users/unkonw_yu/Desktop/scala/rating.json"
    val f = new File(path)
    val lines = f.read()
    println(lines)
  }
}


泛型

[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
abstract class Message[T](msg: T) {
    def getMsg(): T = msg
}
class IntMsg(msg: Int) extends Message(msg)
class StrMsg(msg: String) extends Message(msg)
 
object TestMsg {
    def main(args: Array[String]): Unit = {
        val msg1 = new IntMsg(123)
        println(msg1.getMsg())
        val msg2 = new StrMsg("hello")
        println(msg2.getMsg())
    }
}

 

[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
class Clothes[ColorTypes](val color: ColorTypes)
 
"枚举"
object ColorTypes extends Enumeration {
    type CT = Value
    val RED = Value(0)
    val BLACK = Value(1)
    val GREEN = Value(2)
}
 
object TestMsg {
    def main(args: Array[String]): Unit = {
        val colthes1 = new Clothes[ColorTypes.Value](ColorTypes.RED)
        val colthes2 = new Clothes[CT](ColorTypes.GREEN)
        println(colthes1.color)
        println(colthes2.color)
    }
}


比较器

  • Java 中的比较器
    • Comparable
    • Comparator
  • scala中的比较器
    • Ordered --> Comparable
    • Ordering --> Comparator
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util
import java.util.Collections
 
class Student(val name: String, val age: Int, val fv: Int) extends Ordered[Student] {
    override def compare(that: Student): Int = this.fv - that.fv
    override def toString: String = s"${name},${age},${fv}"
}
 
object Student {
    def main(args: Array[String]): Unit = {
        val sList = new util.ArrayList[Student]()
         
        val s1 = new Student("zs",23,999)
        val s2 = new Student("li",24,998)
        val s3 = new Student("ww",25,997)
         
        sList.add(s1)
        sList.add(s2)
        sList.add(s3)
         
        Collections.sort(sList)
        println(sList)
         
        Collections.sort(sList,new Ordering[Student]{
            override def compare(x: Student, y: Student): Int = y.fv - x.fv
        })
        println(sList)
    }
}


泛型约束上界

  • Java
    • <T extends P>
    • <? extends P>
  • Scala
    • T <: P
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
任意类型比较"
class ComparTest[T](t1: T, t2: T) {
  def myEquals() = t1 == t2
}
"Comparable 的子类"
class ComparaTest2[T <: Ordered[T]](t1: T, t2: T) {
  def myEquals() = t1 compareTo t2
}
object ComparTest {
  def main(args: Array[String]): Unit = {
    val s1 = new Student("zs", 23, 999)
    val s2 = new Student("li", 24, 998)
 
    val comp1 = new ComparTest[Student](s1, s2)
    println(comp1.myEquals())
    val comp2 = new ComparTest[Int](1, 2)
    println(comp2.myEquals())
 
    "报错，Int没有混入Ordered特质"
    val comp3 = new ComparaTest2[Int](1, 2)
    println(comp3.myEquals())
 
    "正常运行"
    val comp4 = new ComparaTest2[Student](s1,s2)
    println(comp4.myEquals())
  }
}


下界

[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
object LowerBounds {
    val f1 = (x: Int, y: Int) => x + y
    val f2 = (a: AnyVal, b: AnyVal) => a.asInstanceOf[Int] + b.asInstanceOf[Int]
    val f3 = (a: Any, b: Any) => a
    val f4 = (a: Any, b: AnyRef) => a
    val f5 = (a: AnyRef, b: AnyRef) => a
 
    def main(args: Array[String]): Unit = {
        val arr = Array(1, 3, 5, 7, 9)
        // def reduce[A1 >: A]
        val res1 = arr.reduce(_ + _)
        val res2 = arr.reduce(f1)
        // AnyVal 是 Int 的父类，可以传递
        val res3 = arr.reduce(f2)
        // Any 是 Int 的顶级父类，可以传递
        val res4 = arr.reduce(f3)
         
        // AnyRef 不是 Int 的父类，调用失败
        // val res5 = arr.reduce(f4)
        // val res6 = arr.reduce(f5)
    }
}



协变逆变

[XML] 纯文本查看 复制代码
?
1
2
3
4
5
[T]  正常的泛型      不变
    [T <: Test]                上界
    [T >: Test]                下界
[+T]                            协变
[-T]                                逆变

 

[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Card[T] {}
class Card[+T] {}
class Card[-T] {}
 
class Metting[T] {
  def metting(c: Card[T]): Unit = println("人们代表大会")
}
 
// 层级关系
class ChangWei
 
class Leader extends ChangWei
 
class Flower extends Leader
 
object Card {
  def main(args: Array[String]): Unit = {
    val metting = new Metting[ChangWei]()
 
    val changweiCart = new Card[ChangWei]
    val leaderCart = new Card[Leader]
    val flowerCart = new Card[Flower]
 
    "class Card[T]"
    metting.metting(changweiCart)
    "下面的会报错"
    // metting.metting(leaderCart)
    // metting.metting(flowerCart)
 
    "class Cart[+T],都不会报错"
    metting.metting(changweiCart)
    metting.metting(leaderCart)
    metting.metting(flowerCart)
 
    "class Cart[-T]"
    val leaderMetting = new Metting[Leader]
    leaderMetting.metting(changweiCart)
    leaderMetting.metting(leaderCart)
    "下面代码会报错"
    // leaderMetting.metting(flowerCart)
  }
}


CallByName 和 CallByValue

  • 函数调用中的两种形式
    • CallByName(传名调用)
      • 传递的参数，在调用的时候才会真正的执行
    • CallByValue(传值调用)
      • 先计算调用的结果，然后再传递
[Scala] 纯文本查看 复制代码 柯里化
  • 柯里化是一个过程
  • 把一个参数列表中的多个参数， 转换为多个参数列表
  • 科里化可以支持隐式转换
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
object Currying {
  "正常方法"
  def m1(a: Int, b: Int): Int = a + b
 
  "柯里化方法"
  def m2(a: Int)(b: Int) = a + b
  def m3(a: Int)(b: Int, c: Int) = a + b + c
  def m4(a: Int, b: Int)(c: Int, d: Int) = a + b + c + d
 
  def main(args: Array[String]): Unit = {
    println("正常方法调用：" + m1(10, 20))
    println("柯里化方法调用：" + m2(10)(20))
    println("柯里化方法调用：" + m3(10)(20, 30))
    println("柯里化方法调用：" + m4(10, 20)(30, 40))
  }
}

隐式参数
  • 用 implicit 关键字修饰的参数，就是隐式参数
  • 隐式参数的值从哪儿取
    • 从上下文环境中，最多找到一个和隐式参数类型一致，且用implicit修饰的变量，如果找到多个则报错
    • 如果上下文环境中没有，则使用默认值
    • 如果找不到，也没有默认值，则报错
  • implicit 只能作用于最后一个参数列表，一个参数列表中只能由一个 implicit 关键字
    • 关键字只能放在最后一个参数列表中，而且修饰该参数列表中的所有参数
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
object ImpDemo {
  implicit val defalut1: Int = 20
  // implicit val defalut2: Int = 30
  implicit val defalut3: Double = 10
 
  def m1(a: Int)(implicit b: Int = 10): Int = {
    if (a > b) a else b
  }
 
  def m2(a: Int)(implicit b: Int, c: Double): Double = a + b + c
 
  def main(args: Array[String]): Unit = {
    println(m1(5))
    println(m1(5)(30))
    println(m2(10))
  }
}

隐式转换
  • 主要指隐式方法和隐式函数
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
object ImpMethod {
  implicit def str2int(str: String): Int = Integer.parseInt(str)
 
  def main(args: Array[String]): Unit = {
    println(1 to 3)
    "这里发生了隐式转换,这里调用了RichInt的方法"
    "implicit 修饰的方法，方法参数是Int，返回值是RichInt"
    "当Int 类型上调用to方法，Int上没有这个方法，但是RichInt上有，发现有隐式方法从Int->RichRint"
    println(1.to(3))
    val x: Int = "123"
    println(x)
  }
}
 
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
import java.io.File
import scala.io.Source
class RichFile(f: File) {
  def read(): String = Source.fromFile(f).getLines().mkString("\r\n");
}
object RichFile {
  // 隐式转换
  implicit def file2RichFile(f: File): RichFile = new RichFile(f)
  def main(args: Array[String]): Unit = {
    val path: String = "C:/Users/unkonw_yu/Desktop/scala/rating.json"
    val f = new File(path)
    val lines = f.read()
    println(lines)
  }
}
 
  • 如果隐式方法和隐式函数都存在，优先使用函数
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
class RichFile(f: File) {
  def read(): String = Source.fromFile(f).getLines().mkString("\r\n");
}
object RichFile {
  // 隐式转换
  implicit def file2RichFile(f: File): RichFile = new RichFile(f)
  implicit val file2RichFile2 = (f: File) => {
    println("调用函数")
    new RichFile(f)
  }
  def main(args: Array[String]): Unit = {
    val path: String = "C:/Users/unkonw_yu/Desktop/scala/rating.json"
    val f = new File(path)
    val lines = f.read()
    println(lines)
  }
}
 
  • 可以导入外部的隐式转换 ，类和object导入方式不一样
[Scala] 纯文本查看 复制代码
?
1
2
3
4
5
6
7
import java.io.File
class MyImpl {
  implicit def file2RichFile(f: File): RichFile = new RichFile(f)
}
object MyImpl {
  implicit def file2RichFile(f: File): RichFile = new RichFile(f)
}
 
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
class RichFile(f: File) {
  def read(): String = Source.fromFile(f).getLines().mkString("\r\n");
}
object RichFile {
  "引入 object 的隐式方法"
  import MyImpl.file2RichFile
 
  "引入 class 的隐式方法"
  private val imp = new MyImpl
  import imp.file2RichFile
 
  def main(args: Array[String]): Unit = {
    val path: String = "C:/Users/unkonw_yu/Desktop/scala/rating.json"
    val f = new File(path)
    val lines = f.read()
    println(lines)
  }
}

泛型
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
abstract class Message[T](msg: T) {
    def getMsg(): T = msg
}
class IntMsg(msg: Int) extends Message(msg)
class StrMsg(msg: String) extends Message(msg)
 
object TestMsg {
    def main(args: Array[String]): Unit = {
        val msg1 = new IntMsg(123)
        println(msg1.getMsg())
        val msg2 = new StrMsg("hello")
        println(msg2.getMsg())
    }
}
 
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
class Clothes[ColorTypes](val color: ColorTypes)
 
"枚举"
object ColorTypes extends Enumeration {
    type CT = Value
    val RED = Value(0)
    val BLACK = Value(1)
    val GREEN = Value(2)
}
 
object TestMsg {
    def main(args: Array[String]): Unit = {
        val colthes1 = new Clothes[ColorTypes.Value](ColorTypes.RED)
        val colthes2 = new Clothes[CT](ColorTypes.GREEN)
        println(colthes1.color)
        println(colthes2.color)
    }
}

比较器
  • Java 中的比较器
    • Comparable
    • Comparator
  • scala中的比较器
    • Ordered --> Comparable
    • Ordering --> Comparator
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util
import java.util.Collections
 
class Student(val name: String, val age: Int, val fv: Int) extends Ordered[Student] {
    override def compare(that: Student): Int = this.fv - that.fv
    override def toString: String = s"${name},${age},${fv}"
}
 
object Student {
    def main(args: Array[String]): Unit = {
        val sList = new util.ArrayList[Student]()
         
        val s1 = new Student("zs",23,999)
        val s2 = new Student("li",24,998)
        val s3 = new Student("ww",25,997)
         
        sList.add(s1)
        sList.add(s2)
        sList.add(s3)
         
        Collections.sort(sList)
        println(sList)
         
        Collections.sort(sList,new Ordering[Student]{
            override def compare(x: Student, y: Student): Int = y.fv - x.fv
        })
        println(sList)
    }
}

泛型约束 上界
  • Java
    • <T extends P>
    • <? extends P>
  • Scala
    • T <: P
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
任意类型比较"
class ComparTest[T](t1: T, t2: T) {
  def myEquals() = t1 == t2
}
"Comparable 的子类"
class ComparaTest2[T <: Ordered[T]](t1: T, t2: T) {
  def myEquals() = t1 compareTo t2
}
object ComparTest {
  def main(args: Array[String]): Unit = {
    val s1 = new Student("zs", 23, 999)
    val s2 = new Student("li", 24, 998)
 
    val comp1 = new ComparTest[Student](s1, s2)
    println(comp1.myEquals())
    val comp2 = new ComparTest[Int](1, 2)
    println(comp2.myEquals())
 
    "报错，Int没有混入Ordered特质"
    val comp3 = new ComparaTest2[Int](1, 2)
    println(comp3.myEquals())
 
    "正常运行"
    val comp4 = new ComparaTest2[Student](s1,s2)
    println(comp4.myEquals())
  }
}

下界
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
object LowerBounds {
    val f1 = (x: Int, y: Int) => x + y
    val f2 = (a: AnyVal, b: AnyVal) => a.asInstanceOf[Int] + b.asInstanceOf[Int]
    val f3 = (a: Any, b: Any) => a
    val f4 = (a: Any, b: AnyRef) => a
    val f5 = (a: AnyRef, b: AnyRef) => a
 
    def main(args: Array[String]): Unit = {
        val arr = Array(1, 3, 5, 7, 9)
        // def reduce[A1 >: A]
        val res1 = arr.reduce(_ + _)
        val res2 = arr.reduce(f1)
        // AnyVal 是 Int 的父类，可以传递
        val res3 = arr.reduce(f2)
        // Any 是 Int 的顶级父类，可以传递
        val res4 = arr.reduce(f3)
         
        // AnyRef 不是 Int 的父类，调用失败
        // val res5 = arr.reduce(f4)
        // val res6 = arr.reduce(f5)
    }
}


协变逆变
[XML] 纯文本查看 复制代码
?
1
2
3
4
5
[T]  正常的泛型      不变
    [T <: Test]                上界
    [T >: Test]                下界
[+T]                            协变
[-T]                                逆变
 
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
class Card[T] {}
class Card[+T] {}
class Card[-T] {}
 
class Metting[T] {
  def metting(c: Card[T]): Unit = println("人们代表大会")
}
 
// 层级关系
class ChangWei
 
class Leader extends ChangWei
 
class Flower extends Leader
 
object Card {
  def main(args: Array[String]): Unit = {
    val metting = new Metting[ChangWei]()
 
    val changweiCart = new Card[ChangWei]
    val leaderCart = new Card[Leader]
    val flowerCart = new Card[Flower]
 
    "class Card[T]"
    metting.metting(changweiCart)
    "下面的会报错"
    // metting.metting(leaderCart)
    // metting.metting(flowerCart)
 
    "class Cart[+T],都不会报错"
    metting.metting(changweiCart)
    metting.metting(leaderCart)
    metting.metting(flowerCart)
 
    "class Cart[-T]"
    val leaderMetting = new Metting[Leader]
    leaderMetting.metting(changweiCart)
    leaderMetting.metting(leaderCart)
    "下面代码会报错"
    // leaderMetting.metting(flowerCart)
  }
}

CallByName 和 CallByValue
  • 函数调用中的两种形式
    • CallByName(传名调用)
      • 传递的参数，在调用的时候才会真正的执行
    • CallByValue(传值调用)
      • 先计算调用的结果，然后再传递
[Scala] 纯文本查看 复制代码
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
object CallByNameAndValue {
  def getCurTime() ={
    println("调用 method")
    System.currentTimeMillis()
  }
  def callByValie (time:Long): Long = {
    println("call by value")
    time
  }
  def callByName(time: => Long): Long = {
    println("call by name")
    time
  }
  def main(args: Array[String]): Unit = {
    "先执行getCurTime获取当前时间，然后传递给callByValue方法"
    callByValie(getCurTime())
    "先执行callByName方法，当需要用到参数的时候，才取计算结果"
    callByName(getCurTime())
  }
}
?
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
object CallByNameAndValue {
  def getCurTime() ={
    println("调用 method")
    System.currentTimeMillis()
  }
  def callByValie (time:Long): Long = {
    println("call by value")
    time
  }
  def callByName(time: => Long): Long = {
    println("call by name")
    time
  }
  def main(args: Array[String]): Unit = {
    "先执行getCurTime获取当前时间，然后传递给callByValue方法"
    callByValie(getCurTime())
    "先执行callByName方法，当需要用到参数的时候，才取计算结果"
    callByName(getCurTime())
  }
}
xiaoyaGrace
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
scala--型变
timicai的博客
10-26 168
scala--型变一、类型边界二、协变三、逆变四、不变 一、类型边界 在Scala中，类型参数可以有一个类型边界约束 类型上界：将类型限制为另一种类型的子类 T<:A 表示类型变量T应该是类型A的子类 A是具体类型，T是泛型 类型下界：将类型声明为另一种类型的超类 T>:A 表示类型变量T应该是类型A的超类 A是具体类型，T是泛型 二、协变 class Covariant[+T]{ } 对于两种类型 A 和 B，如果 A 是 B 的子类型，那么 Covariant[A] 就是 Covaria
【图文详细 】Scala——泛型
谦卑t
12-24 4936
3、Scala 泛型    3.1、Scala 泛型基础  泛型用于指定方法或类可以接受任意类型参数，参数在实际使用时才被确定，泛型可以有效 地增强程序的适用性，使用泛型可以使得类或方法具有更强的通用性。泛型的典型应用场景 是集合及集合中的方法参数，可以说同 Java 一样，Scala 中泛型无处不在，具体可查看 Scala 的 API   泛型类：指定类可以接受任意类型参数。 泛型方法：...
Scala学习——泛型[T]的6种使用
weixin_43813200的博客
07-21 225
TClassTag的例子。
scala基础之泛型详解
happy19870612's blog
06-02 9873
在Scala中你可以使用类型参数来实现类和函数，这样的类和函数可以用于多种类型。比如Array[T] 你可以存放任意指定类型T的数据. 类、特质、函数都可以有类型参数；将类型参数放在名字后面用方括号括起来   一 泛型类 1.1Java 实现 public class AnimalsA,B> {     private A name;     private B age;
Scala的那些奇怪的符号（二） [+T]和[-T]
菜刚RyuGou的专栏
08-03 4701
看到这个例子就得说说逆变和协变。众所周知，一般面向对象的语言中都有“继承”的概念：A继承于B，那么B就是A的父类，A就是B的子类，B的引用可以直接指向A的实例，而A的引用指向B的实例需要强制类型转化……不拉不拉可以延伸一堆内容。但是，一般的语言，Java也好C#也好……A类型的集合和B类型的集合两个集合是没有关系的；可是，Scala中却可以有关系： [+T] A是B的子类，如果想让Contai...
Scala基本语法
道听途说
01-19 518
基本语法 Scala 基本语法需要注意以下几点： 区分大小写 -  Scala是大小写敏感的，这意味着标识Hello 和 hello在Scala中会有不同的含义。 类名 - 对于所有的类名的第一个字母要大写。 如果需要使用几个单词来构成一个类的名称，每个单词的第一个字母要大写。 示例：class MyFirstScalaClass 方法名称 -
Scala基础语法
Oak_Komorebi的博客
08-02 454
1 变量与类型 val修饰的变量，相当于Java中final修饰的变量 // 定义常量s1，使用字符串"1"赋值，自动推断为String类型，值不可变 val s1 = "1" // 定义常量s2，手动指定类型为String，此时需要保证所赋值类型匹配 val s2: String = "2" // 使用val定义基本数据类型时，值不可变，可以使用val重新定义 注意：变量声明一定要初始化 变量推断 含义：声明变量时，可以不指定变量类型，编译器会根据赋值内容自动推断当前变量的类型。 // 定
scala 语法参考中文pdf
08-03
《Scala语言规范 2.7版》是Scala的官方文档之一，它详细阐述了Scala的语法结构、类型系统、控制结构、类和对象的定义、模式匹配、函数和闭包等核心概念。在2.7版本中，Scala引入了若干创新特性，例如： 1. **类型...
Scala高级语言设计
02-07
Scala基础语法，搭建环境，数据结构，模式匹配，函数式编程
Scala:它包含一些scala程序以了解其语法
03-12
另外，Scala还包含了一些高级特性，比如元编程和宏，这些可以让你在编译时生成或修改代码。同时，Scala的复合性模型允许你构建模块化的大型系统，使用trait来实现接口和混合行为，增强了代码的灵活性和可组合性。 ...
Scala研究
02-17
Scala的基本语法与Java类似，但更加简洁和表达性强。它支持变量声明、函数定义、类和对象创建等。例如，`val`用于声明不可变变量，`var`则表示可变变量。类和对象的定义则通过`class`和`object`关键字完成，同时...
Scala安装包
08-11
- 语法简洁：Scala的语法简洁且富有表达力，比如使用`_`作为占位符，以及模式匹配功能。 - 并发和并行：Scala的Actor模型支持并发编程，使得在多核处理器环境下编写高性能代码变得容易。 - 大数据处理：Scala是...
Scala的高级用法
qq_37400096的博客
04-29 1778
scala的一些高级用法
Scala 语言学习五——高级语法
heartless_killer的博客
03-10 314
隐式（implicit） 详解 通过隐式转换，程序员可以在编写Scala程序时故意漏掉一些信息，让编译器去尝试在编译期间自动推导出这些信息来，这种特性可以极大的减少代码量，忽略那些冗长，过于细节的代码。 掌握 implicit 的用法是阅读 spark 源码的基础， 也是学习 Scala 其它的开源框架的关键， implicit 可分为： 隐式参数 隐式转换类型 隐式类 隐式参数 定义方法时，...
Scala => 用法总结
Dean Chen的专栏
07-16 5140
10.1 =>这是个各种诡异用法的标记10.1.1 创建4.2=>右边是函数体，左边表示函数的参数类型.(x: Int) => x + 1 10.1.2 无参匿名函数() => T 相当于new Function0[T] //T是返回类型 下面是示例代码scala> val f: () => Unit = () => { println("x")} f: () => Unit =
Scala 高级语法
开水烫鱼的博客
01-08 204
隐式 implicit分类： （1）隐式参数 1） //隐式参数 object ImplicitTest { //此参数如果被implicit修饰的话，调用可以不写参数 直接sleep def sleep(implicit how:String) = {println(how)} def main(args: Array[String]): Unit = { ...
scala中的option[T]、Any、Nothing、Null、null、Nil、None、Some和Unit
热门推荐
周天祥的博客
11-15 8万+
scala中的option[T]、Any、Nothing、Null、null、Nil、None和Unit 1 Option[T] 、None 和 Some 2 Any 3.Nothing 4.Null与null 5、Nil 6、Unit 对人工智能感兴趣的同学，可以点击以下链接： 现在人工智能非常火爆，很多朋友都想学，但是一般的教程都是为博硕生准备的，太难看懂了。最近发现了一个非...
Java基础入门：掌握基本语法与概念2024最新0基础！！！易懂！！！.md
最新发布
07-14
Java编程语言的基础语法要点。首先介绍了数据类型与变量的概念，包括整型、浮点型、字符型和布尔型，每种类型的定义和示例代码都有详细解释。其次，讨论了运算符与表达式的使用，包括算术运算符、赋值运算符、关系运算符和逻辑运算符，每种运算符的功能和示例展示。接着，文章深入探讨了控制流程，包括条件语句（if-else、switch-case）和循环语句（for循环、while循环、do-while循环），每种语句的用法和示例演示。随后，文章详细讲解了方法的定义与调用，展示了如何定义带有参数和返回值的方法，并给出了实际使用的示例。最后，文章介绍了Java中的数组与集合，包括如何定义和初始化数组，以及如何使用列表（List）作为集合类型存储数据。字符串处理也得到了关注，包括字符串的拼接、长度、比较、查找和替换等操作。整篇文章通过清晰的教程、详细的示例代码和逐步解释，帮助读者建立起对Java基础语法的全面理解和实际运用能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值