Swift和Java在函数(method/方法)方面的比较

1. 函数是用来完成特定任务的独立的代码块。Swift中函数的使用比Java中更灵活，在 Swift 中，可以把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。在函数的参数值类型和返回值类型方面，Swift和Java函数的用法是相似的。

2. 函数的申明和调用

Swift：

func sayHelloAgain(personName: String) -> String {
    return "Hello again, " + personName + "!"
}
print(sayHelloAgain("Anna"))
// prints "Hello again, Anna!"

函数以 func 作为前缀。指定函数返回类型时，用返回箭头 ->（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。

Java：

public String sayHello(String personName){
        return "hello, "+personName;
    }
System.out.println(sayHello("morden"));

3. 函数参数与返回值（Function Parameters and Return Values）

3.1 多重输入参数（Multiple Input Parameters）

Swift:

func halfOpenRangeLength(start:Int, end:Int)->Int{
            return end - start
        }

Java:

public int halfOpenRangeLength(int start, int end){
        return end - start;
    }

3.2 无参函数（Functions Without Parameters）

Swift:

func sayHelloWorld()->String{
            return "hello world"
        }

Java:

public String sayHelloWorld(){
        return "hello world";
    }

3.3 无返回值函数（Functions Without Return Values）

Swift:

func sayGoodbye(personName:String){
            print("GoodBye, (personName)")
        }

Java:

public void sayGoodbye(String personName){
        System.out.println("Goodbye, "+personName);
    }

注意：在返回值方面，Swift比Java语法灵活多了，看下面代码

func printAndCount(stringToPrint: String) -> Int {
    print(stringToPrint)
    return stringToPrint.characters.count
}
func printWithoutCounting(stringToPrint: String) {
    printAndCount(stringToPrint)
}
printAndCount("hello, world")
// prints "hello, world" and returns a value of 12
printWithoutCounting("hello, world")
// prints "hello, world" but does not return a value

第一个函数 printAndCount，输出一个字符串并返回 Int 类型的字符数。第二个函数printWithoutCounting调用了第一个函数，但是忽略了它的返回值。

3.4 多重返回值函数（Functions with Multiple Return Values）

func count(string: String) -> (vowels: Int, consonants: Int, others: Int) {
            var vowels = 0, consonants = 0, others = 0
            for character in string.characters {
                switch String(character).lowercaseString {
                case "a", "e", "i", "o", "u":
                    ++vowels
                case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
                "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
                    ++consonants
                default:
                    ++others
                }
            }
            return (vowels, consonants, others)
        }
    

这个例子中，count 函数用来计算一个字符串中元音，辅音和其他字母的个数（基于美式英语的标准）。

let total = count("some arbitrary string!")
print("(total.vowels) vowels and (total.consonants) consonants")
// prints "6 vowels and 13 consonants"

4. 外部参数名（External Parameter Names）

如果你希望函数的使用者在调用函数时提供参数名字，那就需要给每个参数除了局部参数名外再定义一个外部参数名。外部参数名写在局部参数名之前，用空格分隔。外部参数名函数格式如下：

func someFunction(externalParameterName localParameterName: Int) {
    // function body goes here, and can use localParameterName
    // to refer to the argument value for that parameter
}

Swift代码如下：

func join(string s1 : String, toString s2 : String, withJoiner joiner: String)->String{
        return s1 + joiner + s2
    }
//调用函数
let temp = join(string: "hello", toString: "world", withJoiner: ", ")
print(temp)

默认参数值（Default Parameter Values）.你可以在函数体中为每个参数定义默认值。当默认值被定义后，调用这个函数时可以忽略这个参数。代码如下：

func join(string s1: String, toString s2: String, withJoiner joiner: String = " ") -> String {
    return s1 + joiner + s2
}

像第一个版本的 join 函数一样，如果 joiner 被赋值时，函数将使用这个字符串值来连接两个字符串：

join(string: "hello", toString: "world", withJoiner: "-")
// returns "hello-world"

当这个函数被调用时，如果 joiner 的值没有被指定，函数会使用默认值（" "）：

join(string: "hello", toString:"world")
// returns "hello world"

5. 可变参数（Variadic Parameters）

一个可变参数（variadic parameter）可以接受一个或多个值。函数调用时，你可以用可变参数来传入不确定数量的输入参数。通过在变量类型名后面加入（...）的方式来定义可变参数。传入可变参数的值在函数体内当做这个类型的一个数组。代码如下：

func arithmeticMean(numbers:Double...){
            var total : Double = 0
            for item in numbers{
                total += item
            }
            print("total is (total)")
        }
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8, 19)
// returns 10.0, which is the arithmetic mean of these three numbers

注意：一个函数至多能有一个可变参数，而且它必须是参数表中最后的一个。这样做是为了避免函数调用时出现歧义。如果函数有一个或多个带默认值的参数，而且还有一个可变参数，那么把可变参数放在参数表的最后。

