1、隐式参数
方法可以具有隐式参数列表，由参数列表开头的implicit关键字标记。如果该参数列表中的参数没有像往常一样传递，Scala将查看它是否可以获得正确类型的隐式值，如果可以，则自动传递。
Scala将查找这些参数的位置分为两类：
- Scala将首先查找隐式定义和隐式参数，这些参数可以在调用隐式参数块的方法时直接访问（无前缀）。
- 然后，它查找与隐式候选类型关联的所有伴随对象中隐式标记的成员。
abstract class Monoid[A] {
def add(x: A, y: A): A
def unit: A
}
object ImplicitTest {
implicit val stringMonoid: Monoid[String] = new Monoid[String] {
def add(x: String, y: String): String = x concat y
def unit: String = ""
}
implicit val intMonoid: Monoid[Int] = new Monoid[Int] {
def add(x: Int, y: Int): Int = x + y
def unit: Int = 0
}
def sum[A](xs: List[A])(implicit m: Monoid[A]): A =
if (xs.isEmpty) m.unit
else m.add(xs.head, sum(xs.tail))
def main(args: Array[String]): Unit = {
println(sum(List(1, 2, 3))) // intMonoid
println(sum(List("a", "b", "c"))) //stringMonoid
}
}
Monoid定义一个add在这里调用的操作，它返回一个A，一个unit能够创建一些（特定）的操作。
为了说明隐式参数如何工作，首先分别定义 stringMonoid和intMonoid字符串和整数。该implicit关键字指示对应的对象可以被隐式地使用。
该方法sum接受 List[A]并返回A，它从初始化A开始unit，并将A列表中的每个下一个与该add方法的下一个组合。使参数m隐含在这里意味着只需要在调用方法时提供参数，如果Scala可以找到隐Monoid[A]式m参数用于隐式参数。
在main方法中，调用sum两次，并且只提供参数。Scala现在将在上述范围内寻找隐含的内容。第一次调用sum传递List[Int]for xs，这意味着A就是Int。隐藏了隐式参数列表m，因此Scala将查找隐式类型Monoid[Int]。第一个查找规则读取
- Scala将首先查找隐式定义和隐式参数，这些参数可以在调用隐式参数块的方法时直接访问（无前缀）。
intMonoid是一个可以直接访问的隐式定义。它也是正确的类型，因此它会sum自动传递给方法。
第二次调用sum传递List[String]，这意味着A就是String。隐式查找将与使用相同的方式Int，但这次将查找stringMonoid，并自动传递为m。
输出如下:
2、隐式转换
从类型S到类型的隐式转换由T具有函数类型的隐式值定义S => T，或者由可转换为该类型的值的隐式方法定义。
隐式转换适用于两种情况：
- 如果表达式
e是类型S，并且S不符合表达式的预期类型T。 - 在
e.m具有e类型S的选择m中，如果选择器不表示成员S。
在第一种情况下，c搜索适用e于其结果类型符合的转换T。在第二种情况下，c搜索适用于e且其结果包含名为的成员的转换m。
如果隐式方法List[A] => Ordered[List[A]]在范围内，以及隐式方法Int => Ordered[Int]，则对两个类型列表的以下操作List[Int]是合法的：
List(1, 2, 3) <= List(4, 5)
Int => Ordered[Int]通过自动提供隐式方法scala.Predef.intWrapper。List[A] => Ordered[List[A]]下面提供了隐式方法的示例。
import scala.language.implicitConversions
implicit def list2ordered[A](x: List[A])
(implicit elem2ordered: A => Ordered[A]): Ordered[List[A]] =
new Ordered[List[A]] {
//替代
def compare(that: List[A]): Int = 1
}
隐式导入的对象scala.Predef声明了常用类型（例如scala.collection.immutable.Map别名Map）和方法（例如assert）的几个别名，但也有几个隐式转换。
例如，在调用期望的Java方法时java.lang.Integer，您可以自由地传递它scala.Int。这是因为Predef包含以下隐式转换：
import scala.language.implicitConversions implicit def int2Integer(x: Int) = java.lang.Integer.valueOf(x)
因为如果不加选择地使用隐式转换可能会有陷阱，编译器会在编译隐式转换定义时发出警告。
要关闭警告，请执行以下任一操作：
- 导入
scala.language.implicitConversions隐式转换定义的范围 - 使用调用编译器
-language:implicitConversions
编译器应用转换时不会发出警告。
3、多态方法
Scala中的方法可以按类型和值进行参数化。语法类似于泛型类。类型参数括在方括号中，而值参数括在括号中。例子如下：
def listOfDuplicates[A](x: A, length: Int): List[A] = {
if (length < 1)
Nil
else
x :: listOfDuplicates(x, length - 1)
}
println(listOfDuplicates[Int](3, 4))
println(listOfDuplicates("La", 8))
结果如下：
该方法listOfDuplicates采用类型参数A和值参数x和length。价值x是类型A。如果length < 1返回一个空列表。否则，前缀x到递归调用返回的重复列表。（注意，这::意味着将左侧的元素添加到右侧的列表中。）
例1中，通过写入显式提供了类型参数[Int]。因此，第一个参数必须是a Int，返回类型将是List[Int]。
例2显示您并不总是需要显式提供type参数。编译器通常可以根据上下文或值参数的类型来推断它。在这个例子中，"La"是一String所以编译器知道A必须String。
4、类型推断
Scala编译器通常可以推断表达式的类型，因此您不必显式声明它。
- 省略类型
val businessName = "Café"
编译器可以检测到它businessName是一个String。它与方法类似：
def squareOf(x: Int) = x * x
编译器可以推断返回类型是 Int，因此不需要显式返回类型。
编译器无法对递归方法推断结果类型。这是一个程序，由于这个原因将使编译器失败：
def fac(n: Int) = if (n == 0) 1 else n * fac(n - 1)
在调用多态方法或实例化泛型类时，也不必强制指定类型参数。Scala编译器将从上下文和实际方法/构造函数参数的类型推断出这样的缺失类型参数。
这是两个例子：
case class MyPair[A, B](x: A, y: B); val p = MyPair(1, "scala") //多态方法 def id[T](x: T) = x val q = id(1) //泛型类
编译器使用参数的类型MyPair来确定哪种类型A和类型B。同样的类型x。
- 参数
编译器永远不会推断出方法参数类型。但是，在某些情况下，当函数作为参数传递时，它可以推断出匿名函数参数类型。
Seq(1, 3, 4).map(x => x * 2)
map的参数是f: A => B。因为我们把整数放在中Seq，所以编译器知道那A是Int（即它x是一个整数）。因此，编译器可以推断从x * 2该B是类型Int。
- 不依赖类型推断
通常认为声明在公共API中公开的成员类型更具可读性。因此，我们建议您为将向您的代码用户公开的任何API明确指定类型。
此外，类型推断有时可以推断出太具体的类型。假设我们写道：
var obj = null
我们不能继续进行这种重新分配：
obj = new AnyRef
它不会编译，因为推断的类型obj是Null。由于该类型的唯一值是null，因此无法分配不同的值。