BigData-24：scala高级

一、Scala的高级特性

（一）泛型
	1、泛型类：定义类的时候，可以带有一个泛型的参数
	
	2、泛型函数:也可以带有泛型的参数
	scala> //泛型函数

	scala> //定义一个函数：创建一个Int类型的数组

	scala> def mkIntArray(elem:Int*) = Array[Int](elem:_*)
	mkIntArray: (elem: Int*)Array[Int]

	scala> mkIntArray(1,2,3,4,5)
	res28: Array[Int] = Array(1, 2, 3, 4, 5)

	scala> //定义一个函数，创建 一个String类型的数组

	scala> def mkStringArray(elem:String*) = Array[String](elem:_*)
	mkStringArray: (elem: String*)Array[String]

	scala> mkStringArray("abc","xyz")
	res29: Array[String] = Array(abc, xyz)

	scala> //问题：能否创建一个通用的函数，可以创建整数的数组，也可以创建String类型数组
	
	import scala.reflect.ClassTag
	def mkArray[T:ClassTag](elem:T*) = Array[T](elem:_*)
	
	调用:
	mkArray(1,2,3)
	mkArray("abc","xyz")
	
	解释ClassTag???? 参考讲义
------------------------------------------------------------
	
	3、上界和下界：upper bound、lower bound
	               作用：是规定泛型的取值范围
				   
		（*）简单的例子	
				定义一个变量 ： Int x
				规定的x的取值范围：100 <= x <= 200
				                   下界        上界
								   
		（*）是规定泛型的取值范围
				举例：定义一个泛型（类型的变量）：T
				      类的继承关系： A--->B--->C--->D
					  规定T的取值范围： D <:   T    <: B
					  T的取值只能是：B C D
					  
		（*）概念：
				上界：S <:  T 规定了S的类型必须是T的子类或者本身
				下界：U >:  T 规定了U的类型必须是T的父类或者本身
					 
		（*）scala> //再看一个例子

				scala> //定义一个函数：拼加字符串

				scala> def addTwoString[T<:String](x:T,y:T)= {println(x+"***"+y)}
				addTwoString: [T <: String](x: T, y: T)Unit

				scala> addTwoString("Hello ","World")
				Hello ***World

				scala> addTwoString(1,2)  //希望得到: 1***2
				产生错误。1和2是可以转换成字符串的
				   
	4、视图界定：View bound
				 其实是上界和下界的一种扩展。
				 除了可以接收上界和下界规定的类型以外，还可以接收能够通过隐式转换过去的类型
				 用 % 表示
				 
				 def addTwoString[T<%String](x:T,y:T)= {println(x+"***"+y)}
				 （1）可以接收String和String的子类
				 （2）可以接收能够转换成String的其他数据
				 
				 调用 addTwoString(1,2)
				 error: No implicit view available from Int => String.
				 
				 一定定义转换的规则（通过隐式转换函数来实现）：多了一个关键字 implicit
				 implicit def int2String(n:Int):String = {n.toString}

				调用：
				scala> addTwoString(1,2)
				1***2
				
				执行的过程：（1）首先调用int2String，把Int转成String
				            （2）调用addTwoString，拼加字符串

				 
	5、协变和逆变
		概念：
		（1）协变：表示在类型参数的前面加上 + 
		（2）逆变：表示在类型参数的前面加上 -

（二）隐式转换

	1、隐式转换函数：多了一个关键字 implicit
	2、隐式参数：使用implicit申明的函数参数就叫隐式参数
				scala> //定义一个带有隐式参数的函数

				scala> def testParam(implicit name:String) = println("The value is " + name)
				testParam: (implicit name: String)Unit

				scala> //定义一个隐式参数

				scala> implicit val name:String = "AAAAA"
				name: String = AAAAA

				scala> testParam("BBBBB")
				The value is BBBBB

				scala> testParam
				The value is AAAAA	

				参考讲义：有一个复杂点的例子 P34
	
	3、隐式类：在类名前加上implicit
	           作用：一般来说，可以增强类的功能