6.常量参数和变量参数（Constant and Variable Parameters）

函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。但是，有时候，如果函数中有传入参数的变量值副本将是很有用的。你可以通过指定一个或多个参数为变量参数，从而避免自己在函数中定义新的变量。变量参数不是常量，你可以在函数中把它当做新的可修改副本来使用。通过在参数名前加关键字 var 来定义变量参数：

func alignRight(var string : String, count : Int, pad : Character)->String{
            let amountToPad = count - string.characters.count
            if amountToPad < 1 {
                return string
            }
            let padString = String(pad)
            for _ in 1...amountToPad {
                string = padString + string
            }
            return string
        }
let originalString = "hello"
let paddedString = alignRight(originalString, 10, "-")
// paddedString is equal to "-----hello"
// originalString is still equal to "hello"

注意： 对变量参数所进行的修改在函数调用结束后便消失了，并且对于函数体外是不可见的。变量参数仅仅存在于函数调用的生命周期中。

7. 输入输出参数（In-Out Parameters）

      变量参数，仅仅能在函数体内被更改。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。定义一个输入输出参数时，在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。你只能将变量作为输入输出参数。你不能传入常量或者字面量（literal value），因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数前加&符，表示这个值可以被函数修改。注意： 输入输出参数不能有默认值，而且可变参数不能用 inout 标记。如果你用 inout 标记一个参数，这个参数不能被 var 者 let 标记。

func swapTwoInts(inout a: Int, inout b: Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

我们可以用两个 Int 型的变量来调用 swapTwoInts。需要注意的是，someInt 和 anotherInt 在传入swapTwoInts 函数前，都加了 & 的前缀，代码如下：

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now (someInt), and anotherInt is now (anotherInt)")
// prints "someInt is now 107, and anotherInt is now 3”

从上面这个例子中，我们可以看到 someInt 和 anotherInt 的原始值在 swapTwoInts 函数中被修改，尽管它们的定义在函数体外。注意： 输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值，但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。

8. 函数类型（Function Types

函数类型（Function Types：每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。

 8.1 申明函数类型，代码如下：

func addTwoInts(a: Int, b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(a: Int, b: Int) -> Int {
    return a * b
}

8.2 使用函数类型（Using Function Types），代码如下：

var mathFunction: (Int, Int) -> Int = addTwoInts
print("Result: (mathFunction(2, 3))")
// prints "Result: 5"
mathFunction = multiplyTwoInts
print("Result: (mathFunction(2, 3))")
// prints "Result: 6"

8.3 函数类型作为参数类型（Function Types as Parameter Types）：你可以用(Int, Int) -> Int这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现交由给函数的调用者。代码如下：

func printMathResult(mathFunction: (Int, Int) -> Int, a: Int, b: Int) {
    print("Result: (mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "Result: 8”

8.4 函数类型作为返回类型（Function Type as Return Types）

我们可以用函数类型作为另一个函数的返回类型。需要做的是在返回箭头（->）后写一个完整的函数类型。下面的这个例子中定义了两个简单函数，分别是 stepForward 和stepBackward。stepForward 函数返回一个比输入值大一的值。stepBackward 函数返回一个比输入值小一的值。这两个函数的类型都是 (Int) -> Int：代码如下：

func stepForward(input: Int) -> Int {
    return input + 1
}
func stepBackward(input: Int) -> Int {
    return input - 1
}

chooseStepFunction 根据布尔值 backwards 来返回 stepForward 函数或 stepBackward 函数：代码如下：

func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    return backwards ? stepBackward : stepForward
}

现在可以用 chooseStepFunction 来获得一个函数，不管是那个方向：

var currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function

这个例子中计算出从 currentValue 逐渐接近到0是需要向正数走还是向负数走。currentValue 的初始值是3，这意味着 currentValue > 0 是真的（true），这将使得 chooseStepFunction 返回stepBackward 函数。一个指向返回的函数的引用保存在了 moveNearerToZero 常量中。

8.5 嵌套函数（Nested Functions）

你所见到的所有函数都叫全局函数（global functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数（nested functions）。默认情况下，嵌套函数是对外界不可见的，但是可以被他们封闭函数（enclosing function）来调用。一个封闭函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。你可以用返回嵌套函数的方式重写 chooseStepFunction 函数：

    func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
        func stepForward(input: Int) -> Int { return input + 1 }
        func stepBackward(input: Int) -> Int { return input - 1 }
        return backwards ? stepForward : stepBackward
    }

    @IBAction func Test(sender: AnyObject) {
        var currentValue = -4
        let moveNearerToZero = chooseStepFunction(currentValue < 0)
        // moveNearerToZero now refers to the nested stepForward() function
        while currentValue != 0 {
            print("(currentValue)... ")
            currentValue = moveNearerToZero(currentValue)
        }
    }

// -4...
// -3...
// -2...
// -1...