Scala学习笔记

var表示变量是可变的，可以重新赋值

val表示变量不可变

推荐使用val，没有线程安全问题，效率更高

val类型的变量底层是使用了final修饰

同时在idea中，如果使用var修饰变量，但是后面没有重新给变量赋值，var会变成灰色

和Java类似，Scala也是值传递，对于引用数据类型，例如对象，只是地址不变，但是对象的属性是可以改变的

Settings -> Editor -> Inlay Hints -> Scala -> Type hints -> Show type hints for

①Byte 8位有符号补码整数。数值区间为 -128 到 127

②Short 16位有符号补码整数。数值区间为 -32768 到 32767

③Int 32位有符号补码整数。数值区间为 -2147483648 到 2147483647。如果是整数且不加L，默认为Int，和Java一样。

④Long 64位有符号补码整数。例如123L。数值区间为 -9223372036854775808 到 9223372036854775807

⑤Float 32 位。IEEE 754 标准的单精度浮点数。例如0.1F。如果是小数且不加F或者D，默认为Float类型，和Java一样。

⑥Double 64 位 IEEE 754 标准的双精度浮点数。例如0.1D。

⑦Char 16位无符号Unicode字符, 区间值为 U+0000 到 U+FFFF

⑧String 字符序列

⑨Boolean true或false

⑩Unit 表示无值，和其他语言中void等同。用作不返回任何结果的方法的结果类型。Unit只有一个实例值，写成()。

11.Null null 或空引用

12.Nothing Nothing类型在Scala的类层级的最底端；它是任何其他类型的子类型。

13.Any Any是所有其他类的超类

14.AnyRef AnyRef类是Scala里所有引用类(reference class)的基类

Symbol

1.Scala的数据类型与Java的基本一样

2.在Scala中有一个根类型Any，它是是所有类的父类

3.Scala中一切皆为对象，分为两大类AnyVal(值类型)和AnyRef(引用类型)

4.Null类型是Scala的特别类型，它只有一个值null，它是bottom class，是所有AnyRef类型的子类

5.Nothing类型也是bottom class，它是所有类的子类，在开发过程中可以将Nothing类型的值返回给任意变量或者函数，这里抛出异常使用很多

6.在Scala中仍然遵守，低精度的值向高精度的值自动转换（implictit conversion）隐式转换

小结

1.在Scala中，所有引用类型的类都是AnyRef的子类，类似于Java的object

2.AnyVal和AnyRef都扩展自Any类。Any类是根节点

3.Any中定义了isInstanceOf、asInstanceOf方法，以及哈希方法等

4.Null类型的唯一实例就是null对象，可以将null赋值给任何引用，但不能赋值给值类型的变量

5.Nothing类型没有实例。它对于泛型结构是有用处的，举例：空列表nuil的类型时List[Nothing]，它是List[T]的子类型，T可以时任何类

var num2 = if (5 > 6) "大于" else "小于"

1. 基本案例
for (i <- 1 to 3) {
      println(i)
}
1 to 3左闭右闭
i表示循环中的变量，并且i是val修饰的，不能改变值
1 until 3表示左闭右开

2. 循环守卫
for(i <- 1 to 3 if i!=2){
println(i)
}
循环守卫，即循环保护式（也称条件判断式），保护式为true则进入循环体内部，为false则跳过，类似于continue

3. 引入变量
for (i <- 1 to 10; j = 1 + i) {
      println("i = " + i + ", j = " + j)
    }

4. 循环嵌套
for (i <- 1 to 3; j <- 1 to 3) {
      println("i = " + i + ", j = " + j)
    }

等价于
for (i <- 1 to 3) {
      for (j <- 1 to 3) {
        println("i = " + i + ", j = " + j)
      }
    }

5. 循环返回值
val rest = for (i <- 1 to 10 ) yield {
      if (i % 2 == 0) {
        i
      } else {
        "不是偶数"
      }
    }
案例说明
将遍历过程中处理的结果返回到一个新的Vector集合中，使用yield关键字，yield后可以接收一段代码块

6. 循环控制步长
方法一
for (i <- Range(1, 10, 2)) {
      println(i)
    }
说明Range(1, 10, 2)
1代表start值，10代表end值，2代表步长

for(i <- 1 to 10 if i%2==1){
print(i)
}
说明：利用循环守卫控制步长

和Java完全一致

//1. 计算1-100的和
    var i = 1
    var sum = 0
    while (i < 101) {
      sum += i
      i += 1
    }
    println(sum)

和Java完全一致

//使用do while循环, 输出10次"hello, 尚硅谷"
    var i = 0
    do {
      println("Hello, 尚硅谷")
      i += 1
    } while (i < 10)

高版本已经废弃

for循环

while和do while循环

//main方法开始执行
//sum方法之后
//sum函数执行了。。。。。。。。
//3
object LazyDemo01 {

  def main(args: Array[String]): Unit = {
    println("main方法开始执行")
    //当函数返回值被声明为lazy时，函数的执行将被推迟，直到我们首次对此取值，该函数才会执行。
    //这种函数我们称之为惰性函数，在Java的某些框架代码中称之为懒加载(延迟加载)。
    //val result = sum(1, 2)
    lazy val result = sum(1, 2)
    println("sum方法之后")
    println(result)
  }

  def sum(arg1 : Int, arg2 : Int): Int = {
    println("sum函数执行了。。。。。。。。")
    arg1 + arg2
  }

}

    try {
      var i = 1 / 0
    } catch {
      case ex: Exception =>
        ex.printStackTrace()
        throw new RuntimeException("测试手动抛出运行时异常")
    } finally {
      println("finally最终执行了")
    }

object ExceptionDemo02 {

  def main(args: Array[String]): Unit = {
    val unit: Unit = f1()
    println(unit)
  }

  //scala提供了throws关键字来声明异常。可以使用方法定义声明异常。 它向调用者函数提供了此方法可能引发此异常的信息
  //方法的调用处也不需要显示处理
  //和java不同的是, scala不需要在方法上声明类型, 没有编译时异常, 都是运行时异常
  @throws(classOf[NumberFormatException])
  def f1(): Unit = {
    "abc".toInt
  }

}

Scala构造器的基本语法

