Introduction To Swift For iOS

An Intertech Course

Introduction to Swift for iOS

Jason Shapiro, Intertech

Introduction to Core Data for iOS

Copyright © Intertech, Inc. • www.Intertech.com • 800-866-9884 Slide 2

Intertech

Training• Training through hands-on,

real world business examples.• Our site, your site, or live

online – globally.• Agile/Scrum, Citrix, VMware,

Oracle, IBM, Microsoft, Java/Open Source, and web and mobile technologies.

Consulting Design and develop software

that powers businesses and governments of all sizes.

On-site consulting, outsourcing, and mentoring.

Agile, .NET, Java, SQL Server, mobile development including iPhone and Android platforms and more….

Instructors Who Consult, Consultants Who Teach

Our Company Over 35 awards for growth,

innovation and workplace best practices.

99.7% satisfaction score from our consulting and training customers.

Yearly “Best Places to Work” winner in Minnesota.



Welcome• Jason S. Shapiro – [email protected]

• Intertech Blog: http://www.intertech.com/blog• My LinkedIn Profile - http://linkedin.com/in/jshapiro

• Intertech MVP, Senior Instructor, and Software Architect

• 20+ Years of Professional Software Development and Architecture Experience (Java EE, iOS, Web, Agile, etc.)

• Master of Science in Software Engineering (2004)

• Scrum Alliance Certified ScrumMaster

mailto:[email protected]

mailto:[email protected]



Welcome

• About this Presentation:• This is a beginner to intermediate level presentation. • The assumption is that you are have basic Object Oriented

programming experience (any OO language... it does not need to be Objective-C).

• A few part of the presentation will refer to Objective-C.• The final two demos are geared towards those who have

experience building iOS apps.



Agenda• What is Swift?• Swift vs. Objective-C• The Swift Programming Language

• Variables and Constants• Strings• Collections• Control Structures• Functions• Access Modifiers• Optionals• Classes

• Demos• Xcode 6’s “Playground”• Single View (w/ outlets and actions)• Table View

• Recap• Questions



What is Swift?

• A brand new programming language for iOS and OS X development.• Secretly in development for several years at Apple.• Announced at the WWDC in June of 2014.• Used to write applications for iOS 7+ and OS X Mavericks+• Xcode 6 includes Swift support (templates, “Playground,” etc.)

• Works with Objective-C• It’s possible to add Swift to existing Objective-C programs (and

call existing Objective-C libraries).• Designed to be succinct.

• Reasonable defaults are assumed, resulting in much less coding.• Syntax often includes the option to be more verbose for those that

prefer a more “classic” style of coding.



What is Swift: Objective-C Example



What is Swift: Swift Example



Swift vs. Objective C

• Objective-C is STILL a “first class language” for iOS development.• Swift can work side by side with Objective-C.• ... or you can ignore Swift altogether and continue to develop iOS 8

/ OS X Yosemite apps with Objective-C.• Objective-C is a very verbose language.

• Swift tries to remove code that can reasonably be assumed. • For example, in most (though not all) situations, you do not need

to include semicolons or parentheses, no need for a main function, or a header file... even, in some cases, internal parameter names!

• Objective-C variables & properties require explicit types declared.• Swift infers the type based on the value (though an explicit type

may be included).




• Objective-C has a special syntax for defining properties (@property)• Swift does not differentiate between a variable and a property. If

you make a variable, you’ve got a property!• Objective-C expects that you’ll be smart enough to call an init method

for a new object.• Swift treats init methods like constructors. • If you instantiate an object, it calls a matching init method.

• Objective-C inherits all init methods, which can complicate an instantiation path.• If you provide one or init methods, you will not inherit any from

your ancestors.




• Objective-C requires primitive/scalar values to be explicitly wrapped before adding to a collection.• Swift allows direct addition of primitives/scalar values without

any additional code.• Objective-C carries over a lot of syntactical “baggage” by being a sub-

set of C.• Swift uses modern programming syntax... no need to use * for a

pointer, etc.• Swift includes MANY constructs and features not found in Objective-C

