萧然 2019-06-29
类型参数类似于Java中的泛型。注意了,是类型参数,不是参数类型, 顾名思义,就是把类型作为参数。跟Java泛型一样,在集合,类,函数中定义参数类型,然后保证 使用到该类型参数的地方,只能用这种类型,否则编译器报错。在编译期就能发现错误可以大大降低开发成本。
这里说的成本我是很想讨论下,开发成本,不仅仅指的是钱。如你在编写代码时,IDE就提示你错误了。这时候你就不用浪费时间去点击运行才发现错误,从而节省了你的时间,你可能会说时间就是钱啊,实际不那么是,因为得看角度,你的时间或许是你的金钱,但对于老板来说不是,因为你一天无论干什么,发呆、百度资料或做了个功能,老板都是给一样的钱。但开发成本,我觉得能够全面客观的描述这个项目花的劳动时间及资源。泛型类,顾名思义,其实就是在类的声明中,定义一些泛型类型,然后在类的内部,比如field或者method中使用。
使用泛型类,同城需要对类中的某些成员, 比如某些field或method中的参数或变量,进行统一的类型限制,这样可以保证程序更好的健壮性和稳定性。在编译期就能发现错误。
如果不是使用泛型进行统一的类型限制,那么在运行时发现错误,则处理错误的成本就要高很多了。
在使用类的时候,比如创建对象,将类型参数替换为实际的类型即可。或者直接给使用了泛型类的field赋值是,scala会自动进行类型推断。
例子:新生报到,每个学生来自不同的地方,id可能是Int,也可能是String
clas Student[T](val localId:T){ def getSchoolId(id:T) = "S-"+id+"-"+localId } val jc = new Student[Int](700) jc.getSchoolId("jc"); jc.getSchoolId(10);
泛型函数,与泛型类类似,可以给某个函数在声明时指定泛型类型,然后在函数体内,多个变量或返回值之间,就可以使用泛型类型进行声明,从而对某个特殊的变量,或者多个变量,进行强制性的类型限制。
与泛型类一样,你可以通过使用了泛型类型的变量传递值来让scala自动推断泛型的是积累下,也可以在调用函数时,手动指定函数类型。
例子:卡片售卖机,可以指定卡片的内容,内容可以是String类型或者Int类型
def getCard[T](content:T)={ if(content.isInstanceOf[Int]) "card:001,"+content else if(content.isInstanceOf[String]) "card: this your card, "+content else "card: "+content }
在指定泛型类型的是偶,有时我们需要对泛型类型的范围进行界定,而不是可以是任意的类型。比如,我们可能要求某个泛型类型,它就必须是某个类的子类,这样在程序中就可以放心地调用泛型类型继承弗雷的方法,程序才能正常的使用和运行。此时就可以使用上下边界Bounds的特性。
scala的上下边界特性允许泛型类型必须是某个类的子类,或者必须是某个类的弗雷。
上边界Bounds语法: T<:Person
例子:在派对上交朋友
class Person(val name:String){ def sayHello = println("Hello, I'm "+ name) def makeFriends(p:Person){ sayHello p.sayHello } } class Student(name:String) extends Person(name) class Other(name:String) class Party[T<:Person](p1:T,p2:T){ def play = p1.makeFriends(p2); } scala> val s = new Student("jc") s: Student = Student@718632e9 scala> val s2 = new Student("jc2") s2: Student = Student@3540ee91 scala> val p = new Party(s,s2) p: Party[Student] = Party@77240ed1 scala> p.play Hello, I'm jc Hello, I'm jc2 scala> val s3 = new Person("jc2") s3: Person = Person@38c9c7a0 scala> val p = new Party(s,s3) p: Party[Person] = Party@fa7e87b scala> val o = new Other("o") o: Other = Other@40cecfc0 scala> val p = new Party(s,o) <console>:14: error: inferred type arguments [Object] do not conform to class Party's type parameter bounds [T <: Person] val p = new Party(s,o) ^ <console>:14: error: type mismatch; found : Student required: T val p = new Party(s,o) ^ <console>:14: error: type mismatch; found : Other required: T val p = new Party(s,o) ^
语法[T<:Person],只要是Person类或及其子类即可。
下边界,指定类型必须是某个类的父类
下边界Bounds语法: T>:Child
例子:领身份证
class Father(val name:String) class Child(name:String) extends Father(name) class GrandChild(name:String) extends Child(name) def getIdCard[R>:Child](p:R){ if(p.getClass == classOf[Child]) println("please tell us your parents' names.") else if(p.getClass == classOf[Father]) println("sign your name to get your child's id card.") else println("sorry, you are not allowed to get id card.") } val c = new Child("jc child") val p = new Father("jc father") getIdCard(c) getIdCard(p) val g = new GrandChild("jc grandechild") getIdCard(g) //可执行成功 // 想要编译器能发现错误,就只能在调用函数式,指定类型参数 scala> getIdCard[GrandChild](g) <console>:16: error: type arguments [GrandChild] do not conform to method getIdCard's type parameter bounds [R >: Child] getIdCard[GrandChild](g)
上下边界Bounds,虽然可以让一种泛型类型,支持父子关系的多种类型。但是,在某个类与上下边界Bounds指定的父子类型范围内的类都没有任何关系,则默认是肯定不能接受的。
然而,View Bounds作为一种上下边界Bounds的加强版,支持对类型进行隐时转换,将指定的类型进行隐式转换后,再判断是否在边界指定得了类型范围内。
上边界Bounds语法: T>:Person
例子:跟小狗交朋友
class Person(val name:String){ def sayHello = println("Hello, I'm " + name) def makeFriends(p:Person){ sayHello p.sayHello } } class Student(name:String) extends Person(name) //特定于法,<% 代表Person及Person以下的类,可以包括隐式转换的 class Party[T<%Person](p1:T,p2:T){ def play = p1.makeFriends(p2); } scala> val s = new Student("jc") s: Student = Student@3e1e52b8 scala> val p = new Person("jcp") p: Person = Person@44f8d156 scala> val party = new Party(s,p) party: Party[Person] = Party@587f3671 scala> party.play Hello, I'm jc Hello, I'm jcp class Dog(val name:String){def sayHello = println("Wang, Wang, I'm "+ name)} scala> val d = new Dog("jdog") d: Dog = Dog@729dc481 //报错,因为没有指定隐式转换 scala> val party = new Party(s,d) <console>:14: error: No implicit view available from Object => Person. val party = new Party(s,d) ^ implicit def dog2person(dog: Object): Person= if(dog.isInstanceOf[Dog]){val _dog = dog.asInstanceOf[Dog]; new Person(_dog.name)} else Nil //需指定泛型类型,不然party.play就一直卡住 scala> val party = new Party[Person](s,d) party: Party[Person] = Party@702a694f scala> party.play Hello, I'm jc Hello, I'm jdog
Context Bounds是一种特殊的Bounds,它会根据泛型类型的声明,比如“T:类型”要求必须存在一个类型为“类型[T]”的隐式值。
就是可以使用scala的隐式类,并且可以控制参数类型的一致性
例子: 使用scala内置的比较器比较大小
class Calculator[T: Ordering](val number1:T, val number2:T){ def max(implicit order: Ordering[T]) = if(order.compare(number1,number2)>0) number1 else number2 } scala> val c = new Calculator(1,2) c: Calculator[Int] = Calculator@c62b064 scala> c.max res6: Int = 2 scala> val c = new Calculator(1,"2") <console>:13: error: No implicit Ordering defined for Any. val c = new Calculator(1,"2") ^ scala> val c = new Calculator("3","2") c: Calculator[String] = Calculator@409c4578 scala> c.max res7: String = 3
如果想实例化一个泛型数组,需运用到Manifest Context Bounds。也就是说,如果数组元素类型为T的话,需要为类或函数定义[T:Manifest]类型参数。
简单直白地说就是 固定语法,类和函数必须定义[T:Manifest],其里面才能使用泛型数组。
例子: 打包饭菜(不同食物类型分开打包)
class Meat(val name:String) class Vegetable(val name:String) def packageFood[T:Manifest](food: T*) = { val foodPackage = new Array[T](food.length) for(i <-0 until food.length) foodPackage(i) = food(i) foodPackage } scala> packageFood(new Meat("m1"),new Meat("m2")) res8: Array[Meat] = Array(Meat@18f4a2ae, Meat@7e319726) //由于scala有自动推断功能,所以想要编译期发现错误,需指定类型参数 scala> packageFood(new Meat("m1"),new Vegetable("v2")) res9: Array[Object] = Array(Meat@4c1bd6ce, Vegetable@16a7770b) //由于scala有自动推断功能,所以想要编译期发现错误,需指定类型参数 scala> packageFood[Meat](new Meat("m1"),new Vegetable("v2")) <console>:16: error: type mismatch; found : Vegetable required: Meat packageFood[Meat](new Meat("m1"),new Vegetable("v2"))
scala的协变和逆变是非常有特色的,完全解决了java中的泛型的一大遗憾。
举例子说,java中,如果有Professional是Master的子类,那么Card[Professional]是不是Card[Master]的子类?答案是:不是的。
例子:进入会场
class Master class Professional extends Master //大师以及大师级别以下的名片都可以进入会场 // class Card[+T] (val name:String) def enterMeet(card:Card[Master]){ println("welcome to have this meeting") } scala> val p = new Card[Professional]("p") p: Card[Professional] = Card@49f8e77c scala> enterMeet(p) welcome to have this meeting scala> val m = new Card[Master]("m") m: Card[Master] = Card@125d05e2 scala> enterMeet(m) welcome to have this meeting
协变,在上述例子也就是Card[Profession]是Card[Master]的子类,协变的语法是[+T],对比[T]:
scala> class Card[T] (val name:String) defined class Card scala> val p = new Card[Professional]("p") p: Card[Professional] = Card@6732963b def enterMeet(card:Card[Master]){ println("welcome to have this meeting") } scala> enterMeet(p) <console>:15: error: type mismatch; found : Card[Professional] required: Card[Master] enterMeet(p)
逆变,也就是上述例子Card[Master]是Card[Profession]的父类,逆变的语法是[-T],对比[+T]:
scala> class Card[-T](val name:String) defined class Card def enterMeet(card:Card[Master]){ println("welcome to have this meeting") } scala> val p = new Card[Professional]("p") p: Card[Professional] = Card@584ff37c scala> enterMeet(p) <console>:15: error: type mismatch; found : Card[Professional] required: Card[Master] enterMeet(p) ^ //只要专家级别的名片就可以进入会场,如果大师级别的过来了,当然可以了! def enterMeet(card:Card[Professional]){ println("welcome to have this meeting") } scala> enterMeet(p) welcome to have this meeting scala> val m = new Card[Master]("m") m: Card[Master] = Card@7ef67f5d scala> enterMeet(p) welcome to have this meeting
要点,协变和逆变的语法,可以让原本控制泛型很死的类或函数,扩展到其泛型的父类或子类:
协变,可以让函数enterMeet(card:Card[Master]),原本是只能Master的Card参数,现在只需要Card[+T],即可传入Card[Master]和Card[Professional]参数。也就是可以传入某类及其子类的参数。
逆变,理解了协变,那逆变就更好理解了,可以让函数enterMeet(card:Card[Professional]),原本是只能Professional的Card参数,现在只需要Card[-T],即可传入Card[Master]和Card[Professional]参数。也就是可以传入某类及其父类的参数。