class 类名(形参列表){//主构造器
//类体
def this(形参列表){//辅助构造器
}

def this(形参列表){//辅助构造器

}
说明:主构造器只有一个，辅助构造器函数名称为this，可以有多个。
编译器通过不同参数来区分多个构造器

1.Scala构造器作用是完成对对象的初始化，构造器没有返回值，和Java一样

2.主构造器的声明直接放置于类名之后

3.主构造器会执行类定义中的所有语句，这里可以体会到Scala的函数式编程和面向对象编程融合在一起。
即：构造器也是方法（函数），传递方法以及使用方法和前面函数部分内容没有区别

4.如果主构造器无参数，小括号可以省略，构造对象时调用构造方法的小括号也可以省略，建议不要省略

5.辅助构造器的名称为this（这个和Java是不一样的），多个辅助构造器通过不同参数列表进行区分，在底层就是构造器重载。

6.辅助构造器一定要先调用主构造器，执行主构造器中的逻辑，并且需要在第一行调用

7.Java里辅助构造器可以直接super去调用父类的主构造器，但是在Scala中只允许主构造器去调用父类的主构造器，使用辅助构造器先要调用主构造器，主构造器会默认先执行父类中的构造器

8.如果想让主构造器变成私有的，可以在()之前加上private，这样用户只能通过辅助构造器来创建对象

9.辅助构造器的声明和主构造器的声明一致，否则会发生错误

1.Scala类主构造器的形参未用任何修饰符，那么这个参数就是局部变量。可以理解主构造方法就是一个普通方法
class B(name:String){}，在类中的任意地方都可以使用，且不允许重新赋值

2.如果参数使用val关键字声明，那么Scala会将参数作为类的私有的只读属性
class A(val name:String){}

3. 如果参数使用var关键字声明，那么Scala会将参数作为类的成员属性使用，
class A(var name:String){}

作用

命名规则

命名规范

Scala自动导入的包

import详解

代码实现

基本介绍

包对象使用注意事项

代码示例

因为包对象中的所有方法和属性，包下面的所有类都能访问，类似于抽取的作用。之前使用工具类，现在可以使用包对象

因此在包对象中一般定义隐式值、隐式转换函数、隐式类和通用方法等
详情可以见org.apache.flink.streaming.api.scala包对象，里面定义了隐式转换函数

高版本已经废弃

object VisitTest {

  def main(args: Array[String]): Unit = {
    val demo0 = new VisitDemo01
    //报错, private修饰的字段只能在本类和伴生对象中使用
    //demo0.sal

    println(demo0.name)

    demo0.showInfo()

    //protected只能在子类中使用, 同包无法访问
    //demo0.age
  }

}

object VisitDemo01 {

  def test1(visitDemo01: VisitDemo01): Unit = {
    //private为私有权限, 只能在类的内部和伴生对象中使用
    println(visitDemo01.sal)
  }

}

/**
 * scala中字段、方法等访问权限和java不一样，有四种public、protected、private
 * scala中没有public关键字, 默认就是public
 * protected为受保护的权限, 只能子类访问, 同包不能访问
 * private为私有权限, 只能在类的内部和伴生对象中使用
 */
class VisitDemo01 {

  //可以理解为public, 可以在任意地方使用
  var name = "jack"

  //私有属性, 只能在类的内部和伴生对象中使用
  private val sal = 9999.9D

  //protected只能在子类中使用, 同包无法访问
  protected var age = 10

  def showInfo(): Unit = {
    println(s"薪资: $sal")
  }


}

访问父类的成员变量和方法使用super.的方式

子类重写父类的非抽象方法需要使用override关键字修饰

如果类之间存在继承关系那么在声明子类时必须要给父类的主构造器传值
可以简单地理解为子类主构造器必须显示调用父类的主构造器

不存在super(...)调用父类的构造器的方式

代码示例

在Scala中支持重写子类重写父类的字段，复写的字段需要使用override关键字修饰

覆写字段的注意事项和细节

1.def只能重写另一个def（即方法只能重写另一个方法）

2.val只能重写另一个val属性 或不带参数的def

3.var只能重写另一个抽象的var属性

抽象字段就是没有初始化的字段

抽象方法就是没有方法体的方法

声明未初始化的变量就是抽象的属性，抽象属性在抽象类

var重写抽象的var属性小结

abstract class Animal {

//  抽象字段，只会生成抽象的name()方法
  val name : String

//  抽象字段，会生成抽象的age()和age_$eq()方法
  var age : Int

//  非抽象字段，普通属性，生成color()和color_$eq()方法
  var color : String = "黄色"

//  非抽象字段，不可变属性，生成sex()方法
  val sex : String = "公"

//  抽象方法不需要生命abstract，只需要省略方法体即可
  def eat(): Unit

