Swift Methods

Swift is a function of the method associated with certain types

In Objective-C, classes are the only type defined methods. But Swift, you not only can choose whether you want to define a class / struct / enum, but also flexible in type (class / struct / enum) that you create on the definition method.

Instance Methods

In Swift language, an instance method belongs to a particular class, a structure or enumerated type instances.

Instance method provides the following methods:

• You can access and modify instance properties

• Example providing object-related functions

Examples of methods to write around it belongs between the types of braces ({}).

Examples of implicit method can access all methods and properties of other instances of the type to which it belongs.

Examples of methods can only be called a particular instance of the class to which it belongs.

Instance method can not be separated on the existing instance is called.

grammar

func funcname(Parameters) -> returntype
{
    Statement1
    Statement2
    ……
    Statement N
    return parameters
}

Examples

import Cocoa

class Counter {
    var count = 0
    func increment() {
        count++
    }
    func incrementBy(amount: Int) {
        count += amount
    }
    func reset() {
        count = 0
    }
}
// 初始计数值是0
let counter = Counter()

// 计数值现在是1
counter.increment()

// 计数值现在是6
counter.incrementBy(5)
print(counter.count)

// 计数值现在是0
counter.reset()
print(counter.count)

The above program execution output is:

6
0

Counter class defines three instance methods:

• increment so that the counter is incremented by one;
• incrementBy(amount: Int) make counter by a specified integer value is incremented;
• reset the counter is reset to 0.

Counter This class also declares a variable attribute count , use it to keep track of the current counter value.

Local parameter name and the name of the method the external parameters

Swift function parameters can have both a local name (in the body of the function used internally) and an external name (used when calling functions

Swift methods and Objective-C method very similar. Like in Objective-C, the same as the name of Swift in the method usually a preposition points to the first parameter method, for example: with, for, by, and so on.

Swift default only to the method of the first parameter the name of a local parameter name; the default at the same time to the second and subsequent global parameter name parameter name.

The following examples 'no1' declared locally in the parameter name in the swift. 'No2' for global declarations and accessed through an external program.

import Cocoa

class division {
    var count: Int = 0
    func incrementBy(no1: Int, no2: Int) {
        count = no1 / no2
        print(count)
    }
}

let counter = division()
counter.incrementBy(1800, no2: 3)
counter.incrementBy(1600, no2: 5)
counter.incrementBy(11000, no2: 3)

The above program execution output is:

600
320
3666

Whether to provide external name settings

We force the first argument to add an external name to the name of the local name as external use (Swift 2.0 before using the # sign).

import Cocoa

class multiplication {
    var count: Int = 0
    func incrementBy(first no1: Int, no2: Int) {
        count = no1 * no2
        print(count)
    }
}

let counter = multiplication()
counter.incrementBy(first: 800, no2: 3)
counter.incrementBy(first: 100, no2: 5)
counter.incrementBy(first: 15000, no2: 3)

The above program execution output is:

2400
500
45000

self property

Each instance of the type has a property called implicit self, self exactly the same as the instance itself.

You can use this implicit self a property in an instance method instance to reference the current instance.

import Cocoa

class calculations {
    let a: Int
    let b: Int
    let res: Int
    
    init(a: Int, b: Int) {
        self.a = a
        self.b = b
        res = a + b
        print("Self 内: \(res)")
    }
    
    func tot(c: Int) -> Int {
        return res - c
    }
    
    func result() {
        print("结果为: \(tot(20))")
        print("结果为: \(tot(50))")
    }
}

let pri = calculations(a: 600, b: 300)
let sum = calculations(a: 1200, b: 300)

pri.result()
sum.result()

The above program execution output is:

Self 内: 900
Self 内: 1500
结果为: 880
结果为: 850
结果为: 1480
结果为: 1450

Modify the value type instance method

Swift language structures, and enumerations are value types. In general, the type of the property value can not be modified in its instance methods.

But if you really need to change the structure or enumerated property in a specific way, you can choose the variation (mutating) the method, then the method can change the properties from the internal method; any changes, and it does at the end of the method it will be left in the original structure.

The method also can give it implied self property assignment a new instance of this new instance to replace the original instance with method.

import Cocoa

struct area {
    var length = 1
    var breadth = 1
    
    func area() -> Int {
        return length * breadth
    }
    
    mutating func scaleBy(res: Int) {
        length *= res
        breadth *= res
        
        print(length)
        print(breadth)
    }
}

var val = area(length: 3, breadth: 5)
val.scaleBy(3)
val.scaleBy(30)
val.scaleBy(300)

The above program execution output is:

9
15
270
450
81000
135000

In the process variable assigned to self

Variable method can assign attributes self implied a new instance.

import Cocoa

struct area {
    var length = 1
    var breadth = 1
    
    func area() -> Int {
        return length * breadth
    }
    
    mutating func scaleBy(res: Int) {
        self.length *= res
        self.breadth *= res
        print(length)
        print(breadth)
    }
}
var val = area(length: 3, breadth: 5)
val.scaleBy(13)

The above program execution output is:

39
65

Type methods

Instance method is a method is called an instance of the type, you can also define the type of method calls itself, this method is called type method.

Statement structure and enumerated type method before func keyword method with the keyword static. Class might use the keyword class to allow subclasses override the parent class implementation.

The same type and instance methods using the dot (.) Syntax to invoke.

import Cocoa

class Math
{
    class func abs(number: Int) -> Int
    {
        if number < 0
        {
            return (-number)
        }
        else
        {
            return number
        }
    }
}

struct absno
{
    static func abs(number: Int) -> Int
    {
        if number < 0
        {
            return (-number)
        }
        else
        {
            return number
        }
    }
}

let no = Math.abs(-35)
let num = absno.abs(-5)

print(no)
print(num)

The above program execution output is:

35
5