Kotlin -- function

One 、 Function header

• Used fun Keyword to define the function ;
• The name of the function , The hump nomenclature is used （ In most cases ）;
• Function parameter , In order to (name: String) In this form , This means that the parameter type is String type ;
• return type , Immediately after the parameter ;
• Finally, the function body in curly braces , It represents the logic of the whole function .

Two 、 Function parameter

1. Default value parameter
   If you do not intend to pass in parameters , You can set default values for parameters in advance

   fun doSomething(a: Int=1) {
         
       
   }
   

2. Named value parameter

   fun doSomething(a: Int=1) {
         
       
   }
   
   doSomething(a = 2)
   

3、 ... and 、Unit Function of

If a function does not return any useful values , Its return type is Unit.Unit It's a type that has only one value ——Unit The type of . This value does not need to be explicitly returned . Be similar to void, however Unit Function solves the application in generics .

fun printHello(name: String?): Unit {
    
    if (name != null)
        println("Hello $name")
    else
        println("Hi there!")
    // `return Unit`  perhaps  `return`  It's optional 
}

Four 、TODO function

TODO The function throws an exception , The return value is Nothing type

public inline fun TODO(reason: String): Nothing = throw NotImplementedError("An operation is not implemented: $reason")

for example

fun sum(a: Int, b: Int):Int {
    
    if (a == null || b == null) {
    
        TODO(" abnormal ")
    }
    return a + b
}

5、 ... and 、 Anonymous functions

• Functions that are defined without names are called anonymous functions

• Anonymous functions are usually passed to or returned from other functions as a whole , Specify special rules

      val s = "abscsabsa"
      val count = s.count({
         letter ->
          letter == 'a'
      })
  

Anonymous function types and implicit returns

• () -> return type
• Unlike named functions , With a few exceptions , Anonymous functions don't need return Keyword returns data , Anonymous functions implicitly or automatically return the result of the last line of the function body

Anonymous function parameters

Like named functions , Anonymous functions can take no arguments , You can also take one or more parameters of any type

• The type of the parameter is defined in the type of the anonymous function

• The parameter name is placed in the function definition

      val blessingFunction: (String,Int) -> String = {
         name,age ->
          
      }
  

• it keyword ： When defining an anonymous function with only one parameter , have access to it Keyword indicates parameter name

      val blessingFunction: (String) -> String = {
        
          "hello $it"
      }
  

Type inference

• When defining a variable , If you have assigned an anonymous function to it as a variable , You don't need to show the specified variable type
  
• Type inference also supports anonymous functions with parameters , But anonymous functions Parameter name and parameter type There has to be
  

When defining parameters, the function of the function

fun showOnBoard(goodsName: String, showDiscount: (String,Int) -> String) {
    
    
}

In a nutshell ： If a function lambda Parameters last ,, Or the only parameter , Then cover it lambda A pair of parentheses for parameters can be omitted

    val blessingFunction = {
    
        "hello"
    }

6、 ... and 、 Function inlining

When inlining Kotlin It's an optimization mechanism , With inlining ,JVM No need to use lambda Object instance , Thus, variable memory allocation is avoided . Where need to be lambda, The compiler will copy and paste the function body to where . Otherwise ,JVM Will be the same for all lambda Allocate memory for the variables you deal with , This creates memory overhead , Performance issues .

7、 ... and 、 Function reference

Function references can convert a named function into a value parameter , Use lambda Where the expression is , You can use function references

8、 ... and 、 Function type as return type

Nine 、 Closure

• stay Kotlin in , Anonymous functions can modify and reference variables defined outside their scope , And one function references the variables of another function ,Kotlin Medium lambda It's a closure