  //普通方法, 有方法体
  def eat2(): Unit = {
    println("eat2普通方法被调用了。。。。")
  }

}

val animal: Animal = new Animal {
      override val name: String = ""
      override var age: Int = _

      override def eat(): Unit = {}
    }

Scala语言完全是面向对象的（万物皆对象）的语言，所以并没静态的操作（即在Scala中没有静态的概念）。

但是为了和Java语言交互（因为Java中有静态概念），就产生了一种特殊的对象来模拟类对象，我们称之为伴生对象。

这个类的所有静态内容都可以放置在它的伴生对象中声明和调用

1.scala中伴生对象用object关键字声明，伴生对象中的内容全部是静态

2.伴生对象对应的是伴生类，伴生对象的名称和伴生类的名称要一致

3.伴生对象中的属性和方法可以直接通过伴生对象名称调用

4.从语法上来看，所谓的伴生对象就是静态方法和静态属性的集合

5.从技术上来看，Scala还是没有生成静态的内容，只不过是将伴生对象生成了一个新的类，实现属性和方法的调用

6.从底层原理上看，伴生对象静态特性是依赖于public static final MODULE$实现的

7.伴生对象和伴生类的声明必须在同一个源码文件中，但是没有伴生类，就没有所谓的伴生对象了，所有放哪里无所谓，但是底层还是生成了一个空的伴生类

8.如果class A独立存在，那么A就是一个类；如果object A独立存在，那么A就是一个“静态”性质的对象（类对象）

9.当一个文件中同时存在伴生对象和伴生类，那么文件的图标会发生变化

10.伴生对象是一种特殊的类，可以继承类、也可以实现trait等，但是只有一个实例

伴生对象apply方法

1.在伴生对象中定义apply方法，可以实现类名()的方式创建对象实例

伴生类和伴生对象简单使用

伴生对象apply方法

一.特质的声明

trait 特质名{

trait体

}

trait的命名一般首字母大写

二.Scala中特质的使用

一个类中具有某种特质（特征），就意味着这个类满足了这个特质（特征）的所有要素，所有在使用时也是用extends关键字，如果有多个特征存在父类，那么需要用with关键字连接

1.没有父类

class 类名 extends 特质1 with 特质2 with 特质3

2.有父类

class 类名 extends 父类 with 特质1 with 特质2

三.快速入门

1.可以把特质看作是对继承的一种补充。Scala的继承是单继承，也就是一个类最多只能有一个父类，这就对子类功能的扩展有一定的影响。所以我们认为：Scala引入trait特质，第一可以替代Java的接口，第二也是对单继承的一种补充

四.特质的再说明

1.trait可以同时拥有抽象方法和具体方法，一个类可以实现或者继承多个特质

2.Java中的接口可以直接当成Scala特质使用

代码示例

1.从面向对象来看，接口并不属于面向对象的范畴，Scala是纯面向对象的语言，在Scala中没有接口

2.Scala语言中采用特质trait（特征）来代替接口的概念，多个类具有相同的特征时，就可以将这个特征独立出来，采用关键字trait声明。
简单理解为 trait等价于 interface+abstract class

动态混入是Scala特有的方式（Java没有动态混入），可在不修改类声明/定义的情况下，扩展类的功能，非常的灵活，耦合性低 。
动态混入可以在不影响原有的继承关系的基础上，给指定的类扩展功能。

在不修改类的定义基础，让他们可以使用trait中的方法
除了可以在类声明时继承特质以外，还可以在构建对象时混入特质，扩展目标类的功能
此种方式也可以应用于对抽象类功能进行扩展

代码示例

一.叠加特质的基本介绍

构建对象的同时如果混入多个特质，称之为叠加特质
那么特质声明顺序从左到右，方法执行顺序从左到右

二.叠加特质的注意事项和细节

1.特质声明顺序从左到右

2.Scala在执行叠加对象方法时，会首先从最右边的特质开始执行，类似于数据结构栈

3.Scala特质中如果调用super方法，并不是表示调用父特质中的方法，而是向左边继续查找特质，如果左边没有特质，此时就会调用父特质

4.如果想要调用具体特质的方法，可以指定super[特质名].方法，其中泛型必须是该类的直接超类类型

三.在特质中重写抽象方法

trait A{
def insert() //抽象方法
}

trait B extends A{
override def insert(): Unit = {
println("将数据保存到文件中！")
super.insert() //思考这里super如何调用父特质中的抽象方法
}
}

以上代码会出错，原因：是没有完全实现insert方法，同时还要声明abstract override
解决方法：①去掉super.insert()
②调用父特质的抽象方法，那么在实际使用中，没有方法的具体实现，无法通过编译，为了避免这种情况的发生。可以重写抽象方法，这样在使用过程中必须考虑动态混入的顺序问题

三.特质构造顺序

1.特质也是有构造器的，构造器中的内容由“字段初始化”和一些其他语句构成。具体实现请参考“叠加特质”
第一种特质构造顺序（声明类的同时混入特质【静态混入】）

①调用当前类的超类构造器
②第一个特质的父类构造器
③第一个特质构造器
④第二个特质构造器的父特质构造器，如果已经执行，就不会在执行
⑤第二个特质构造器
⑥重复4，5步骤（如果有第3，4个特质）
⑦最后执行本类的构造

第二种特质构造顺序（构建类的同时混入特质【动态混入】）
①调用当前类的超类构造器，然后执行本类的构造
②第一个特质的父类构造器
③第一个特质构造器
④第二个特质构造器的父特质构造器，如果已经执行，就不会在执行
⑤第二个特质构造器
⑥重复4，5步骤（如果有第3，4个特质）

分析两种方式对构造顺序的影响
第1种方式实际是构建类对象，在混入特质时，该对象还没有创建
第2种方式实际是构造匿名子类，可以理解成在混入特质时，该对象已经创建

//导入对应的规则类，以免出现警告
import scala.language.implicitConversions

//指定某些数据类型的相互转化
//隐式转换函数的函数名可以是任意的, 与函数名无关, 只与函数的签名有关, 即函数的形参和返回值
object ImplicitFunDemo01 {

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

    //这里定义了隐式转换函数, 使用implicit关键字修饰只有单个参数的方法, 并且有返回值
    //隐式转换函数只在当前作用于生效
    //可以使用import关键字导入相应的隐式函数
    implicit def f1(num: Double): Int = num.toInt

    implicit def f2(num: Float): Int = num.toInt

    //隐式函数可以有多个, 当时需要保证在当前环境下, 只能有一个函数被识别, 否则会发生编译错误
    //implicit def f3(num: Float): Int = num.toInt

    //scala中有下划线的就是有隐式转换, 编译器识别了隐式转换函数
    val num: Int = 3.5D
    println(num)

    val num2: Int = 3.5f
    println(num2)
  }

}

//在scala2.10后提供了隐式类, 可以使用implicit声明类, 隐式类非常强大, 同样可以拓展类的功能
//比前面使用隐式转换函数使用上更加方便, 在集合中隐式类会发挥重要的作用
object ImplicitClassDemo {

  def main(args: Array[String]): Unit = {
    //使用implicit关键字修饰类
    //隐式类不能是顶级的class, 必须定义在其他顶级类中
    //类的主构造方法就是要增强的类, 且只能是一个参数, 一般也是转换前的类型
    //隐式类不能是case class
    implicit class DB1(var mySQL1: MySQL1) {
      def addSuffix(): String = {
        mySQL1.hashCode() + " scala"
      }
    }

    val mySQL = new MySQL1
    mySQL.sayOk()
    println(mySQL.addSuffix())
  }

}

class MySQL1 {

  def sayOk(): Unit = {
    println("sayOk")
  }
}

隐式值也叫隐式变量，将变量标记使用implicit修饰。隐式值只要配合隐式参数

指方法或者函数的形参使用了implict关键字修饰

1.编译器会在方法省略隐式参数的情况下，去搜索作用域中的隐式变量作为缺省参数（默认值）

2.当同时有implicit值和默认值时，会调用implicit值，因为implicit值的优先级高

3.当同时有implicit值和默认值时，但是两则类型不匹配，则会调用默认值

4.当同时有implicit值和没有默认值时，但是implicit值类型与形参类型不匹配，此时会报错

在于可以给方法的形参设置默认值，但是优先级高于参数的默认值

在方法调用时，省略形参的赋值，让代码看上去更加简洁

一般隐式参数使用科里化的方式，而且也是最后一个形参

代码示例1

代码示例2

1）当函数没有柯里化时，implicit关键字会作用于函数列表中的的所有参数。
2）隐式参数使用时要么全部不指定，要么全不指定，不能只指定部分。
3）同类型的隐式值只能在作用域内出现一次，即不能在同一个作用域中定义多个相同类型的隐式值。
4）在指定隐式参数时，implicit 关键字只能出现在参数开头。
5）如果想要实现参数的部分隐式参数，只能使用函数的柯里化，
如要实现这种形式的函数，def test(x:Int, implicit  y: Double)的形式，必须使用柯里化实现：def test(x: Int)(implicit y: Double).
6) 柯里化的函数， implicit 关键字只能作用于最后一个参数。否则，不合法。
7）implicit 关键字在隐式参数中只能出现一次，柯里化的函数也不例外！

object ImplicitObjectDemo01 {

