一、Scala函数式编程
多范式：面向对象，函数式编程（程序实现起来简单）
举例：WordCount
sc 是 SparkContext , 非常重要
一行：
var result = sc.textFile("hdfs://xxxx/xxx/data.txt")
.flatMap(_.split(" ")).map((_,1)).reduceByKey(_+_).collect1、复习函数
关键字 def
2、匿名函数
没有名字的函数
举例
scala> var myarray = Array(1,2,3)
myarray: Array[Int] = Array(1, 2, 3)
scala> def fun1(x:Int):Int = x*3
fun1: (x: Int)Int
scala> (x:Int) => x*3
res0: Int => Int = <function1>问题：怎么去调用？高阶函数
scala> fun1(3)
res1: Int = 9
scala> myarray.foreach(println)
1
2
3
//调用匿名函数
scala> myarray.map((x:Int) => x*3)
res3: Array[Int] = Array(3, 6, 9)(_,1) (_+_) 都是匿名函数
3、高阶函数（带有函数参数的函数）
把一个函数作为另外一个函数的参数值
定义一个高阶函数：
对10做某种运算
scala> def someAction(f:(Double)=>(Double)) = f(10)
someAction: (f: Double => Double)Double解释
(Double)=>(Double) 代表了f 的类型：入参是double，返回值也是double的函数
import scala.math._
scala> someAction(sqrt)
res5: Double = 3.1622776601683795
scala> someAction(sin)
res6: Double = -0.5440211108893698
scala> someAction(cos)
res7: Double = -0.8390715290764524
scala> someAction(println)
<console>:16: error: type mismatch;
found : () => Unit
required: Double => Double
someAction(println)
^
def someAction(f:(Double)=>(Double)) = f(10)
someAction(sqrt) = sqrt(10)4、高阶函数的实例
scala中提供了常用的高阶函数
（1）map : 相当于一个循环，对某个集合中的每个元素都进行操作（接收一个函数），返回一个新的集合
scala> var numbers = List(1,2,3,4,5,6,7,8,9,10)
numbers: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
scala> numbers.map((i:Int)=>i*2)
res2: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
scala> numers.map(_*2)
res3: List[Int] = List(2, 4, 6, 8, 10, 12, 14, 16, 18, 20)
说明：
(i:Int)=>i2 与 _2 等价的
(i:Int,j:Int)=>i+j _+_
scala> numbers
res4: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
不改变numbers本身的值
（2）foreach：相当于一个循环，对某个集合中的每个元素都进行操作（接收一个函数），不返回结果
scala> numbers.foreach(println)
1
2
3
4
5
6
7
8
9
10
numbers.foreach(_*2)
没有返回值
（3） filter ：过滤，选择满足的数据
举例：查询能被2整除的数字
scala> numbers.filter((i:Int)=>i%2==0)
res5: List[Int] = List(2, 4, 6, 8, 10)
filter函数，参数要求：要求一个返回 bool 值的函数，筛选出所有为true的数据
（4）zip操作：合并两个集合
scala> List(1,2,3).zip(List(4,5,6))
res6: List[(Int, Int)] = List((1,4), (2,5), (3,6))
//少的话匹配不上就不合并
scala> List(1,2,3).zip(List(4,5))
res7: List[(Int, Int)] = List((1,4), (2,5))
scala> List(1).zip(List(4,5))
res8: List[(Int, Int)] = List((1,4))
（5）partition ： 根据断言（就是某个条件，匿名函数）的结果，来进行分区
举例：
能被2整除的分成一个区，不能被2整除的分成另外一个区
scala> numbers.partition((i:Int)=>i%2==0)
res9: (List[Int], List[Int]) = (List(2, 4, 6, 8, 10),List(1, 3, 5, 7, 9))
（6）find ： 查找第一个满足条件的元素
scala> numbers.find(_%3==0)
res10: Option[Int] = Some(3)
_%3==0 (i:Int)=>i%3==0 一样
（7）flatten：把嵌套的结果展开
scala> List(List(2,4,6,8,10),List(1,3,5,7,9)).flatten
res11: List[Int] = List(2, 4, 6, 8, 10, 1, 3, 5, 7, 9)
（8）flatmap : 相当于一个 map + flatten
scala> var myList = List(List(2,4,6,8,10),List(1,3,5,7,9))
myList: List[List[Int]] = List(List(2, 4, 6, 8, 10), List(1, 3, 5, 7, 9))
scala> myList.flatMap(x=>x.map(_*2))
res22: List[Int] = List(4, 8, 12, 16, 20, 2, 6, 10, 14, 18)
myList.flatMap(x=>x.map(_*2))
执行过程：
1、将 List(2, 4, 6, 8, 10), List(1, 3, 5, 7, 9) 调用 map(_*2) 方法。x 代表一个List
2、flatten
package day4
/**
* 对比flatmap与map
*/
object Demo2 {
/**
* flatmap执行分析
* 1 List(1*2) List(2)
* 2 List(2*2) List(4)
* 3 List('a','b')
*
* List(List(2),List(4),List('a','b')).flatten
* List(2,4,'a','b')
*/
def flatMap(){
val li = List(1,2,3)
val res = li.flatMap(x=>
x match{
case 3=>List('a','b')
case _=>List(x*2)
})
println(res)
}
/**
* map过程解析
*
* 1 2 ---->List(2,2,3)
* 2 4 ---->List(2,4,5)
* 3 List('a','b')---->List(2,4,List('a','b'))
*/
def map(){
val li = List(1,2,3)
val res = li.map(x=>
x match{
case 3=>List('a','b')
case _=>x*2
})
println(res)
}
def main(args: Array[String]): Unit = {
flatMap()
map()
}
}5、概念：闭包、柯里化
（1）闭包：就是函数的嵌套
在一个函数的里面，包含了另一个函数的定义
可以在内函数中访问外函数的变量
举例：
def mulBy(factor:Double) = (x:Double)=>x*factor
外 内乘以三：
scala> def mulBy(factor:Double) = (x:Double)=>x*factor
mulBy: (factor: Double)Double => Double
scala> var triple = mulBy(3)
triple: Double => Double = <function1>
相当于 triple(x:Double) = x*3
scala> triple(10)
res1: Double = 30.0
scala> triple(20)
res2: Double = 60.0
scala> var half = mulBy(0.5)
half: Double => Double = <function1>
scala> half(10)
res3: Double = 5.0引入柯里化：
scala> mulBy(3)(10)
res4: Double = 30.0
（2）柯里化
概念：柯里化函数：是把具有多个参数的函数，转化为一个函数链，每个节点上都是单一函数
def add(x:Int,y:Int) = x+y
def add(x:Int)(y:Int) = x+y
转化步骤：
原始：def add(x:Int,y:Int) = x+y
闭包：def add(x:Int) = (y:Int) => x+y
简写：def add(x:Int)(y:Int) = x+y
scala> def add(x:Int)(y:Int) = x+y
add: (x: Int)(y: Int)Int
scala> add(1)(2)
res5: Int = 3
二、Scala集合
1、可变集合和不可变集合（Map）
immutable mutable
举例：
scala> def math = scala.collection.immutable.Map(“Tom”->80,”Lily”->20)
math: scala.collection.immutable.Map[String,Int]
scala> def math = scala.collection.mutable.Map(“Tom”->80,”Lily”->20,”Mike”->95)
math: scala.collection.mutable.Map[String,Int]
集合的操作：
获取集合中的值
scala> math.get(“Tom”)
res1: Option[Int] = Some(80)
scala> math(“Tom”)
res2: Int = 80
scala> math(“Tom123”)
java.util.NoSuchElementException: key not found: Tom123
at scala.collection.MapLike$class.default(MapLike.scala:228)
at scala.collection.AbstractMap.default(Map.scala:59)
at scala.collection.mutable.HashMap.apply(HashMap.scala:65)
… 32 elided
scala> math.get(“Tom123”)
res3: Option[Int] = None
scala> math.contains(“Tom123”)
res4: Boolean = false
scala> math.getOrElse(“Tom123”,-1)
res5: Int = -1
更新集合中的值：注意：必须是可变集合
scala> math
res6: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 80, Lily -> 20)
scala> math(“Tom”)=0
scala> math
res7: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 80, Lily -> 20)
造成上述现象的原因，没有import包，如果import以后，问题解决：
scala> import scala.collection.mutable._
import scala.collection.mutable._
scala> var math = Map(“Tom”->80,”Lily”->20,”Mike”->95)
math: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 80, Lily -> 20)
scala> math(“Tom”)=0
scala> math
res8: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 0, Lily -> 20)
添加新的元素
scala> math(“Tom”)=80
scala> math += “Bob”->85
res9: scala.collection.mutable.Map[String,Int] = Map(Bob -> 85, Mike -> 95, Tom -> 80, Lily -> 20)
移出一个元素
scala> math -= “Bob”
res10: scala.collection.mutable.Map[String,Int] = Map(Mike -> 95, Tom -> 80, Lily -> 20)
2、列表：可变列表，不可变列表
不可变列表 List
scala> var myList=List(1,2,3)
myList: List[Int] = List(1, 2, 3)
scala> val nullList:List[Nothing] = List()
nullList: List[Nothing] = List()
//二维列表
scala> val dim : List[List[Int]] = List(List(1,2,3),List(4,5,6))
dim: List[List[Int]] = List(List(1, 2, 3), List(4, 5, 6))
scala> myList.head
res11: Int = 1
scala> myList.tail
res12: List[Int] = List(2, 3)
注意：tail 是除了第一个元素外，其他的元素
可变列表：LinedList 在 scala.collection.mutable 包中
scala> var myList = scala.collection.mutable.LinkedList(1,2,3,4)
warning: there was one deprecation warning; re-run with -deprecation for details
myList: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)
需求：把上面列表中，每一个元素都乘以2
游标，指向列表的开始
var cur = myList
//Nil意思为空
while(cur != Nil ){
//把当前元素乘以2
cur.elem = cur.elem*2
//移动指针到下一个元素
cur = cur.next
}scala> var cur = myList
cur: scala.collection.mutable.LinkedList[Int] = LinkedList(1, 2, 3, 4)
scala> while(cur != Nil ){
| cur.elem = cur.elem*2
| cur = cur.next
| }
scala> myList
res13: scala.collection.mutable.LinkedList[Int] = LinkedList(2, 4, 6, 8)
scala> myList.map(_*2)
warning: there was one deprecation warning; re-run with -deprecation for details
res14: scala.collection.mutable.LinkedList[Int] = LinkedList(4, 8, 12, 16)
3、序列
（*）数据库中也有序列：sequence 、 auto increment
（1）作为主键，实现自动增长
（2）提高性能，序列在Oracle是在内存中的
（*）Vector Range
举例：
Vector 是一个带下标的序列，我们可以通过下标来访问Vector中的元素
scala> var v = Vector(1,2,3,4,5,6)
v: scala.collection.immutable.Vector[Int] = Vector(1, 2, 3, 4, 5, 6)
Range ： 是一个整数的序列
scala> Range(0,5)
res15: scala.collection.immutable.Range = Range(0, 1, 2, 3, 4)
从0开始，到5 ，但不包括5
scala> println(0 until 5)
Range(0, 1, 2, 3, 4)
scala> println(0 to 5)
Range(0, 1, 2, 3, 4, 5)
Range可以相加
scala> (‘0’ to ‘9’) ++ (‘A’ to ‘Z’)
res16: scala.collection.immutable.IndexedSeq[Char] = Vector(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)
把Range转换成list
scala> 1 to 5 toList
warning: there was one feature warning; re-run with -feature for details
res17: List[Int] = List(1, 2, 3, 4, 5)
4、集（Set）
不重复元素的集合，默认是HashSet，与java类似
scala> var s1 = Set(1,2,10,8)
s1: scala.collection.immutable.Set[Int] = Set(1, 2, 10, 8)
scala> s1 + 10
res18: scala.collection.immutable.Set[Int] = Set(1, 2, 10, 8)
scala> s1 + 7
res19: scala.collection.immutable.Set[Int] = Set(10, 1, 2, 7, 8)
scala> s1
res20: scala.collection.immutable.Set[Int] = Set(1, 2, 10, 8)
创建一个可排序的Set SortedSet
scala> var s2 = scala.collection.mutable.SortedSet(1,2,3,10,8)
s2: scala.collection.mutable.SortedSet[Int] = TreeSet(1, 2, 3, 8, 10)
判断元素是否存在
scala> s2.contains(1)
res21: Boolean = true
scala> s2.contains(1231231)
res22: Boolean = false
集的运算：union并集 intersect 交集 diff 差集
scala> var s1 = Set(1,2,3,4,5,6)
s1: scala.collection.immutable.Set[Int] = Set(5, 1, 6, 2, 3, 4)
scala> var s2 = Set(5,6,7,8,9,10)
s2: scala.collection.immutable.Set[Int] = Set(5, 10, 6, 9, 7, 8)
scala> s1 union s2
res23: scala.collection.immutable.Set[Int] = Set(5, 10, 1, 6, 9, 2, 7, 3, 8, 4)
scala> s1 intersect s2
res24: scala.collection.immutable.Set[Int] = Set(5, 6)
scala> s1 diff s2
res25: scala.collection.immutable.Set[Int] = Set(1, 2, 3, 4)
数据库里面的union操作，要求：
列数一样
列的类型一样
select A,B from ****
union
select C,D from *****函数的定义+返回值
def sum():Int =
python数据分析
pyspark
5、模式匹配
相当于java中的switch case语句 但是 功能更强大
package day5
/**
* 模式匹配
*/
object Demo1 {
def main(args: Array[String]): Unit = {
//1、相当于java switch case
var chi = '-'
var sign = 0
chi match {
case '+' => sign = 1
case '-' => sign = -1
case _ => sign = 0
}
println(sign)
/**
* 2、scala中的守卫，case _ if 匹配某种类型的所有值
* 需求：匹配所有的数字
*/
var ch2 = '5'
var result : Int = -1
ch2 match {
case '+' => println("这是一个加号")
case '-' => println("这是一个减号")
//这里的10表示转换成1十进制
case _ if Character.isDigit(ch2) => result=Character.digit(ch2,10)
case _ => println("其他")
}
println(result)
/**
* 3、在模式匹配中使用变量
* 如果改成var mystr = "Hello W+rld"
* 打印：加号
*
* 匹配中，则相当于break
*/
var mystr = "Hello World"
//取出某个字符，赋给模式匹配的变量
mystr(7) match {
case '+' => println("加号")
case '-' => println("减号")
//case 语句中使用变量 ch代表传递进来的字符
case ch => println(ch)
}
/**
* 4、匹配类型 instance of
* 用法：case x : Int =>
*
* Any : 表示任何类型，相当于java中的Object
* Unit : 表示没有值， void
* Nothing : 表示在函数抛出异常时，返回值就是Nothing
* 是scala类层级中的最低端，是任何其他类型的子类型
* Null : 表示引用类型的子类，值：null
*
* 特殊类型
* Option : 表示一个值是可选的（有值或者无值）
* Some : 如果值存在，Option[T] 就是一个Some[T]
* None : 如果值不存在，Option[T] 就是一个None
*
* scala> var myMap = Map("Time"->96)
* myMap: scala.collection.immutable.Map[String,Int] = Map(Time -> 96)
*
* scala> myMap.get("Time")
* res0: Option[Int] = Some(96)
*
* scala> myMap.get("Time12342")
* res1: Option[Int] = None
*
* Nil : 空的List
*
* 四个N总结：None Nothing Null Nil
* None : 如果值不存在，Option[T] 就是一个None
* Nothing : 如果方法抛出异常时，则异常的返回值类型就是Nothing
* Null : 可以赋值给所以的引用类型，但是不能赋值给值类型
* class Student
* var s1 = new Student
* s1 = null
* Nil : 空的List
*/
var v4 : Any = 100
v4 match {
case x : Int => println("这是一个整数")
case s : String => println("这是一个字符串")
case _ => println("这是其他类型")
}
//5、匹配数组和列表
var myArray = Array(1,2,3)
myArray match {
case Array(0) => println("数组中只有一个0")
case Array(x,y) => println("数组中包含两个元素")
case Array(x,y,z) => println("数组中包含三个元素")
case Array(x,_*) => println("这是一个数组，包含多个元素")
}
var myList = List(1,2,3)
myList match {
case List(0) => println("列表中只有一个0")
case List(x,y) => println("列表中包含两个元素，和是" + (x+y))
case List(x,y,z) => println("列表中包含三个元素，和是" + (x+y+z))
case List(x,_*) => println("列表中包含多个元素，和是" + myList.sum)
}
}
}6、样本类
定义： case class
package day5
/**
* 使用case class 来实现模式匹配
*/
class Vehicle
case class Car(name:String) extends Vehicle
case class Bike(name:String) extends Vehicle
object Demo2 {
def main(args: Array[String]): Unit = {
var aCar : Vehicle = new Car("Car")
aCar match {
case Car(name) => println("汽车 " + name)
case Bike(name) => println("自行车 " + name)
case _ => println("其他")
}
}
}作用：
（1）支持模式匹配，instanceof
（2）定一个 Spark SQL 中的 schema ： 表结构
scala> class Fruit
defined class Fruit
scala> class Banana(name:String) extends Fruit
defined class Banana
scala> class Apple(name:String) extends Fruit
defined class Apple
scala> var a = new Apple("Apple")
a: Apple = Apple@572e6fd9
scala> println(a.isInstanceOf[Fruit])
true
scala> println(a.isInstanceOf[Banana])
<console>:16: warning: fruitless type test: a value of type Apple cannot also be a Banana
println(a.isInstanceOf[Banana])
^
false三、Scala高级特性
1、泛型
和java类似 T
1）泛型类
定义类的时候，可以带有一个泛型的参数
例子：
package day5
/**
* 泛型类
*/
//需求：操作一个整数
class GenericClassInt{
//定义一个整数的变量
private var content : Int = 10
//定义set get
def set(value : Int) = content = value
def get() : Int = content
}
//需求：操作一个字符串
class GenericClassString{
//定义一个空字符串
private var content : String = ""
//定义set get
def set(value : String) = content = value
def get() : String = content
}
class GenericClass[T]{
//定义变量
//注意：初始值用_来表示
private var content : T = _
//定义set get
def set(value : T) = content = value
def get() : T = content
}
object Demo3{
def main(args: Array[String]): Unit = {
//定义一个Int 类型
var v1 = new GenericClass[Int]
v1.set(1000)
println(v1.get())
//定义一个String 类型
var v2 = new GenericClass[String]
v2.set("Ni")
println(v2.get())
}
}2）泛型函数
定义一个函数，可以带有一个泛型的参数
scala> def mkIntArray(elem:Int)=`Array[Int](elem:_)`
mkIntArray: (elem: Int*)Array[Int]
scala> mkIntArray(1,2,3)
res5: Array[Int] = Array(1, 2, 3)
scala> mkIntArray(1,2,3,4,5)
res6: Array[Int] = Array(1, 2, 3, 4, 5)
scala> def mkStringArray(elem:String)=`Array[String](elem:_)`
mkStringArray: (elem: String*)Array[String]
scala> mkStringArray(“a”,”b”)
res7: Array[String] = Array(a, b)
scala> def mkArray[T:ClassTag]
ClassTag ： 表示scala在运行时候的状态信息，这里表示调用时候数据类型
scala> import scala.reflect.ClassTag
import scala.reflect.ClassTag
scala> def mkArray[T:ClassTag](elem:T*)= Array[T](elem:_*)
mkArray: [T](elem: T*)(implicit evidence$1: scala.reflect.ClassTag[T])Array[T]scala> mkArray(1,2)
res8: Array[Int] = Array(1, 2)
scala> mkArray(“Hello”,”aaa”)
res9: Array[String] = Array(Hello, aaa)
scala> mkArray(“Hello”,1)
res10: Array[Any] = Array(Hello, 1)
泛型：但凡有重复的时候，考虑使用泛型
3）上界和下界
Int x
规定x的取值范围 100 <= x <=1000
泛型的取值范围：
T
类的继承关系 A —> B —> C —> D 箭头指向子类
定义T的取值范围 D <: T <: B
T 的 取值范围 就是 B C D
<: 就是上下界的表示方法
概念
上界 S <： T 规定了 S的类型必须是 T的子类或本身
下界 U >： T 规定了 U的类型必须是 T的父类或本身
例子：
package day5
/**
* 主界
*/
//定义父类
class Vehicle{
//函数：驾驶
def drive() = println("Driving")
}
//定义两个子类
class Car extends Vehicle{
override def drive() : Unit = println("Car Driving")
}
//class Bike extends Vehicle{
// override def drive(): Unit = println("Bike Driving")
//}
class Bike{
def drive(): Unit = println("Bike Driving")
}
object ScalaUpperBoud {
//定义驾驶交通工具的函数
def takeVehicle[T <: Vehicle](v:T) = v.drive()
def main(args: Array[String]): Unit = {
//定义交通工具
var v : Vehicle = new Vehicle
takeVehicle(v)
var c : Car = new Car
takeVehicle(c)
//因为没有继承Vehicle，所以运行报错
var b : Bike = new Bike
takeVehicle(b)
}
}scala> def addTwoString[T <: String](x:T,y:T) = x +" ********* " + y
addTwoString: [T <: String](x: T, y: T)String
scala> addTwoString("Hello","World")
res11: String = Hello ********* World
scala> addTwoString(1,2)
<console>:14: error: inferred type arguments [Int] do not conform to method addTwoString's type parameter bounds [T <: String]
addTwoString(1,2)
^
<console>:14: error: type mismatch;
found : Int(1)
required: T
addTwoString(1,2)
^
<console>:14: error: type mismatch;
found : Int(2)
required: T
addTwoString(1,2)
^
scala> addTwoString(1.toString,2.toString)
res13: String = 1 ********* 24）视图界定 View bounds
就是上界和下界的扩展
除了可以接收上界和下界规定的类型以外，还可以接收能够通过隐式转换过去的类型
用 % 来表示
scala> def addTwoString[T <% String](x:T,y:T) = x +" ********* " + y
addTwoString: [T](x: T, y: T)(implicit evidence$1: T => String)String
scala> addTwoString(1,2)
<console>:14: error: No implicit view available from Int => String.
addTwoString(1,2)
^
//定义隐式转换函数
scala> implicit def int2String(n:Int):String = n.toString
warning: there was one feature warning; re-run with -feature for details
int2String: (n: Int)String
scala> addTwoString(1,2)
res14: String = 1 ********* 2执行过程
1、调用了 int2String Int => String
2、addTwoString(“1”,”2”)
5）协变和逆变（概念）
协变：表示在类型参数前面加上 + 。泛型变量的值，可以是本身类型或者其子类类型
例子：
package day5
/**
* 协变：表示在类型参数前面加上 + 。泛型变量的值，可以是本身类型或者其子类类型
*/
class Animal
class Bird extends Animal
class Sparrow extends Bird
//定义第四个类，吃东西的类，协变，有继承关系了
class EatSomething[+T](t:T)
object Demo4 {
def main(args: Array[String]): Unit = {
//定义一个鸟吃东西的对象
var c1 : EatSomething[Bird] =new EatSomething[Bird](new Bird)
//定义一个动物吃东西的对象
var c2 : EatSomething[Animal] = c1
/**
* 问题：能否把c1 赋给c2
* c1 c2都是EatSomething
* c1 c2 没有继承关系
*
* class EatSomething[T](t:T)
* var c2 : EatSomething[Animal] = c1 报错
* 原因 ： EatSomething[Bird] 并没有继承EatSomething[Animal]
*
* class EatSomething[+T](t:T)
* 报错消失
*
* 协变
*/
var c3 : EatSomething[Sparrow] = new EatSomething[Sparrow](new Sparrow)
var c4 : EatSomething[Animal] = c3
}
}逆变：表示在类型参数前面加上 - 。泛型变量的值，可以是本身类型或者其父类类型
例子：
package day5
/**
* 逆变：表示在类型参数前面加上 - 。泛型变量的值，可以是本身类型或者其父类类型
*/
class Animal
class Bird extends Animal
class Sparrow extends Bird
//定义第四个类，吃东西的类，逆变
class EatSomething[-T](t:T)
object Demo5 {
def main(args: Array[String]): Unit = {
//定义一个鸟吃东西的对象
var c1 : EatSomething[Bird] =new EatSomething[Bird](new Bird)
//定义一个动物吃东西的对象
var c2 : EatSomething[Sparrow] = c1
}
}2、隐式转换
1）隐式转换函数： implicit
package day5
/**
* 隐式转换
*
* 定义一个隐式转换函数
*/
class Fruit(name:String){
def getFruitName() : String = name
}
class Monkey(f:Fruit){
def say() = println("Monkey like " + f.getFruitName())
}
object ImplicitDemo {
def main(args: Array[String]): Unit = {
//定义一个水果对象
var f : Fruit = new Fruit("Banana")
f.say()
}
implicit def fruit2Monkey(f:Fruit) : Monkey = {
new Monkey(f)
}
}2）隐式参数：使用implicit 修饰的函数参数
定义一个带有隐式参数的函数：
scala> def testPara(implicit name:String) = println("The value is " + name)
testPara: (implicit name: String)Unit
scala> testPara("AAAA")
The value is AAAA
scala> implicit val name : String = "*****"
name: String = *****
scala> testPara
The value is *****定义一个隐式参数，找到两个值中比较小的那个值
100 23 –>23
“Hello” “ABC” –> ABC
scala> def smaller[T](a:T,b:T)(implicit order : T => Ordered[T]) = if(a<b) a else b
smaller: [T](a: T, b: T)(implicit order: T => Ordered[T])T
scala> smaller(1,2)
res18: Int = 1
scala> smaller("Hello","ABC")
res19: String = ABC解释：
order 就是一个隐式参数，我们使用Scala中的 Ordered 类，表示该值可以被排序，也就是可以被比较
作用：扩充了属性的功能
3）隐式类 在类名前 加 implicit 关键字
作用：扩充类的功能
package day5
/**
* 隐式类
*/
object Demo6 {
def main(args: Array[String]): Unit = {
//执行两个数字的求和
println("两个数字的和是： "+1.add(2))
/**
* 定义一个隐式类，类增强1的功能
*
* Calc(x:Int)
* 1是Int类型，所以就会传递进来
*
* 执行过程：
* 1--->Calc类
* var a = new Calc(1)
* 在调用Calc add方法
* a.add(2)
*
*/
implicit class Calc(x:Int){
def add(y: Int) : Int = x + y
}
}
}
