斯卡拉 |类型推断

如果处理了类型不匹配，Scala Type Inference 可以选择指定变量的类型。借助类型推断功能，我们可以减少编写编译器已经知道的东西的时间。 Scala 编译器通常可以推断出表达式的类型，因此我们不必显式声明它。
让我们先来看看在 scala 中如何声明不可变变量的语法。

val variable_name : Scala_data_type = value

例子：

// Scala program of type interference
object Geeks 
{ 
    
    // Main method 
    def main(args: Array[String]) 
    { 
        // prints a double value
        val a : Double = 7.893
        println(a)  
        println(a.getClass)
          
    } 
}

输出：

7.893
double

在上面的示例中，getClass 方法用于将变量的类型打印到控制台。对于上面的例子，变量“a”的类型是双精度的。

但是，通过类型推断，Scala 会自动检测变量的类型，而无需用户明确指定。
例子：

// Scala program of type interference
object Geeks { 
  
    // Main method 
    def main(args: Array[String]) 
    { 
        // type inference
        println("Scala Data Types")
        val number = 5
        val big_number = 100000000L
        val small_number = 1
        val double_number = 2.50
        val float_number = 2.50f
        val string_of_characters = "This is a string of characters"
        val byte = 0xc
        val character = 'D'
        val empty = ()
          
        println(number)
        println(big_number)
        println(small_number)
        println(double_number)
        println(float_number)
        println(string_of_characters)
        println(byte)
        println(character)
        println(empty)
          
    } 
}

输出：

Scala Data Types
5
100000000
1
2.5
2.5
This is a string of characters
12
D
()

请注意，没有为上述变量明确指定数据类型。

函数的 Scala 类型推断
现在我们将看看类型推断是如何在 Scala 中为函数工作的。
让我们先来看看函数是如何在 Scala 中声明的。
句法：

def function_name ([parameter_list]) : [return_type] = {
   
  // function body

}

例子：

// Scala program of multiply two numbers
object Geeks 
{ 
  
    // Main method 
    def main(args: Array[String])
    { 
          
        // Calling the function 
        println("Product of the two numbers is: " + Prod(5, 3)); 
    } 
      
      
    // declaration and definition of Product function 
    def Prod(x:Int, y:Int) : Int =
    { 
        return x*y 
    } 
}

输出：

Product of the two numbers is: 15

在上面的例子中，我们可以从声明中指定返回类型是 Int。使用 Scala 类型推断，Scala 会自动检测函数的类型，而无需用户明确指定。
例子：

// Scala program of type interference
object Geeks 
{ 
  
    def factorial(n: Int)= { 
          
        var f = 1
        for(i <- 1 to n) 
        { 
            f = f * i; 
        } 
          
        f 
    } 
  
    // Driver Code 
    def main(args: Array[String]) 
    { 
        println(factorial(5)) 
    }
  
}

输出：

def factorial(n: Int)=

在上面的示例中，冒号和返回类型被省略了。

另外，在上面的例子中，我们省略了“return f”到“f”的语句，因为我们没有指定返回类型。
如果放置了“return f”而不是“f”，则编译器将显示以下错误。

prog.scala:11: error: method factorial has return statement; needs result type
        return f
        ^

这显示了 Scala 类型推断的强大功能，但对于递归方法，编译器无法推断结果类型。上述阶乘函数也可以递归实现。
以下是没有类型推断的阶乘函数的递归定义。
例子：

// Scala program of using recursion
object Geeks { 
  
    // factorial function
    def factorial(n: Int): Int =
    { 
        if (n == 0) 
            return 1
        else
            return n * factorial(n-1) 
    } 
  
    // Driver Code 
    def main(args: Array[String]) 
    { 
        println(factorial(5)) 
    } 
  
}

输出：

示例：使用 Scala 类型推断

// Scala program of type interference
object Geeks 
{ 
      
    // Defining function with type interfrence
    def factorial(n: Int) =
    { 
        if (n == 0) 
            1
        else
            n * factorial(n-1) 
    } 
  
    // Driver Code 
    def main(args: Array[String]) 
    { 
        println(factorial(5)) 
    } 
  
}

输出：

Compile Errors :
prog.scala:8: error: recursive method factorial needs result type
            n * factorial(n-1)
                ^