  def main(args: Array[String]): Unit = {
    trait S1 {
      def fun(): Unit
    }

    //隐式对象不能是顶级对象, 必须要在其他类或者对象中
    implicit object S2 extends S1 {
      override def fun(): Unit = println("Spark")
    }

    def g(arg1: String)(implicit arg2: S1): Unit = {
      println(s"隐式对象的解析!!!, 参数: $arg1")
      arg2.fun()
    }

    g("Scala")(() => println("不是隐式对象"))

    //这里隐式对象S2在这里当做隐式值使用
    g("Scala")
  }

}

一.Scala集合基本介绍

1.Scala同时支持不可变集合和可变集合，不可变集合可以安全的并发访问

2.两个主要的包

不可变集合：scala.collection.immutable

可变集合：scala.collection.mutable

3.Scala默认采用不可变集合，对于几乎所有的集合类，Scala都同时提供了可变（mutable）和不可变（immutable）的版本，

4.Scala的集合有三大类：序列Seq、集Set、映射Map，所有集合都扩展自Iterable特质，在Scala中集合有可变（mutable）和不可变（immutable）两种类型 

二.可变集合和不可变集合

1.不可变集合：Scala不可变集合，就时这个集合本身不能动态变化。类似于Java的数组，是不可以动态增长的

2.可变集合：就是这个集合本身可以动态变化，是可以动态增长的

三.集合的种类

1.数组Array

2.元组Tuple

3.列表List

4.队列Queue

5.映射Map

6.集Set

定长数组

变长数组

定长数组与变长数组相互转换

多维数组

一.tuple介绍

元组可理解成一个容器，可以存放各种相同和不同的数据。简单来说，就是将多个无关的数据封装成一个整体，称为元组。注意：元组内最多只能有22个数据

二.元组的创建

val tuple = (1,2,3,"hello",2,2)

三.小结

1.tuple的类型取决于tuple中有多少个元素，比如有 6个元素，则类型就是tuple6

2.元组中最大只能有22个元素

四.元组的访问

访问元组中的数据，可以采用顺序序号（_顺序号），也可以通过索引（productElement）访问

tuple1._1 //1代表顺序号

tuple1.productElement(0) //0代表索引

五.元组的遍历

1.元组的遍历需要用到迭代器

2.即 for(item <- tuple1.productIterator){

print(item)

}

一.列表的基本介绍

Scala中list和Java List本不一样，Java中的List是一个接口，真正存放数据的是ArrayList，而Scala的list可以直接存放数据，就是一个object，默认情况下，Scala的list是不可变的，list属于序列Seq

二.说明

1.在默认情况下list是Scala.collection.immutable.list，即list是不可变的

2.在Scala中，list就是不可变的，如果需要使用可变的list，则使用listBuffer

3.Nil代表空集合

三.小结

1.list默认为不可变的集合

2.list在Scala包对象声明的，因此不需要引入其他包也可以使用

3.val List = scala.collection.immutable.List

4.list中可以存放任何数据类型，比如arr1的类型为list[Any]

5.如果希望得到一个空列表，可以使用Nil对象，在Scala包对象声明的，因此不需要引入其他包也可以使用

val Nil = scala.collection.immuteable.Nil

四.列表的元素追加

1.基本介绍
向列表中增加元素，会返回新的列表/集合对象，本身的集合并没有发生变化。注意Scala列表追加元素的形式非常独特，和Java不一样
val list01 = List(1,2,3)
var list02 = list01:+9 //创建一个新的列表并在这个列表的最后添加
var list03 = 4 +: list01 //（同上）在列表的最前面添加

2.添加数据::符号
①符号::表示向集合中新建集合添加元素
②运算时，集合对象一定要放置在最右边
③运算规则，从左向右
④:::运算符是将集合中的每一个元素加入到空集合中，并且:::符号左右两边都为集合，不然会报错
⑤ //将元素1 2 和 list列表存放到空列表Nil中

val list2 = 1 :: 2 :: list :: Nil
println(list2) //List(1, 2, List(1, 2, 3, 4))

五.listBuffer可变列表

①列表创建 val list = new ListBuffer[Int]()
②访问列表 list(0)
③动态追加元素 list += 1 和 list.appent(1,2,3) 和 list :+ 5
④列表中添加列表 list ++= list01
⑤删除元素 list.remove(1) //索引值（下标值）

六.listBuffer的操作案例

//listBuffer列表添加元素或列表
listBuffer += (99,22) //可以添加一个或多个元素
listBuffer.append(29,100)
listBuffer ++= list //添加一个列表
println(listBuffer)

//listBuffer删除元素
listBuffer -= 2 //删除2这个元素
listBuffer -= 1000 //如果删除的这个元素不存在，则不执行，也不会报错
listBuffer.remove(1) //删除下标为 1 的元素
listBuffer.remove(1,3) //从下标为 1 的元素开始，往后删除 3 个元素
println(listBuffer)

七.列表的其他操作

list.head //返回列表的第一个元素
list.tail //返回列表除第一个元素外的元素
list.isEmpty //判断列表是否为空，空true，非空false
list.last //返回列表最后一个元素
list.init //返回列表除最后一个元素外的元素

一.队列的基本介绍

1.队列是一个有序列表，再底层可以用数组或链表来实现
2.其输出和输入要遵循先入先出的原则。即：先存入队列的数据先取出，后存入的数据后取出
3.在Scala中，由设计者直接给我们提供队列类型使用
4.在Scala中，由scala.collection.mutable.Queue 和 scala.collect.immutable.Queue 我们使用最多的是可变的队列

二.队列的创建

val queue = new mutable.Queue[Int] //Int为队列的泛型

三.队列添加元素

1.queue += 20
2.queue ++= list(2,3,4) //将列表中每个元素取出后加入队列
3.queue += list(2,3,4) //将list直接加入队列，前提是queue的泛型是Any

三.出入队列

1.（出队列）删除第一个元素并返回 queue.dequeue()
2.（入队列）在队尾添加元素 queue.enqueue(100,2,100) //元素是有序的，并且可以重复

四.返回队列中的元素

1.返回队列第一个元素 queue.head
2.返回队列最后一个元素 queue.last
3.返回队列尾部元素，返回的是一个队列，所以可以级联使用该方法（除了第一个元素，其他元素都返回）

queue.tail
queue.tail.tail

Map的创建

Map的操作

一.集的基本介绍
集是不重复元素的集合。集不保留顺序，默认是以哈希集实现

二.回顾：Java中Set
Java中，Hash是实现Set<E>接口的一个实现类，数据是以哈希表的顺序存放的，里面不能包含重复数据。Set接口是一个不包含重复数据的collection，HashSet中的数据也是没有顺序的

三.Scala中的Set说明
1.默认情况下，Scala使用的是不可变的集合，如果想使用可变的集合，需要引入scala.collection.mutable.Set包。
2.set(1) 可以判断元素 1 在集合中是否存在，存在返回true，不存在返回false

