在 scala 中以下工作
1 max 2
但以下不是
1 Math.pow 2
或
import Math.pow
1 pow 2
你能解释一下原因吗？
【问题讨论】：
math小写吗？
标签： scala
这里发生了几件事。简而言之：
在 1 max 2 的情况下，常量 1 被隐式转换为 Int（即 Int 类的实例）。
由于 Int 类定义了一个名为“max”的方法，该方法采用单个参数，您可以使用空格或infix notation。以下都是等价的（在 spark-shell 中运行）：
scala> 1 max 2
res8: Int = 2
scala> 1.max(2)
res9: Int = 2
scala> val x = 1 // Note the result type here is Int
x: Int = 1
scala> x.max(2)
res10: Int = 2
scala> x max (2)
res11: Int = 2
scala> 1 // Note the result type here is *also* Int
res12: Int = 1
scala> 1. // Here are all of the methods that are defined for an Int
!= + << >> byteValue ensuring formatted isInfinity isValidByte isWhole notify signum toChar toInt toString until
## - <= >>> ceil eq getClass isInstanceOf isValidChar longValue notifyAll synchronized toDegrees toLong unary_+ wait
% -> == ^ compare equals hashCode isNaN isValidInt max round to toDouble toOctalString unary_- |
& / > abs compareTo floatValue intValue isNegInfinity isValidLong min self toBinaryString toFloat toRadians unary_~ →
* < >= asInstanceOf doubleValue floor isInfinite isPosInfinity isValidShort ne shortValue toByte toHexString toShort underlying
请注意，Int 上有很多可用的方法，例如 max、min、+、- 等等。查看 say, + 的签名，我们可以看到 + 是一个接受单个参数的方法。因此我们可以做到以下几点：
scala> 1 + 2 // No surprises here
res15: Int = 3
scala> 1.+(2) // Huh? This works because + is a method of Int that takes a single parameter.
// This is effectively the same as your max example.
res16: Int = 3
scala> 1.+ // Here are the signatures of the + method.
def +(x: Char): Int
def +(x: Long): Long
def +(x: Float): Float
def +(x: Short): Int
def +(x: Double): Double
def +(x: Byte): Int
def +(x: String): String
def +(x: Int): Int
scala> 1 + 'A' // From the above, we can see that the following is also valid
res17: Int = 66 // because the return type is Int
scala> 1 + "41"
res18: String = 141 // In this case, the + operator is a String concatenation operator Because the return type is String
scala> 1 + "x"
res19: String = 1x // Also because the return is String, but possible more intuitive.
到问题的 pow 部分。
Math.pow 是一种采用 2 个参数的方法。因为它需要 2 个参数，所以您无法使用空格符号。 此外，pow 不是与 Int 关联的方法。它很像 Math 类的静态方法（实际上 Math 是一个对象）。所以，就像你不能说 x.pow(y,z) 你不能说 1.pow(y, z) 另一方面你可以说 Math.pow(x, 2) - 得到 x 平方 -因为这与 pow 方法的签名相匹配。
这是 Math.pow 的签名：
scala> Math.pow
def pow(x$1: Double,x$2: Double): Double
这比 + 稍微不那么令人兴奋，但很明显它需要 2 个 Doubles 并返回一个 Double。即使将整数作为参数提供（当需要双精度时），说 Math.pow(2,2) 的示例仍然有效，因为 Ints 会自动转换为 Double。
我希望这有助于解释您所看到的。我鼓励您在 spark-shell、sbt 或其他一些 scala REPL 中尝试这些示例。
【讨论】：
方法不一样的签名：
override def max(that: Long): Long
def pow(x$1: Double,x$2: Double): Double
第一个是Int的成员*，可以在1上调用，而第二个在Math对象上调用，必须有两个参数。
* 实际上是 RichInt 的隐式转换，但是从直观的使用角度来看，它涉及到同样的事情，所以这个微妙之处不应该打扰你
【讨论】：
方法：
override def max(that: Int): Int = math.max(self, that)
来自scala.runtime.RichInt class bc evry Int 被包装：
@inline implicit def intWrapper(x: Int) = new runtime.RichInt(x)
类scala.LowPriorityImplicits
但是RichInt 没有任何pow 方法。而且您必须重新指定 Math.pow 签名：
public static double pow(double a, double b)
并使用 2 个参数调用它或使用您自己开发的包装器，例如：
object MainClass {
implicit class IntHelper(i:Int) {
def pow(p:Int): Double = Math.pow(i, p)
}
def main(args: Array[String]): Unit = {
println(1 pow 2)
}
}
输出：
1.0
【讨论】：
1 max 2 只是1.max(2) 的语法糖。
由于1 是一个整数字面量，所有为scala.Int 定义的方法都可以通过这种方式应用。
不幸的是pow不是scala.Int的方法
但是你可以在scala.math.BigDecimal和scala.math.BigInt找到相关的方法。
所以下面的方法会起作用：
BigInt(1) pow 2
【讨论】：
Scala.Math Documentation 表示pow 函数接受两个 Double 类型的参数，并返回第一个参数的第二个参数次方的值。
这是pow函数的工作版本：
import Math.pow
val a: Double = 1
pow(a,2) // returns 1.0
【讨论】：