Swift Tutorial Part 2. The complete guide for Swift programming language

By: Hossam Ghareeb
hossam.ghareb@gmail.com
Part 2
The Complete Guide For
Programming Language

Contents
● Classes
● Inheritance
● Computed Properties
● Type Level
● Lazy
● Property Observers
● Structures
● Equality Vs Identity
● Type Casting
● Any Vs AnyObject
● Protocols
● Delegation
● Extensions
● Generics
● Operator Functions

Classes
● Swift is Object oriented language and you can create your own
custom classes .
● In Swift, you don't have to write interface and implementation
files like Obj-C. Just one file and Swift will care about everything.
● You can create classes with the keyword "class" and then you can
list all your attributes and methods.
● In creating new instances of your class, you don't need for
keywords like new, alloc, init . Just the class name and empty
parentheses ().
● Class instances are passed by reference.

Classes
● Student class example

Classes
● As in previous example, you can list easily your attributes. In Swift
class, attributes should have one of 3 conditions :
○ Defined with initial value like firstName.
○ Defined with Optional value like middleName.
○ Initialized inside the default initializer lastName.
● init() function is used to make a default initializer for the class.
● You can create multiple initializers that accept parameters.
● Methods are created easily like functions syntax.
● Deinitializer using deinit() can be use to free up any resources
that this instance holds them.

Inheritance
● In Swift, a class can inherit from another class using ":"
● Unlike Objective-C, a Swift class doesn't inherit from base class or
anything by default.
● Calling super is required when overriding any initializer from
super class.
● Use the keyword override when you want to override a function
from your super class.
● Use the keyword final before a class name to prevent it from
being inherited. Also you can use it before a function name to
prevent it from being overridden.

Computed Properties
● All previous properties are called "stored properties", because we
store values on them. In Swift, we have other type called
"Computed properties" as these properties don't store anything
but they compute the value from other properties.
● Open curly braces { } after property to write the code of
computing. You can do this if you wanna getter only.
● If you want to override setter , you will type code inside set{ } and
getter inside get { }
● If you didn't provide setter set { } the property will be considered
as readOnly
● A value called newValue will be available in setter to be used.

Type Level
● TypeLevel in Swift is a way to define properties and methods
called by Type itself, not by instance (like class methods)
● Write the keyword class before attribute or function to make it as
type level.

Lazy
● Lazy keyword is used before var attributes (var only not let) to
mark it as lazy initialized. It means that, initialize it only when it
will be used. So when you try to access this attribute it will be
initialized to be used, otherwise it will remain nil.

Property Observers
● Suppose you want to keep track about every change in a property
in a class. Swift gives you an awesome way to track it before and
after change using willSet { } and didSet { }
● In next example, we wanna keep track on player score. Also we
have a limit 1000 points in score, so if the score is set to value
more than 1000, it will remain 1000.
● newValue is given in willSet { } and oldValue is given in didSet { }
● If you want to change the
names of newValue and
oldValue do the following =>

Structures
● Structures and classes are very similar in Swift. Structures can
define properties, methods, define initializers, computed
properties and conform to protocols.
● Structures don't have Inheritance, Type Casting or Deinitializers
● String, Array and Dictionary are implemented as Structures!
● Structures are value types, so they are passed by value . When
you assigned it to another value, the struct value is copied.
● Structures have an automatically memberwise initializers to
initialize your properties

Equality Vs Identity
● We always used to use "==" for checking in equality. In Swift there
is another thing called Identity "===" and "!==". Its used only with
Objects to check if they point to the same object.
● Identity is used only with objects. You cannot use it with
structures.
● Two objects can be equal but not identical. Because they may
have the same values but they are different objects

Type Casting
● TypeCasting is a way for type checking and downcasting objects.
check this:
we created array of controls. As we know that Array should be typed,
Swift compiler found that they are different in type, so it had to look
for their common superclass which is UIView so this array is of type
UIView.
● We will use is keyword to check the type of object, check
example:

Type Casting
● If I wanted to use component, you can't because its UIView type.
To use it we can cast it to UILabel using as keyword. Use as if you
really sure that the downcast will work because it will give
runtime error if not.
● Use as? if you are not sure, it will return nil if downcast fails

Type Casting
In this example you will see how to use as?

Any Vs AnyObject
● In Swift you can set the type of object to AnyObject, its equivalent
to id in Objective-C.
● You can use it with arrays or dictionaries or anything. AnyObject
holds only Objects (class type references).
● Any can be anything like objects, tuples, closures,.....
● Use is, as and as? to downcast and check the type of Any or
AnyObject
Check examples:

Any Vs AnyObject
objects array has String, Label and Date !! so the compiler will try to
get their common super class of them, it will ended by "AnyObject".
But someone can say, "55 & true are not objects ???". In fact, they are
because in runtime Swift bridged them to Foundation classes. So
String will be bridged to NSString, Int & Bools will be bridged to
NSNumber. The common superclass for them now will be NSObject
which is equivalent to AnyObject in Swift
● AnyObject is like id, you can send any message to them (call any
function), but in runtime will give error is doesn't respond to this
message. check example:

Any Vs AnyObject
Here in runtime we got this error, because obj became of type
Number which doesn't respond to this method. So to avoid this you
have to use is as or as? to help check the type before using the object.

Protocols
● Protocols can easily be created using keyword protocol.
● Methods and properties can be listed between { } to be
implemented by class which conforms to this protocol
● Protocol properties can be readonly by adding {get} OR settable
and gettable by adding {get set} .
● Classes can conform to multiple protocols.
● Structures and enumerations can conform to protocols.
● You can use protocols as types in variables, properties, function
return type and so on.
● Protocols can inherit one or more protocols.

Protocols
● Add the keyword class in
inheritance list after ':' to limit
protocol adoption to classes only
(No structures or enumerations)
● When using protocols with
structures and enumerations, add
the keyword mutating before func
to indicate that this method is
allowed to modify the instance it
belongs or any properties in it.

Protocols Composition
● If you want a type to conform to multiple protocols use the form
protocol<SomeProtocol, AnotherProtocol>

Checking For Protocol Conformance
● Use is, as or as? to check for protocol conformance.
● You must mark your protocol with @objc attribute to check for
protocol conformance.
● @objc protocols can be adopted only by classes.
● @objc attribute tells compiler that this protocol should be
exposed to Objective-C code.

Optional Requirements In Protocols
● Attributes and methods can be optional by prefixing them with
the keyword optional. It means that they don't have to be
implemented.
● You check for an implementation of an optional requirement by
writing ? after the requirement. Thats because the optional
property or method that return value will return Optional value
so you can check it easily
● Optional protocol requirements can only be specified if your
protocol is marked with the @objc attribute

Delegation
● Delegation is the a best friend for any iOS developer and I think
there is no developer didn't use it before.
● Defining delegate property as optional is useful for not required
delegates OR to use its initial value nil, so when you use it as nil
you will not get errors ( Remember you can send msgs to nil)
Check example:

Delegation
Delegation
example

Extensions
● Extensions are like Categories in Objective-C
● You can use it with classes, structures and enumerations.
● They are not names like categories in Objective-C
● You can add properties, instance and class methods, new
initializers, nested types, subscripts and make it conform to a
protocol.
● Extensions can be created by this form:

Extension Examples
Using computed properties:
Here we have Double value to represent meters, we need it in Km and
Cm, we add an extension for Double

Extension Examples
Define new initializers:
We will add a new initializer for CGRect , to accept center point, width
and height.

Extension Examples
Define new methods:
In this example we will add new method in Int, it will take a closure to
run it with int value times.

Extension Examples
Define mutating methods:
Add methods that modify in the instance itself (mutate it):

Extension Examples
Protocol adoption with Extension:

Generics
● Generics is used to write reusable functions that can apply for any
type.
● Example for generics: Arrays and Dictionaries. You can create
Array with any type and once declared, it works with this kind.
● Suppose you need a function that takes array as parameter and
returns the first and last elements. In Swift you have to tell the
function the type of array and type of return values. So this will
not work for any kind of array. If you used AnyObject, the
returned values will be of kind AnyObject and you have to cast
them!
● To solve this we will use generics, check exmaple:

Generics
We will build a stack
data structure with
generic type. It can be
stack of Strings, Ints,
….. or even custom
objects.

Operator Functions
● Classes and structures can provide their own implementation of
operators (Operator overloading).
● You can add your custom operators and override them.
Check example, we will add some operators functions for CGVector

Thanks!
If you liked the tutorial, please share and tweet with your friends.
If you have any comments or questions, don't hesitate to email ME

Swift Tutorial Part 2. The complete guide for Swift programming language

Recommended

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Swift Tutorial Part 2. The complete guide for Swift programming language (20)

Recently uploaded (20)

Swift Tutorial Part 2. The complete guide for Swift programming language