四.集Set的创建
1.创建不可变的集
val set = Set(1,2,3) //不需要引包，默认就是不可变的

2.可变集合的创建
import scala.collection.mutable.Set
val mutable = mutable.Set(1,2,3) 

五.可变集合元素的添加

set.add(4) //只有可变集才能添加元素，如果添加的元素重复也不会报错，但是不会添加
set += 8

六.可变集合元素的删除

set.remove(4) //集Set中可以根据值来删除，因为Set中的元素不重复
set -= 8 //如果删除的元素不存在，则不会报错。

七.Set的遍历
for(x <- set){
print(x)
}

八.集合的其他操作
val set1 = Set(1,2,3,4)
val set2 = Set(3,4,5,6)

1.求两个集合的并集（两个集合相加）
val res1 = set1 ++ set2

2.求两个集合的交集（返回两个集合中都存在的元素）
val res2 = set1.&(set2) //方法1
val res3 = set1.intersect(set2) //方法2

先看一个实际需求
要求：请将List(3,5,7) 中的所有元素都 * 2 ，将其结果放到一个新的集合中返回，即返回一个新的List(6,10,14), 请编写程序实现

传统方法
val list1 = List(3, 5, 7)
var list2 = List[Int]()
for (item <- list1) { //遍历
list2 = list2 :+ item * 2
}
println(list2)

上面提出的问题，其实就是一个关于集合元素映射操作的问题。在Scala中可以通过map映射操作来解决：将集合中每一个元素通过指定功能（函数）映射（转换）成新的结果集合，这里其实就是所谓的将函数作为参数传递给另外一个函数，这就是函数式编程的特点

使用map完成上述操作：list2 = list1.map(_*2)

高阶函数：一个可以接受函数的函数
//创建一个高阶函数，即可以接收函数的函数
//f:Double => Double表示一个可以接收Double类型并返回Double类型的函数
//n1 代表test的形参
//= 表示返回的类型使用类型推导
//f(n1) 表示执行传入的函数
def test(f:Double => Double,n1 :Double)={
f(n1)

flatmap映射：flat 即压扁

flatmap：就是集合中每个元素的子元素映射到某个函数并返回新的集合

val names = ListBuffer("Python","Scala","Java")
def upper(s:String):String={ //接收一个字符串，将字符串字母全部变成大写后返回
s.toUpperCase
}
println(names.flatMap(upper)) //flatMap操作就是将集合中元素继续扁平化操作，即遍历所有元素

filter：将符合要求的数据（筛选）放置到新的集合中

应用案例：
/*
将 val names = List("Alice", "Bob", "Nick") 集合中首字母为'A'的筛选到新的集合
*/
val names = List("Alice", "Aob", "Nick")
val res = names.filter(filter)
println(res)

def filter(s:String):Boolean={
s.startsWith("A")
}

需求：val list = List(1,20,30,4,5) 求出list中元素之和

化简：将二元函数（接收两个参数的函数）引用于集合中的函数，
一.左化简reduceLeft 等价于 reduce
val list = List(1, 20, 30, 4, 5)
def sum(n1: Int, n2: Int): Int = {
n1 + n2
}
val res = list.reduceLeft(sum)
println("res=" + res)

左化简说明：
1.reduceLeft(f) 接收的函数需要的形式为 op: (B, A) => B): B
2.reduceLeft(f) 的运行规则是从左边开始执行将得到的结果返回给第一个参数，然后和下一个元素运行，以此类推
3.化简流程(((1+20)+30)+4)+5 = 60

二.右化简reduceRight
val list = List(1,2,3,4,5)
def product(n1:Int,n2:Int): Int ={
println(n1-n2)
n1-n2
}
val res = list.reduceLeft(product)
println(res)

右化简说明：
1.reduceRight(f) 的运行规则是从右边开始执行将结果返回给第二个参数，然后和下一个元素运算，以此类推
2.化简流程1-(2-(3-(4-5))) = 13

一.折叠的基本介绍
fold函数将上一步返回的值作为函数的第一个参数继续传递参与运算，直到list中的元素被遍历

1.可以把reduceLeft看做成简化版的foldLeft

操作代码
val list = List(2, 6, 3, 5, 9)
//foldLeft()和reduceLeft()的运行机制几乎一样
//list.foldLeft(5)(function)可以理解为List(5 , 2, 6, 3, 5, 9)的reduceLeft操作
//就是将 5 放到list的第一个元素位置，再进行reduceLeft操作
//运行流程：
// ((((5-2)-6)-3)-5)-9

val res1 = list.foldLeft(5)(function) //更多的时候5这个位置传的是一个函数
println(res1) //-20

折叠fold的简写
正斜杠 / 在哪边，就是哪边折叠
val list = List(2, 6)
val res = (5 /: list) (function) //这种写法等价于 list.foldLeft(5)(function)
println(res) //-3

val res2 =(list :\ 5) (function) //等价于 list.foldRight(5)(function)
println(res2) //1

def function(n1: Int, n2: Int): Int = {
n1 - n2
}

一.扫描的基本方式
扫描，即对某个集合中所有的元素做fold操作，但是会把产生的的所有中间结果放置于一个集合中保存

操作代码
val list = 1 to 5
//scan 扫描就是将集合中的每一个元素进行折叠操作，并将每个操作的结果放置再一个集合中
val res = list.scanLeft(8)(minux)
println(res) //8,7,5,2,-2,-7

//scanRight跟折叠fold操作基本相同，只是返回的结果不一样
val res2 = list.scanRight(6)(minux)
println(res2) //-3,4,-2,5,-1,6

def minux(n1:Int,n2:Int): Int ={
n1-n2
}

一.基本介绍
groupBy会按照列表中的某个元素中某个字段进行分组。会返回一个Map映射，分组字段做为key，包含该字段的元素做为value

二.代码演示1
//将列表进行分组 按照元素是否为 2 的倍数分组
val list = List(12,3,4,4,5,65,6,6,7,87,23)
val res = list.groupBy(x => if(x%2==0) "2的倍数" else "不是2的倍数" )
println(res)

三.代码演示2
//将列表按照每个元素中的城市字段进行分组
val list = List[String]("70999,1371001,广东,广州,中国移动,020,510000",
"71000,1371002,广东,广州,中国移动,020,510000",
"71348,1371350,广东,深圳,中国移动,0755,518000",
"71349,1371351,广东,深圳,中国移动,0755,518000")

//将匿名函数传入到groupBy中
val res = list.groupBy(s => s.split(",")(3))
//当匿名函数的参数在 => 符号右边只出现一次时，可以将参数用下划线 _ 代替。如下：
val res1 = list.groupBy(_.split(",")(3))
println(res1)
//也可以将自己写的函数传入到groupBy中
val res2 = list.groupBy(MygroupBy)
println(res2)

