scala学习七：scala的高级特性

scala学习七：scala的高级特性

标签（空格分隔）： scala

一，泛型类

类和特质可以带类型参数，使用[]来定义类型参数

//T:泛型类的类型
class GenericClass[T]{
private var content:T=_
def set(value:T) ={content=value}
def get():T={content}
}
//test
object GenericClass{
def main(args:Array[String]){
val gen1=new GenericClass[Int]
gen1.set(100)
println(gen1.get())

val gen2=new GenericClass[String]
gen2.set("name")
println(gen2.get())

}
}

二，泛型函数

函数和方法也可以带类型参数，把类型参数放在方法名后面。

//ClassTag:上下文的运行状态
def mkArray[T:ClassTag](elem:T*) = Array[T](elem:*)
mkArray(1,2,3)
mkArray("tom","mike","lily ")

三，类型的上界和下界

class Vichael{
def drive() = println("vichael*************")
}
class Car extends Vichael{
override def drive() = println("car*************")
}
class Bicycle extends Vichael{
override def drive() = println("bicycle*************")
}

object test{
def takeVichael[T <:Car](v:T) = { v.drive() }
def main(args:Array[String]){
var c=new Car
takeVichael(c)
}
}

四，视图界定

def addTwoString[T <% String](x:T,y:T) = {println(x+"************"+y)}
implicit def int2String(n:Int):String = {n.toString}
addTwoString(100,200)

五，协变和逆变

协变：泛型变量的值可以是本身或者其子类

class Animal{}
class Bird extends Animal{}
class Sparrow extends Bird{}
class EatSomeThing[+T](t:T){}

object Demo{
def main(args:Array[String]){
val c1:EatSomeThing[Bird] = new EatSomeThing[Bird](new Bird)
val c2:EatSomeThing[Animal]=c1
}
}

逆变：泛型变量的值可以是本身或者其父类

class Animal{}
class Bird extends Animal{}
class Sparrow extends Bird{}
class EatSomeThing[-T](t:T){}

object Demo{
def main(args:Array[String]){
val c1:EatSomeThing[Animal] = new EatSomeThing[Animal](new Animal)
val c2:EatSomeThing[Bird]=c1
}
}

六，隐式函数

class Fruit(name:String){
def getName():String = {name}
}
class Monkey(f:Fruit){
def say() = {println("monkey like " + f.getName())}
}
object Demo{
implicit def fruitToMonkey(f:Fruit):Monkey ={new Monkey(f)}
def main(args:Array[String]){
var f:Fruit=new Fruit("apple")
f.say()

}
}

七，隐式参数

def testparameter(implicit name:String) = { println("the value is " + name)}
implicit val name="this is a implicit value"

testparameter

//利用隐式参数完成隐式转换
def smaller[T](a:T,b:T)(implicit order:T => Ordered[T]) ={if(order(a)<b) a else b}
smaller(100,12)
smaller("hello","abcd")

八，隐式类

object Demo{
implicit class Cal(x:Int){
def add(a:Int):Int = {a+x}
}
def main(args:Array[String]){
println(1.add(2))
/*
隐式类执行的过程：
1，当1.add(2)时，scala的编译器不会立即报错，在当前域中查找，有没有implicit修饰的同时可以将Int作为参数的构造器，并且具有add方法的类，通过查找，找到了Cal
2，利用隐式类来执行add方法
*/
}
}