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方法
        */
    }
}