def MygroupBy(string: String)={
//被分组的列表中有多少个元素，这个函数就会被调用多少次
//将列表中每个元素按 , 号分割成数组，然后取出该数组中下标为 3 的元素
string.split(",")(3)
}

一.zip拉链的基本介绍
在开发中，当我们需要将两个集合进行对偶元组合并，可以使用拉链

val list1 = List(1,2,3)
val list2 = List(4,5,6)
val res = list1.zip(list2) //(1,4), (2,5), (3,6)
println(res)

二.拉链的注意事项
1.拉链的本质就是两个集合的合并操作，合并后每一个元素是一个对偶元组
2.拉链操作就是将两个集合中的元素一一对应，再进行合并
3.如果两个集合元素的个数不对应，会造成数据丢失
4.集合不限于list，也可以是Array等
5.如果要取出合并后的各个对偶元组，可以进行遍历 

一.基本说明

通过iterator方法从集合获取一个迭代器，通过while或者for循环遍历

val array = Array(1,2,3,4,5).iterator
println("=============while================")
while (array.hasNext){
println(array.next())
}

println("=============for================")
for (item <- array){
println(item)
}

一.基本说明
stream是一个集合。它可以存放无穷多个元素，但是这无穷多个元素并不会一次性生产出来，而是需要多大的区间，就会动态的产生，末尾元素遵循lazy规则（即：需要是，才计算）

