part three<\/a>. A method belongs to a particular class and provides a means to access and modify an instance of that class in some way.<\/p>\nLet\u2019s add a simple method to our class that is used to reload the cannon\u2019s ammunition:<\/p>\n
class IonCannon {
\n static let capacity = 20
\n var ammunition = IonCannon.capacity {
\n didSet {
\n if ammunition < 0 {
\n ammunition = 0
\n } else if ammunition > IonCannon.capacity {
\n ammunition = IonCannon.capacity
\n }
\n }
\n }
\n
\n func reload() {
\n ammunition = IonCannon.capacity
\n }<\/codeswiftbold>
\n}<\/codeswift><\/p>\nWe can now easily reset our cannon to full capacity by calling the reload<\/codeswift> method. Here\u2019s an example:<\/p>\nlet cannon = IonCannon()
\ncannon.ammunition = 10
\nprint(“cannon.ammunition: \\(cannon.ammunition)”)
\ncannon.reload()
\nprint(“cannon.ammunition: \\(cannon.ammunition)”)<\/codeswift><\/p>\nYou should see the following output in the sidebar:<\/p>\n
cannon.ammunition: 10
\ncannon.ammunition: 20<\/codeswift><\/p>\nIn other words, calling reload<\/codeswift> has set the cannon\u2019s capacity from 10<\/codeswift> back to 20<\/codeswift>.<\/p>\nParameters<\/h4>\n
As with functions, you can optionally define one or more typed parameters for class methods.<\/p>\n
Let\u2019s add a method to our IonCannon<\/codeswift> class that fires a burst of ion pulses. The method takes a single parameter that is used to specify the number of ion pulses to fire:<\/p>\nclass IonCannon {
\n static let capacity = 20
\n var ammunition = IonCannon.capacity {
\n didSet {
\n if ammunition < 0 {
\n ammunition = 0
\n } else if ammunition > IonCannon.capacity {
\n ammunition = IonCannon.capacity
\n }
\n }
\n }
\n
\n func reload() {
\n ammunition = IonCannon.capacity
\n }
\n
\n func fireBurstOf(amount: Int) {
\n ammunition -= amount
\n }<\/codeswiftbold>
\n}<\/codeswift><\/p>\nWe’ve just added a method named fireBurstOf(_:)<\/codeswift> that simulates our ion cannon firing a specified number of pulses. Calling this method will deplete the instance’s ammunition<\/codeswift> property.<\/p>\nLet’s use our method to fire 4 ion bursts at the incoming Imperial fleet:<\/p>\n
let cannon = IonCannon()
\ncannon.fireBurstOf(4)<\/codeswift><\/p>\nWe can verify that the pulses were fired by querying our instance’s ammunition<\/codeswift> property:<\/p>\nprint(“The cannon has enough charge remaining to fire \\(cannon.ammunition) more ion bursts.”)<\/codeswift><\/p>\nThe line above will result in the following being sent to the appropriate output:<\/p>\n
The cannon has enough charge remaining to fire 16 more ion bursts.<\/code><\/p>\nCall the method again to fire 2 more bursts:<\/p>\n
cannon.fireBurstOf(2)<\/codeswift><\/p>\nYour ion cannon’s ammunition<\/codeswift> property will now have a value of 14<\/codeswift>. Hopefully you took out a few Star Destroyers with those shots.<\/p>\nIt’s possible to provide multiple versions of a method. Here’s an alternative version of our fireBurstOf(_:)<\/codeswift> method that expects two parameters – amount<\/codeswift> and numberOfTimes<\/codeswift>:<\/p>\nclass IonCannon {
\n static let capacity = 20
\n var ammunition = IonCannon.capacity {
\n didSet {
\n if ammunition < 0 {
\n ammunition = 0
\n } else if ammunition > IonCannon.capacity {
\n ammunition = IonCannon.capacity
\n }
\n }
\n }
\n
\n func reload() {
\n ammunition = IonCannon.capacity
\n }
\n
\n func fireBurstOf(amount: Int) {
\n ammunition -= amount
\n }
\n
\n func fireBurstOf(amount: Int, numberOfTimes: Int) {
\n ammunition -= (amount * numberOfTimes)
\n }<\/codeswiftbold>
\n}<\/codeswift><\/p>\nThe numberOfTimes<\/codeswift> parameter is used to specify multiple repetitions of our burst of ion pulses. For example, here’s how to fire off a burst of three ion pulses, four times:<\/p>\nlet cannon = IonCannon()
\ncannon.fireBurstOf(3, numberOfTimes: 4)<\/codeswift><\/p>\nNotice that we explicitly stated the name of the method’s second parameter when making our call. This should seem odd to you as we didn’t explicitly define an external name for our second parameter. In Swift, the default behaviour of local and external parameter names in methods differs from functions. Swift gives the first parameter in a method a local parameter name by default, but gives subsequent parameter names both a local and external parameter name.<\/p>\n
The reason for this is that Swift attempts to make method naming and calling similar to that of Objective-C. In Objective-C, the name of a method typically refers to the method’s first parameter using a preposition such as with<\/strong>, for<\/strong>, by<\/strong>, of<\/strong> etc. We can see this in our fireBurstOf(_:numberOfTimes:)<\/codeswift> method. The use of the Of<\/strong> preposition helps the method to be read as a sentence when it is called.<\/p>\n This naming and calling convention will be familiar to anyone who has coded in Objective-C. Those from other programming languages will likely take time to warm to it. It’s actually a very expressive feature of both Swift and Objective-C and when used properly can result in code that’s extremely easy to read. <\/div>\n
Return Values<\/h4>\n
As you would expect, values can be returned from methods in exactly the same manner as functions.<\/p>\n
As a quick example, let\u2019s modify our fireBurstOf(_:numberOfTimes:)<\/codeswift> method so that it returns the number of ion pulses that were actually fired. This will be useful since the requested number of pulses to fire may actually be greater than the cannon\u2019s current ammunition level.<\/p>\nChange your method\u2019s definition to this: <\/p>\n
func fireBurstOf(amount: Int, numberOfTimes: Int) -> Int<\/codeswiftbold> {
\n var remainingShots = amount * numberOfTimes
\n var actuallyFired = 0
\n while ammunition > 0 && remainingShots > 0 {
\n ammunition--
\n remainingShots--
\n actuallyFired++
\n }
\n
\n return actuallyFired<\/codeswiftbold>
\n}<\/codeswift><\/p>\nCool! We can now tell exactly how many ion pulses were fired on each attempt. Here\u2019s a quick example of how to use our updated method:<\/p>\n
let cannon = IonCannon()
\nprint(“Available ion pulses: \\(cannon.ammunition)”)
\nvar pulsesFired = cannon.fireBurstOf(17, numberOfTimes: 1)
\nprint(“Attempting to fire 17 ion pulses: \\(pulsesFired) actually fired with \\(cannon.ammunition) remaining.”)
\npulsesFired = cannon.fireBurstOf(5, numberOfTimes: 1)
\nprint(“Attempting to fire 5 ion pulses. \\(pulsesFired) actually fired with \\(cannon.ammunition) remaining.”)<\/codeswift><\/p>\nThe following will be output to the sidebar:<\/p>\n
Available ion pulses: 20
\nAttempting to fire 17 ion pulses: 17 actually fired with 3 remaining.
\nAttempting to fire 5 ion pulses: 3 actually fired with 0 remaining.<\/codeswift><\/p>\nAs you can see from the final line above. We attempted to fire 5 ion pulses when there was only enough ammunition for 3. Therefore our fireBurstOf(_:numberOfTimes:)<\/codeswift> method returned a value of 3<\/codeswift> indicating that only three ion pulses were actually fired. <\/p>\nDefault Parameter Values<\/h4>\n
As with functions, a default value can be assigned to parameters of a method. We can default our fireBurstOf(_:numberOfTimes:)<\/codeswift> method’s numberOfTimes<\/codeswift> parameter to 1<\/codeswift>. Doing so will allow us to remove our class\u2019 original fireBurstOf(_:)<\/codeswift> method while still providing the same API. Make the following changes:<\/p>\nfunc fireBurstOf(amount: Int) {<\/strike>
\n ammunition -= amount<\/strike>
\n}<\/strike>
\n
\nfunc fireBurstOf(amount: Int, numberOfTimes: Int = 1<\/codeswiftbold>) -> Int {
\n var remainingShots = amount * numberOfTimes
\n var actuallyFired = 0
\n while ammunition > 0 && remainingShots > 0 {
\n ammunition–
\n remainingShots–
\n actuallyFired++
\n }
\n
\n return actuallyFired
\n}<\/codeswift><\/p>\n Notice that we added a default value of
1<\/codeswift> to the fireBurstOf(_:numberOfTimes:)<\/codeswift> method\u2019s definition above. It\u2019s an easy code change to miss. <\/div>\nThanks to our default parameter, we can still make the following two types of calls even though we\u2019ve removed one of our methods:<\/p>\n
\n- fireBurstOf(_:)<\/codeswift><\/li>\n
- fireBurstOf(_:numberOfTimes:)<\/codeswift><\/li>\n<\/ul>\n
Here\u2019s a concrete example:<\/p>\n
let cannon = IonCannon()
\ncannon.fireBurstOf(5) \/\/ Will fire 5 ion pulses
\ncannon.fireBurstOf(5, numberOfTimes: 1) \/\/ Will also fire 5 ion pulses
\ncannon.fireBurstOf(5, numberOfTimes: 2) \/\/ Will fire 10 ion pulses<\/codeswift><\/p>\nType Methods<\/h3>\n
As well as instance methods, you can also define methods that belong to the class itself rather than an instance of the class. Such methods are known as type methods<\/em><\/strong> and are specified by placing the static<\/code> keyword before the method\u2019s func<\/code> keyword.<\/p>\n Those familiar with object-oriented languages such as Java and ActionScript 3 will be familiar with the concept of static methods. A type method is Swift\u2019s equivalent of a static method. <\/div>\n
Let\u2019s work through a simple example. We\u2019ll write a type method within our IonCannon<\/codeswift> class that returns a text description stating how well the Rebel Alliance are faring against the Galactic Empire. The description will be generated based on the number of Star Destroyers that have been successfully hit by all<\/strong> ion cannon instances.<\/p>\nStart by adding a type property that keeps track of the number of Star Destroyers that have been successfully hit by our ion cannons:<\/p>\n
class IonCannon {
\n static let capacity = 20
\n var ammunition = IonCannon.capacity {
\n didSet {
\n if ammunition < 0 {
\n ammunition = 0
\n } else if ammunition > IonCannon.capacity {
\n ammunition = IonCannon.capacity
\n }
\n }
\n }
\n static var directHits = 0<\/codeswiftbold>
\n
\n :
\n :
\n}<\/codeswift><\/p>\nWe\u2019ll also add a few lines to our fireBurstOf(_:numberOfTimes:)<\/codeswift> method so that it randomly attempts to increment the directHits<\/codeswift> type property each time an ion pulse is fired. Update your method to look like this: <\/p>\nimport Foundation<\/codeswiftbold>
\n
\nclass IonCannon {
\n static let capacity = 20
\n var ammunition = IonCannon.capacity {
\n didSet {
\n if ammunition < 0 {
\n ammunition = 0
\n } else if ammunition > IonCannon.capacity {
\n ammunition = IonCannon.capacity
\n }
\n }
\n }
\n static var directHits = 0
\n
\n :
\n :
\n
\n func fireBurstOf(amount: Int, numberOfTimes: Int = 1) -> Int {
\n var remainingShots = amount * numberOfTimes
\n var actuallyFired = 0
\n while ammunition > 0 && remainingShots > 0 {
\n ammunition–
\n remainingShots–
\n actuallyFired++
\n
\n if arc4random_uniform(10) == 0 {
\n IonCannon.directHits++
\n }<\/codeswiftbold>
\n }
\n
\n return actuallyFired
\n }
\n}<\/codeswift><\/p>\nNotice on the first line of code above that we imported iOS\u2019s Foundation library. Doing so provides support for random number generation via the arc4random_uniform(_:)<\/codeswift> global function.<\/p>\nFinally, we\u2019ll add our type method to the class. This method will examine the directHits<\/codeswift> type property and return a text description based on the number of Star Destroyers that have been successfully hit by all<\/strong> ion cannon instances. Add the following method at the end of your class:<\/p>\nstatic func report() -> String {
\n switch directHits {
\n case 0...2:
\n return “The rebel fleet has little chance”
\n case 3...5:
\n return “Some rebel transports may get away from Hoth”
\n default:
\n return “The entire rebel fleet will likely escape”
\n }
\n}<\/codeswift><\/p>\nAnd here\u2019s how we\u2019d use our updated class:<\/p>\n
let cannon1 = IonCannon()
\nlet cannon2 = IonCannon()
\nlet cannon3 = IonCannon()
\ncannon1.fireBurstOf(5, numberOfTimes: 3)
\ncannon2.fireBurstOf(12)
\ncannon3.fireBurstOf(7, numberOfTimes: 2)
\nprint(IonCannon.report())<\/codeswift><\/p>\nThe code above creates three ion cannon instances and fires off a burst of ion pulses from each. We then obtain a report to see if the cannon fire was enough to clear the Empire\u2019s Star Destroyers from the path of the fleeing Rebel fleet.<\/p>\n
Pay particular attention to how we call the report<\/codeswift> method. Since it\u2019s a type method we make a call directly on the class rather than an instance of the class. Here\u2019s the call again:<\/p>\nIonCannon.report()<\/codeswift><\/p>\nWe can also find out the actual number of direct hits by obtaining the value of the class\u2019