array函数参数 scala_2018年第47周-scala入门-类型参数

类型参数类似于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

在指定泛型类型的是偶，有时我们需要对泛型类型的范围进行界定，而不是可以是任意的类型。比如，我们可能要求某个泛型类型，它就必须是某个类的子类，这样在程序中就可以放心地调用泛型类型继承弗雷的方法，程序才能正常的使用和运行。此时就可以使用上下边界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>

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)

:14: error: inferred type arguments [Object] do not conform to class Party's type parameter bounds [T <: person>

val p = new Party(s,o)

^

:14: error: type mismatch;

found : Student

required: T

val p = new Party(s,o)

^

:14: error: type mismatch;

found : Other

required: T

val p = new Party(s,o)

^

语法[T<:person>

下边界Bounds

下边界，指定类型必须是某个类的父类

下边界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)

:16: error: type arguments [GrandChild] do not conform to method getIdCard's type parameter bounds [R >: Child]

getIdCard[GrandChild](g)

View Bounds

上下边界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)

//特定于法，

class Party[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)

: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

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")

: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

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"))

: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)

: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)

: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]参数。也就是可以传入某类及其子类的参数。

协变跟上边界[T<:>

逆变，理解了协变，那逆变就更好理解了，可以让函数enterMeet(card:Card[Professional])，原本是只能Professional的Card参数，现在只需要Card[-T]，即可传入Card[Master]和Card[Professional]参数。也就是可以传入某类及其父类的参数。