//创建一个流
def numForm(n:BigInt):Stream[BigInt]={n #:: numForm(n+1)}
val stream = numForm(1)
println(stream)
//取出第一个元素
println(stream.head)
println(stream.tail)

说明：
1.stream集合中存放的数据类型是BigInt
2.numForm是一个函数名，由程序员指定
3.创建的集合的第一个元素是n，后续生成的规则是n+1
4.后续元素生成的规则可以自行指定
5.使用tail方法就可以产生一个新的元素

一.基本介绍
stream的懒加载特性，也可以对其他集合应用view方法来得到类似的效果，具有如下特点：
1.view方法产生出一个总是被懒加载执行的集合
2.view不会缓存数据，每次都要重新计算，比如遍历view时。

val view = 1 to 100
val res = view.filter(eq)
println(res)

def eq(n:Int):Boolean={
n.toString.equals(n.toString.reverse)
}

一.所有线程安全的集合都是以synchronized开头的集合
SynchronizedBuffer
SynchronizedMap
SynchronizedPriorityQueue
SynchronizedQueue
SynchronizeSet
SynchronizeStack

二.并行集合
1.Scala为了充分使用多核CPU，提供了并行集合（有别于前面的串行集合），用于多核环境的并行计算
2.主要用到的算法有：Divied and conquer(分治算法)，Scala通过splitters，combiners等抽象层来实现，主要原理是将计算工作分解成很多任务，分发给一些处理器去完成，并将它们处理的结果合并返回
3.Work stealin算法【学数学】，主要用于任务调度负载均衡（load-balancing），通俗点完成自己的所有任务之后，发现其他人还有活没干完，主动（或被安排）帮他人一起干，这样达到尽早干完的目的

三.使用并行模块

Scala 2.13之后，并行模块变成了外部库，和XML、Swing、parser-combinators等一样需要在maven项目的pom.xml中手动导入：
<dependency>
<groupId>org.scala-lang.modules</groupId>
<artifactId>scala-parallel-collections_2.13</artifactId>
<version>0.2.0</version>
</dependency>

然后在代码文件中导入如下的包就行了： import scala.collection.parallel.CollectionConverters._ 参考链接：https://stackoverflow.com/questions/57287607/answer/submit[code=html]

四.基本案例

1.输出1-5
(1 to 5).foreach(println(_)) //单行操作
println()
(1 to 5).par.foreach(println(_)) //并行操作

2.查看并行集合中元素访问的线程
val result1 = (0 to 100).map{case _ => Thread.currentThread.getName}
val result2 = (0 to 100).par.map{case _ => Thread.currentThread.getName}
println(result1)
println(result2)

一.操作符扩展

1.如果想在变量名，类名等定义中使用语法关键字（保留字），可以配合反引号`` val`val`=42

2.中置操作符：A操作符B (等同于) A.操作符(B)

一.基本介绍

如果想要表达匹配某个范围的数据，就需要再模式匹配中增加条件守卫

for (ch <- "+-3!") {
var sign = 0
var digit = 0
ch match {
case '+' => sign = 1
case '-' => sign = -1
// 说明case _ if表示条件守卫，这里的下划线 _ 表示不接收ch
case _ if ch.toString.equals("3") => digit = 3
case _ => sign = 2
}
println(ch + " " + sign + " " + digit)
}

二.模式中的变量

如果在case关键字后跟变量名，那么match前表达式的值会赋给那个变量

val ch = 'V'
ch match {
case '+' => println("ok~")
case mychar => println("ok~" + mychar)
case _ => println ("ok~~")
}

一.先看一个需求
给你一个集合val list = List(1, 2, 3, 4, "abc") ，请完成如下要求:
将集合list中的所有数字+1，并返回一个新的集合
要求忽略掉 非数字 的元素，即返回的 新的集合 形式为 (2, 3, 4, 5)

解决方案
//思路一：使用filter-map
val list = List(1, 2, 3, 4, "12123")
val res = list.filter(fun1).map(fun3).map(fun2)
println(res)

//思路二：模式匹配
val res2 = list.map(fun4)
println(res2)

def fun1(n:Any): Boolean ={
n.isInstanceOf[Int]
}

def fun2(n:Int):Int={
n+1
}

def fun3(n:Any): Int ={
n.asInstanceOf[Int]
}

def fun4(n:Any):Any={
n match {
case n:Int => n+1
case _ =>
}

一.基本介绍

1.在对某个集合进行处理时，其中有些元素不符合处理条件，这时就可以使用偏函数
2.将函数中封装了一组case语句的函数，叫做偏函数。它只会对作用于指定类型的参数或者指定范围的参数实施计算，超出范围的值会另外处理
3.偏函数在Scala中是一个特质PartialFunction

二.代码演示

val list = List(1, 2, 3, 4, "12123")
//创建一个偏函数
//1.PartialFunction[Any,Int]表示偏函数接收一个Any类型的值，返回一个Int类型的值
//2.isDefinedAt(x: Any)这个方法如果返回true，则会调用apply方法，否则不会调用apply方法
//3.apply方法相当于创建一个对象，对传入的值+1，然后返回
val unit = new PartialFunction[Any, Int] {
override def isDefinedAt(x: Any): Boolean = x.isInstanceOf[Int]

override def apply(x: Any): Int = x.asInstanceOf[Int] + 1
}

val res = list.collect(unit)
println(res) 

三.偏函数小结

1.偏函数是使用构建特质的实现类（使用方式是PartialFunction的匿名子类）
2.PartialFunction是个特质
3.构建偏函数时，参数形式[Any,Int]是泛型，第一个表示输入参数的类型，第二个是返回参数的类型
4.当使用偏函数时，会遍历集合中的所有元素，编译器执行流程会先执行isDefinedAt()，如果返回true，则会调用apply方法，构建一个新的Int对象返回
5.执行isDefinedAt() 为false，则会过滤这个元素，即不会构建新的Int对象
6.map函数不支持偏函数，因为map底层的机制就是所有元素循环遍历，无法过滤原来集合的元素
7.collect函数支持偏函数，多用于偏函数的使用

偏函数的简化形式一

声明偏函数，需要重写特质中的方法，有时候会很麻烦，而Scala提供了简单的方法
implicit def dataCon(n:Double):Int={ //创建一个隐式转换函数
n.toInt
}

//偏函数的简化形式
def parFun:PartialFunction[Any,Int]={
case n:Int => n+1 //利用模式匹配
case n:Double => n*2 //这里运用了隐式转换将Double转成了Int
}

val list = List(1,2,3,4,2,2,3,4,"hello")
val res = list.collect(parFun)
println(res)
}

偏函数的简化形式二

这种方式不能指定传入值的类型和返回值的类型，只能使用默认的

//偏函数的简化形式二
val res2 = list.collect{
case n:Int => n+1
case n:Double => n*2
}

println(res2)

一.基本介绍
函数作为一个变量传入到了另一个函数中，那么这个作为参数的函数的类型是function1，即：（参数类型） => 返回类型

二.代码演示
def plus(n:Int): Int ={
n+3
}
val list = List(1,2,3,4)
val res = list.map(plus(_))
println(res.mkString(",")

三.小结
1.map(plus(_))中的plus(_)就是将plus这个函数当做一个参数传给map，_代表从集合中遍历出来的每一个元素
2.plus(_)这里也可以写成plus表示对List(1,2,3,4)的遍历，将每次遍历的元素传给puls的n
3.进行n+3的运算后，返回新的Int，并加入到新的集合中result1中
4.def map[B,That](f:A=>B) 的声明中的f:A=>B是一个函数

一.基本介绍

没有名字的函数就是匿名函数，可以通过函数表达式来设置匿名函数

二.代码演示
val res = (n:Int) => n+3
println(res(2))

三.小结
1.不需要写def函数名
2.不需要写返回值类型，因为默认使用类型推导
3.如果代码块有多行，就使用{}

一.基本介绍
参数推断省去类型信息（在某些情况下【需要有应用场景】），参数类型可以推断出来，如list=(1,2,3) list.map() map中函数参数类型是可以推断出来的，同时也可以进行参数的简写

二参数类型推断的写法说明
1.参数类型是可以推断出来的，可以省略参数类型
2.当传入的函数，只有单个参数时，可以省去括号
3.如果变量只在 => 右边只出现一次，可以用 _ 代替

三.匿名函数的简化写法一（map）

val list = List(1,2,3,4)
//原始写法，将list列表中每个元素加 1 之后返回到一个新列表中
val res1 = list.map((n:Int)=>n+1) //传入一个匿名函数到map函数中
println(res1)

//简化1 ：因为list列表中的元素都是Int,使用匿名函数的形参的类型就可以使用类型推断
//这时就可以省略Int
val res2 = list.map(n=>n+1)
println(res2)

//简化2 ：如果变量在 => 右边只出现了一次，这时可以将变量写成下划线 _
val res3 = list.map(_+1)
println(res3)

四.匿名函数的简化写法二（reduce）

//原始写法，将list列表中的每个元素相加，并返回结果
val reduceRes1 = list.reduce((x:Int,y:Int)=>x+y)
println(reduceRes1)

//简化1 ：因为形参的类型可以根据list元素的类型进行推断，所以Int可以省略
val reduceRes2 = list.reduce((x,y)=>x+y)
println(reduceRes2)

//简化2 ： 因为变量在 => 的右边只出现一次，所以变量x y可以用下划线 _ 表示
val reduceRes3 = list.reduce(_+_)
println(reduceRes3)
}

//Scala的泛型和java类似, 但是功能远比Java的泛型强大
object GenericDemo01 {

  def main(args: Array[String]): Unit = {
    val msg1 = new StringMessage[String]("10")
    val msg2 = new IntMessage[Int](2)

    println(msg1.get)
    println(msg2.get)
  }

}
/*
要求:

编写一个Message类
可以构建Int类型的Message和String类型的Message.
要求使用泛型来完成设计,(说明：不能使用Any)
scala的泛型就是中括号
*/
abstract class Message[T](value: T) {

  def get = value

}

class StringMessage[String](msg: String) extends Message(msg)

class IntMessage[Int](msg: Int) extends Message(msg)

 在Java泛型里表示某个类型是A类型的子类型，使用extend关键字，这种形式叫upper bounds（上线或上界）语法如下：
<T extend A>
//使用通配符的形式
<? extends A>

//java中上界
//在 Java 泛型里表示某个类型是 A 类型的子类型，使用 extends 关键字，这种形式叫 upper bounds(上限或上界)，语法如下: <T extends A>
//或用通配符的形式: <? extends A>
object UpperBoundsDemo01 {

  def main(args: Array[String]): Unit = {
    //1. 第一种方法
    println("传统方法: " + new CompareInt(1, 2).greater)

    //2. 第二种方法
    //这里必须要使用Java的Integer。因为Integer实现了Comparable接口
    println("通用方法: " + new CommonCompare[Integer](Integer.valueOf(1), Integer.valueOf(2)).greater)
    //这里使用了隐式转换

    //3. 第三种方法
    //implicit def float2double(x: Float): Double = x.toDouble
    val commonCompare3 = new CommonCompare[java.lang.Float](10.1f, 10.2f)
    println(commonCompare3.greater)
  }

}

/*
scala中上界应用案例-要求
编写一个通用的类，可以进行Int之间、Float之间、等实现了Comparable接口的值直接的比较.//java.lang.Integer
分别使用传统方法和上界的方式来完成，体会上界使用的好处.
*/
//传统方法
class CompareInt(n1: Int, n2: Int) {

  def greater = if (n1 > n2) n1 else n2

}

//scala的泛型上界
//说明
//1. [T <: Comparable[T]] 表示T是Comparable的子类
//2. T必须要实现Comparable接口
//3. T可以使用compareTo方法
//4. 这样写通用性更好
//5. 通配符的形式: [_ <: Comparable[_]]
class CommonCompare[T <: Comparable[T]](n1: T, n2: T) {

  def greater = if (n1.compareTo(n2) > 0) n1 else n2

}

在Java中泛型里表示某个类型是A类型的父类型，使用super关键字
<T super A>
//使用通配符
<? super A>

//Java中下界
//在 Java 泛型里表示某个类型是 A类型的父类型，使用 super 关键字。<T super A>
//或用通配符的形式： <? super A>

//scala中下界
//在 scala 的下界或下限，使用 >: 关键字，语法如下：[T >: A]
//或用通配符:[_ >: A]

//scala使用下界小结
//对于下界，可以传入任意类型
//传入和Animal直系的，是Animal父类的还是父类处理，是Animal子类的按照Animal处理
//和Animal无关的，一律按照Object处理
//也就是下界，可以随便传，只是处理是方式不一样, 编译器也不会报错, 是可以执行的, 只是丢失了泛型信息
//不能使用上界的思路来类推下界的含义
object LowerBoundsDemo1 {

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

    biophony(Seq(new Earth, new Earth)).foreach(_.sound())

    biophony(Seq(new Animal, new Animal)).foreach(_.sound())

    biophony(Seq(new Bird, new Bird)).foreach(_.sound())

    val res = biophony(Seq(new Bird))

    val res2 = biophony(Seq(new Object))

    val res3 = biophony(Seq(new Moon))
    println("res = " + res)
    println("res2 = " + res2)
    println("res3 = " + res3)

  }
  def biophony[T >: Animal](things: Seq[T]) = things
}


