Download the playground file from github (Classes and Struct)
Class
A class is a blue print for a real-word entity such Player, Person etc. and it is used for creating objects. Class can have properties to store values and methods to add behaviour. Let us see this with an example class called Rectangle which has some properties and two methods for calculating area and for drawing a rectangle.
class Rectangle {
var name:String = ""
var length:Double = 0
var breadth:Double = 0
func area() -> Double {
return length * breadth
}
func draw() -> String {
return "Draw rectangle with area \(area()) "
}
}
let rect = Rectangle()
rect.length = 20
rect.breadth = 10
rect.draw()
In the above example, we have a class named Rectangle, with name, length and breadth as properties, area and draw are functions. rect is a instance variable or object of Rectangle class. On setting the length and breadth and calling draw function should provide the following output in Playground.
Similarly the below code create a Square class
class Square {
var name:String = ""
var length:Double = 0
func area() -> Double {
return length * length
}
func draw() -> String {
return "Draw a square with area \(area()) "
}
}
let squr = Square()
squr.length = 20
squr.draw()
Now instead of repeating property and functions in each classes let us use class inheritance to simplify these classes.
Class Inheritance
Let us create a parent class called Shape and its properties and functions will be inherited by Sub Classes Rectangle and Square.
Parent Class – Shape
class Shape {
var name: String = ""
func area() ->Double {
return 0
}
func draw() ->String {
return "Draw a \(name) with area \(area()) "
}
}
Sub Class – Square
class Square:Shape {
var length: Double = 0
override func area() ->Double {
return length * length
}
}
let squr = Square()
squr.name = "My Square"
squr.length = 5
squr.draw()
Sub Class – Rectangle
class Rectangle:Shape {
var length: Double = 0
var breadth: Double = 0
override func area() -> Double {
return length * breadth
}
}
let rect = Rectangle()
rect.name = "My Rectangle"
rect.length = 5
rect.breadth = 10
rect.draw()
Parent class Shape has been created with name property and with functions area and draw. The child class Square and Rectangle will inherit these property and methods. Apart from the parent class property, Square can have its own property length and Rectangle has length and breadth.
The parent class area function has been overridden by Square and Rectangle class to calculate corresponding areas. Now if you want add one more Shape such as Triangle, Circle etc the new class has to inherit Parent class (Shape) and add its own property and methods (or override methods).
Initialisers
Initialisers in Class and Struct are used for setting the default values for properties and for doing some initial setup. Here is a typical example of initialiser in a Class where the name property is initialised at the time of creating an instance.
class Shape {
var name: String
init(name: String) {
self.name = name
}
func area()-> Double {
return 0
}
func draw()-> String {
return "Draw a \(name) with area \(area())"
}
}
class Square: Shape {
var length: Double = 0
init() {
super.init(name: "MySquare")
}
override func area()-> Double {
return length * length
}
override func draw()-> String {
return "Draw a \(name) with area \(area())"
}
}
let squr = Square()
squr.length = 10
squr.draw()
The sub class Square initialises the name property in init function by calling super.init and after creating the Square instance you need to pass value for the length property.
Designated and Convenience Initialisers
Initialiser which initialises all the properties in a class is known as designated initialiser. A convenience initialiser will initialise only selected properties and in turn will call the designated initialiser in init function. Listed below is a Square class with designated initialiser and convenience initialiser
class Shape {
var name: String
init(name: String) {
self.name = name
}
func area()-> Double {
return 0
}
func draw()-> String {
return "Draw a \(name) with area \(area())"
}
}
class Square: Shape {
var length: Double
// Designated Initialiser
init(length:Double, name:String) {
self.length = length
super.init(name: name)
}
// Convenience Initialiser
convenience init(length: Double) {
self.init(length:length, name:"MySquare")
}
override func area()-> Double {
return length * length
}
override func draw()-> String {
return "Draw a \(name) with area \(area())"
}
}
let squr = Square(length: 10,name: "MySquare")
squr.draw()
let squrNew = Square(length: 20)
squrNew.draw()
Computed Property
A property in swift can be used for performing operation at the time of assigning value. Here is an example, where the length of Square is computed based on assigned area.
class Square {
var length: Double = 0
var area: Double {
get {
return length * length
}
set (newArea) {
self.length = sqrt(newArea)
}
}
}
let square = Square()
square.area = 4 // set call
square.length = 6
square.area // get call
lazy Property
Swift also provides lazy property whose value is assigned when the user access the property.
class Person {
var name: String
init (name: String) {
self.name = name
}
lazy var message: String = self.getMessage()
func getMessage()-> String {
return "Hello \(name)"
}
}
let person = Person(name: "Jason")
person.message
in the above code example, the value for message property is not set at the initialisation and will be set only when call the message property in person object. Some typical where you could due lazy property is when retrieving values from performance intensify operation such as Network or Read/Write.
Property Observers
Swift provides two property observers, willSet and didSet. These methods gets triggered when a value is about to be set for a property or after setting the property.
class Square {
var length: Double = 0 {
willSet(newLength) {
print("Setting length \(self.length) to new length \(newLength)")
}
didSet {
print("Length is modified - do some action here")
}
}
var area: Double {
get {
return length * length
}
set (newArea) {
self.length = sqrt(newArea)
}
}
}
let square = Square()
square.length = -6
square.area
In the above example, Square class length property has a willSet and didSet observers.
Struct
Struct and Class can both have properties, methods, protocols, extensions and initialisers. You can use struct to hold simple values and when you want to pass around those across your program.
struct GeoDetails {
var country: String
var ip: String
var isp: String
var latitude: Double
var longitude: Double
var timeZone: String
init(country: String, ip: String, isp: String, latitude:Double, longitude:Double, timeZone:String) {
self.country = country
self.ip = ip
self.isp = isp
self.latitude = latitude
self.longitude = longitude
self.timeZone = timeZone
}
func description()-> String {
return "Country " + self.country + ", ip " + self.ip + ", isp " + self.isp + ", latitude \(self.latitude), longitude \(self.longitude) "
}
}
Download the playground file from github (Classes and Struct)