• Including: Optionals, Deinitializers, Syntax for Designated vs. Convenience Initializers, Generics, Lazy Property Initialization, Most Unicode Characters for identifiers etc.



Swift: Variables and Constants

• Swift encourages the use of constants (for code safety & performance). • If you know a value will not change, use the “let” keyword.

• If a value may need to change, use “var” instead of “let.”

• Notice that in both examples, the type (String) is not explicitly defined.• i.e. String instructor = “Jason Shapiro”• The type is inferred by the value.• Regardless, Swift is a “Strongly Typed” language - once defined,

instructor can only hold String values.



Swift: Variables and Constants

• Constant values cannot change, however, if the value is an object, the object’s mutable properties may be modified.

• When a variable isn’t defined at the time of declaration, a type needs to be included:



Swift: Strings

• Strings are created by using a standard literal syntax (quotes).• If the String is immutable, use “let,” otherwise use “var.”

• Concatenation of multiple Strings is accomplished with the “+” or the “+=“ operator.



Swift: Strings

• Simple concatenation (no special formatting) of Strings and Variables/Constants uses a “\(variable)” syntax:

• If you want to use String format specifiers, the String class offers an init method (constructor) for that very purpose.• This involves a topic we haven’t covered yet (Object Instantiation),

but is included here for reference:



Swift: Collections

• An array is created using a square bracket literal syntax.• Once again, use “let” for an immutable array, and “var” for a

mutable array:

• Additional elements are added using the += operator:



Swift: Collections

• Array access is accomplished by traditional subscripting:

• Subscripting can include ranges:



Swift: Collections

• Dictionaries also use a square bracket literal syntax:

• Dictionaries use subscripting to add additional items:

• ... and values are retrieved using the same subscripting syntax:



Swift: Control Structures

• Conditionals do not require parentheses, but do require curly braces.




• Switch statements must be “exhaustive.”• If your set of case statements don’t hit every possible value, you

are required to add a “default.”




• Multiple case values can be added by using a comma.• Multiple case statement can be executed using the “fallthrough”

keyword.




• Simple For-In loops do not require parentheses:

• For-In loops have the ability to return tuples (multiple values)• Dictionaries return both the key and the value (rather than just

the key).




• Other loops look just like C based loops, however the parentheses are omitted.



Swift: Functions

• Functions look similar to C styled functions with a few key differences:• They are declared with the keyword “func.”• Method parameters are declared with the same “identifier:type”

syntax that variables and constants use.• Parameters are treated as constants (unless preceded w/ “var”)• Method parameters may declare default values• Return values are declared at the end of a function signature.



Swift: Functions

• Invoking a function that has default values requires that the parameter names are used:

• If the method left off the default values, the parameter names cannot be used:



Swift: Functions

• In order to use parameter names in the function invocation (when default values are not defined), you must add “external names” to the function signature:



Swift: Functions

• Functions have the ability to return multiple values per call (a tuple)

• Alternatively, the tuple values can be named and accessed with a dot operator:



Swift: Optionals

• When a method is invoked that could potentially return “no value,” the API author has to decide what should be returned in it’s place.• Should it be nil? false? 0?

• Optionals standardize what is returned when “no value” is appropriate.• In all cases, regardless if the return type is a primitive or object

type, a “no value” is returned as “nil.”• In fact, nil is so special in Swift, that additional requirements are

placed on variables.• Variables cannot be nil unless they are declared as an optional.• Variables that are not optionals MUST be initialized before they

are used.



Swift: Optionals

• In fact, nil is so special in Swift, that additional requirements are placed on variables.• Variables cannot be nil unless they are declared as an optional.• Variables that are not optionals MUST be initialized before they

are used.

• An optional is defined by adding a question mark:



Swift: Optionals

• Optional values are set just like normal variable values, however accessing the values requires a little more work:

• In order to pull the value out of an optional, you need to add the “!” (force unwrapping) operator.• Recall that we saw this used when accessing a dictionary value.



Swift: Optionals