class Earth { //Earth 类

  def sound(){ //方法
    println("hello !")
  }

}
class Animal extends Earth{

  //重写了Earth的方法sound()
  override def sound() ={
    println("animal sound")
  }

}
class Bird extends Animal{

  //将Animal的方法重写
  override def sound()={
    println("bird sounds")
  }

}

class Moon

//协变、逆变、不变
//Scala的协变(+)，逆变(-)，协变covariant、逆变contravariant、不可变invariant
//对于一个带类型参数的类型，比如 List[T]，如果对A及其子类型B，满足 List[B]也符合List[A]的子类型，那么就称为covariance(协变)，如果 List[A]是 List[B]的子类型，即与原来的父子关系正相反，则称为contravariance(逆变)。如果一个类型支持协变或逆变，则称这个类型为variance(翻译为可变的或变型)，否则称为invariance(不可变的)
//在Java里，泛型类型都是invariant，比如 List<String> 并不是 List<Object> 的子类型。而scala支持，可以在定义类型时声明(用加号表示为协变，减号表示逆变)，如:traitList[+T]//在类型定义时声明为协变这样会把List[String]作为List[Any]的子类型。

//在这里引入关于这个符号的说明，在声明Scala的泛型类型时，“+”表示协变，而“-”表示逆变
//C[+T]：如果A是B的子类，那么C[A]是C[B]的子类，称为协变
//C[-T]：如果A是B的子类，那么C[B]是C[A]的子类，称为逆变
//C[T]：无论A和B是什么关系，C[A]和C[B]没有从属关系。称为不变.
object Demo01 {

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

    //不变
    val t1: Temp3[Sub] = new Temp3[Sub]("abc") //ok
    //    val t2: Temp3[Sub] = new Temp3[Super]("abc") //error
//    val t3: Temp3[Super] = new Temp3[Sub]("abc") //error
    val t4: Temp3[Sub] = new Temp3[Sub]("abc") //ok

    //协变
    val t5: Temp4[Super] = new Temp4[Sub]("abc") //ok
    val t6: Temp4[Sub] = new Temp4[Sub]("abc") //ok

    //逆变
    val t7: Temp5[Sub] = new Temp5[Sub]("abc") //ok
    val t8: Temp5[Sub] = new Temp5[Super]("abc") //ok
//    val t9: Temp5[Super] = new Temp5[Sub]("abc") //error

  }

}

//协变
class Temp4[+A](title: String) {

  override def toString = title

}

//逆变
class Temp5[-A](title: String) {

  override def toString = title

}

//不变
class Temp3[A](title: String) {

  override def toString = title

}


class Super

class Sub extends Super

object ViewBoundsDemo01 {

  def main(args: Array[String]): Unit = {
    val value = new CompareComm11(10, 20)
    println(value.greater)
  }

}

/**
 * 视图界定已经过期了, 推荐使用隐式参数的方式, 科里化的方式写隐式参数
 */
class CompareComm11[T <% Comparable[T]](obj1: T, obj2: T) {
//等价于下面的写法。其中(implicit ev$1: T => Comparable[T])是柯里化的写法。
//ev$1 可以任意写, 是函数名
//class CompareComm11[T](obj1: T, obj2: T)(implicit ev$1: T => Comparable[T]) {

  def greater = if (obj1.compareTo(obj2) > 0) obj1 else obj2

}

object ContextBoundsDemo01 {

  implicit val personComparetor = new Ordering[Person] {
    override def compare(p1: Person, p2: Person): Int =
      p1.age - p2.age
  }

  def main(args: Array[String]): Unit = {
    val p1 = new Person("mary", 30)
    val p2 = new Person("smith", 35)
    val compareComm4 = new CompareComm4(p1,p2)
    println(compareComm4.geatter)
    val compareComm5 = new CompareComm5(p1,p2)
    println(compareComm5.geatter)
    val compareComm6 = new CompareComm6(p1,p2)
    println(compareComm6.geatter)
  }

}

//这里需要对[T: Ordering]进行说明。
//1. 和之前的泛型上下界、视图界定不同。这里的泛型T和Ordering之间没有T必须是Ordering的子类或者是父类
//2. 会自动添加一个隐式转换参数。(implicit comparetor: Ordering[T]), 存在着需要将T => Ordering[T]的隐式转换
//3. 并且调用CompareComm6方法时必须有一个可用的隐式值Ordering[T]存在

//方式1。
class CompareComm4[T: Ordering](obj1: T, obj2: T)(implicit comparetor: Ordering[T]) {

  def geatter = if (comparetor.compare(obj1, obj2) > 0) obj1 else obj2

}

//方式2,将隐式参数放到方法内
class CompareComm5[T: Ordering](o1: T, o2: T) {

  def geatter = {
    def f1(implicit cmptor: Ordering[T]) = cmptor.compare(o1, o2)

    if (f1 > 0) o1 else o2
  }

}

//方式3,使用implicitly语法糖，最简单(推荐使用)
class CompareComm6[T: Ordering](o1: T, o2: T) {

  def geatter = {
    //这句话就是会发生隐式转换，获取到隐式值 personComparetor
    //在隐式转换的作用域中必须存在Ordering[T]这样的隐式值
    //从上线文中获取对应的隐式参数
    val comparetor = implicitly[Ordering[T]]
    println("CompareComm6 comparetor" + comparetor.hashCode())
    if (comparetor.compare(o1, o2) > 0) o1 else o2
  }

}

//一个普通的Person类
class Person(val name: String, val age: Int) {
  override def toString = this.name + "\t" + this.age
}