• Similarly, we can access the courseName by using the “!” (force unwrapping) operator:

• There is, however a problem... although the “!” operator works when the optional is not nil, it throws an exception if it is nil:



Swift: Optionals

• In order to execute a safe unwrapping, use an optional in a conditional statement:

• A function can be declared to return an optional by adding a “?” to the signature.• If the value is not found, return nil... even if it’s for a primitive.



Swift: Optionals

• ... and to safely call a function that returns an optional:

• However, one of the goal’s of Swift is to be as succinct as possible. • Another syntax is available which tests and automatically unwraps

the value if it is not nil.



Swift: Classes

• Classes are typically made up of state and behavior (though it is possible for a class to contain only one or the other).• Unlike Objective-C, only one file is used for a Class... no more

header files!• There is no need to inherit from a base class like NSObject.• State is expressed as either stored or a computed properties.• Behavior is expressed as one or more method.



Swift: Classes

• Here are several example of how a class may be defined:



Swift: Classes

• An initializer is required for a class, and follow these rules:• The syntax looks like a function, but leaves off the “func” keyword

and the return value.• The name must be init() – however it can be overloaded with

different parameter lists.• If no inheritance is used for a class, and it contains some state, you

must provide at least one initializer explicitly.



Swift: Classes

• If inheritance is used AND you provide inline initialization for all of your properties, you will inherit your parent’s initializers.

• If you provide even one explicit initializer, you will not inherit any initializers from your parent.• AND you must call a parent initializer as the LAST statement in

your explicit initializer.



Swift: Classes

• The type of initializers we’ve been looking at are known as “designated initializers.”• Only designated initializers are allowed (and must) call a parent’s

initializer.• Classes that have convenience initializers (those that call other

initializers in the same class) must be designated as such.• If you try to call a super initializer in a convenience initializer, you

will get a compile error.



Swift: Classes



Swift: Classes

• Instantiating an object• The value is the name of the Class, along with the parameter list of

one of its initializers.• Yes! Initializers are called implicitly as instantiation time!• If there are parameters, their names are required.



Swift: Classes

• Stored Properties:• Any variable or constant that is a member of a class is a stored

property.• Accessed through the dot operator.• No instance variable is produced – there is only one way to access

a stored property (through the dot operator).• Optionals can be used for stored properties as well.

• Other than optionals, all stored properties must be initialized prior to being used.



Swift: Classes

• Lazy Stored Properties:• If the initialization of a property is expensive, you have the option

to declare that it should not be initialized unless (and until) someone accesses it.



Swift: Classes

• Computed Properties:• Must be a variable (cannot be a constant)• Dynamically created when method is invoked (no “backing store”)• Define the getter and optionally the setter:



Swift: Classes

• Methods• Methods are just functions that are included as members of the

class!



Demo: Xcode 6’s “Playground”



Demo: Single View App (IBOutlets & IBActions)



Demo: Table View



Recap• What is Swift?• Swift vs. Objective-C• The Swift Programming Language

• Variables and Constants• Strings• Collections• Control Structures• Functions• Access Modifiers• Optionals• Classes

• Demos• Xcode 6’s “Playground”• Single View (w/ outlets and actions)• Table View



Suggested Resources• Apple’s Swift Blog:

https://developer.apple.com/swift/blog/

• The Swift Programming Language: https://developer.apple.com/library/ios/documentation/Swift/Conceptual/Swift_Programming_Language/

• Stackoverflow Q&A on Swift: http://stackoverflow.com/questions/tagged/swift

• Intertech Blog – iOS Topics:http://www.intertech.com/Blog/category/ios-ipad-iphone/



Next Oxygen Blast Webinars• Visit our Free Developer Learning on our site

Next iOS Development Training (iPhone & iPad)• http://www.intertech.com/Training/Mobile/iOS/iOS

Upcoming Webinars and Training

http://www.intertech.com/Free-Developer-Training

http://www.intertech.com/Training/Mobile/iOS/iOS






Questions or Feedback?Jason Shapiro – [email protected]

Thank You

Technology

Introduction To Swift For iOS