1 - SWIFT OVERVIEW

Swift is a new programming language developed by Apple Inc for iOS and OS X development. Swift adopts the best of C and Objective-C, without the constraints of C compatibility.

• Swift makes use of safe programming patterns.
• Swift provides modern programming features.
• Swift provides Objective-C like syntax.
• Swift is a fantastic way to write iOS and OS X apps.
• Swift provides seamless access to existing Cocoa frameworks.
• Swift unifies the procedural and object-oriented portions of the language.
• Swift does not need a separate library import to support functionalities like input/output or string handling.

Swift uses the same runtime as the existing Obj-C system on Mac OS and iOS, which enables Swift programs to run on many existing iOS 6 and OS X 10.8 platforms.

Swift comes with playground feature where Swift programmers can write their code and execute it to see the results immediately.

The first public release of Swift was released in 2010. It took Chris Lattner almost 14 years to come up with the first official version, and later, it was supported by many other contributors. Swift has been included in Xcode 6 beta.

Swift designers took ideas from various other popular languages such as Objective-C, Rust, Haskell, Ruby, Python, C#, and CLU.

2 - SWIFT ENVIRONMENT

Local Environment Setup

---

Swift provides a Playground platform for learning purpose and we are going to setup the same. You need xCode software to start your Swift coding in Playground. Once you are comfortable with the concepts of Swift, you can use xCode IDE for iSO/OS x application development.

To start with, we consider you already have an account at Apple Developer website. Once you are logged in, go to the following link − Download for Apple Developers

This will list down a number of software available as follows

Now select xCode and download it by clicking on the given link near to disc image. After downloading the dmg file, you can install it by simply double-clicking on it and following the given instructions. Finally, follow the given instructions and drop xCode icon into the Application folder.

Now you have xCode installed on your machine. Next, open Xcode from the Application folder and proceed after accepting the terms and conditions. If everything is fine, you will get the following screen −

Select Get started with a playground option and enter a name for playground and select iOS as platform. Finally, you will get the Playground window as follows −

import UIKit var str = "Hello, playground"

If you create the same program for OS X program, then it will include import Cocoa and the program will look like as follows −

import Cocoa var str = "Hello, playground"

When the above program gets loaded, it should display the following result in Playground result area (Right Hand Side).

Hello, playground

Congratulations, you have your Swift programming environment ready and you can proceed with your learning vehicle "Tutorials Point".

3 - SWIFT BASIC SYNTAX

We have already seen a piece of Swift program while setting up the environment. Let's start once again with the following Hello, World! program created for OS X playground, which includes import Cocoa as shown below

import Cocoa /* My first program in Swift */ var myString = "Hello, World!" println(myString)

If you create the same program for iOS playground, then it will include import UIKit and the program will look as follows −

import UIKit var myString = "Hello, World!" println(myString)

When we run the above program using an appropriate playground, we will get the following result −

Hello, World!

Let us now see the basic structure of a Swift program, so that it will be easy for you to understand the basic building blocks of the Swift programming language.

Import in Swift

---

You can use the import statement to import any Objective-C framework (or C library) directly into your Swift program. For example, the above import cocoa statement makes all Cocoa libraries, APIs, and runtimes that form the development layer for all of OS X, available in Swift.

Cocoa is implemented in Objective-C, which is a superset of C, so it is easy to mix C and even C++ into your Swift applications.

Tokens in Swift

---

A Swift program consists of various tokens and a token is either a keyword, an identifier, a constant, a string literal, or a symbol. For example, the following Swift statement consists of three tokens

println("test!") The individual tokens are: println ( "test!" )

Comments

---

Comments are like helping texts in your Swift program. They are ignored by the compiler. Multi-line comments start with /* and terminate with the characters */ as shown below −

/* My first program in Swift */

Multi-line comments can be nested in Swift. Following is a valid comment in Swift −

/* My first program in Swift is Hello, World! /* Where as second program is Hello, Swift! */

Single-line comments are written using // at the beginning of the comment.

// My first program in Swift

Semicolons

---

Swift does not require you to type a semicolon (;) after each statement in your code, though it’s optional; and if you use a semicolon, then the compiler does not complain about it.

However, if you are using multiple statements in the same line, then it is required to use a semicolon as a delimiter, otherwise the compiler will raise a syntax error. You can write the above Hello, World! program as follows −

import Cocoa /* My first program in Swift */ var myString = "Hello, World!"; println(myString)

Identifiers

---

A Swift identifier is a name used to identify a variable, function, or any other user-defined item. An identifier starts with an alphabet A to Z or a to z or an underscore _ followed by zero or more letters, underscores, and digits (0 to 9). Swift does not allow special characters such as @, $, and % within identifiers. Swift is a case sensitive programming language. Thus, Manpower and manpower are two different identifiers in Swift. Here are some examples of acceptable identifiers −

Azad zara abc move_name a_123 myname50 _temp j a23b9 retVal

To use a reserved word as an identifier, you will need to put a backtick (`) before and after it. For example, class is not a valid identifier, but `class` is valid.

Keywords

---

class	deinit	enum	extension
func	import	init	internal
let	operator	private	protocol
public	static	struct	subscript
typealias	var

Keywords used in statements

---

break	case	continue	default
do	else	fallthrough	for
if	in	return	switch
where	while

Keywords used in particular contexts

---

associativity	convenience	dynamic	didSet
final	get	infix	inout
lazy	left	mutating	none
nonmutating	optional	override	postfix
precedence	prefix	Protocol	required
right	set	Type	unowned
weak	willSet

Whitespaces

---

A        line    containing     only     whitespace,    possibly    with    a    comment,    is known as a blank line, and a Swift compiler totally ignores it.

Whitespace is the term used in Swift to describe blanks, tabs, newline characters, and comments. Whitespaces separate one part of a statement from another and enable the compiler to identify where one element in a statement, such as int, ends and the next element begins. Therefore, in the following statement −

var age

there must be at least one whitespace character (usually a space) between var and age for the compiler to be able to distinguish them. On the other hand, in the following statement −

int fruit = apples + oranges //get the total fruits

no whitespace characters are necessary between fruit and =, or between = and apples, although you are free to include some for better readability.

Literals

---

A literal is the source code representation of a value of an integer, floating-point number, or string type. The following are examples of literals −

92 // Integer literal 4.24159 // Floating-point literal "Hello, World!" // String literal

4 - SWIFT DATA TYPES

While doing programming in any programming language, you need to use different types of variables to store information. Variables are nothing but reserved memory locations to store values. This means that when you create a variable, you reserve some space in memory.

You may like to store information of various data types like string, character, wide character, integer, floating point, Boolean, etc. Based on the data type of a variable, the operating system allocates memory and decides what can be stored in the reserved memory.

Built-in Data Types

---

Swift offers the programmer a rich assortment of built-in as well as user-defined data types. The following types of basic data types are most frequently when declaring variables −

• Int or UInt − This is used for whole numbers. More specifically, you can use Int32, Int64 to define 32 or 64 bit signed integer, whereas UInt32 or UInt64 to define 32 or 64 bit unsigned integer variables. For example, 42 and -23.
• Float − This is used to represent a 32-bit floating-point number and numbers with smaller decimal points. For example, 3.14159, 0.1, and -273.158.
• Double − This is used to represent a 64-bit floating-point number and used when floating-point values must be very large. For example, 3.14159, 0.1, and -273.158.
• Bool − This represents a Boolean value which is either true or false.
• String − This is an ordered collection of characters. For example, "Hello, World!"
• Character − This is a single-character string literal. For example, "C"
• Optional − This represents a variable that can hold either a value or no value.

We have listed here a few important points related to Integer types −

• On a 32-bit platform, Int is the same size as Int32.
• On a 64-bit platform, Int is the same size as Int64.
• On a 32-bit platform, UInt is the same size as UInt32.
• On a 64-bit platform, UInt is the same size as UInt64.
• Int8, Int16, Int32, Int64 can be used to represent 8 Bit, 16 Bit, 32 Bit, and 64 Bit forms of signed integer.
• UInt8, UInt16, UInt32, and UInt64 can be used to represent 8 Bit, 16 Bit, 32 Bit and 64 Bit forms of unsigned integer.

Bound Values

---

The following table shows the variable type, how much memory it takes to store the value in memory, and what is the maximum and minimum value which can be stored in such type of variables.

Type	Typical Bit Width	Typical Range
Int8	1byte	-127 to 127
UInt8	1byte	0 to 255
Int32	4bytes	-2147483648 to 2147483647
UInt32	4bytes	0 to 4294967295
Int64	8bytes	-9223372036854775808 to 9223372036854775807
UInt64	8bytes	0 to 18446744073709551615
Float	4bytes	1.2E-38 to 3.4E+38 (~6 digits)
Double	8bytes	2.3E-308 to 1.7E+308 (~15 digits)

Type Aliases

---

You can create a new name for an existing type using typealias. Here is the simple syntax to define a new type using typealias −

typealias newname = type

For example, the following line instructs the compiler that Feet is another name for Int −

typealias Feet = Int

Now, the following declaration is perfectly legal and creates an integer variable called distance −

import Cocoa typealias Feet = Int var distance: Feet = 100 println(distance)

When we run the above program using playground, we get the following result −

100

Type Safety

---

Swift is a type-safe language which means if a part of your code expects a String, you can't pass it an Int by mistake.

As Swift is type-safe, it performs type-checks when compiling your code and flags any mismatched types as errors.

import Cocoa var varA = 42 varA = "This is hello" println(varA)

When we compile the above program, it produces the following compile time error.

Playground execution failed: error: <EXPR>:6:6: error: cannot assign to 'let' value 'varA'
varA = "This is hello"

Type Inference

---

Type inference enables a compiler to deduce the type of a particular expression automatically when it compiles your code, simply by examining the values you provide. Swift uses type inference to work out the appropriate type as follows.

import Cocoa // varA is inferred to be of type Int var varA = 42 println(varA) // varB is inferred to be of type Double var varB = 3.14159 println(varB) // varC is also inferred to be of type Double var varC = 3 + 0.14159 println(varC)

When we run the above program using playground, we get the following result −

42
3.14159
3.14159

5 - SWIFT VARIABLES

A variable provides us with named storage that our programs can manipulate. Each variable in Swift has a specific type, which determines the size and layout of the variable's memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable.

Swift supports the following basic types of variables −

• Int or UInt − This is used for whole numbers. More specifically, you can use Int32, Int64 to define 32 or 64 bit signed integer, whereas UInt32 or UInt64 to define 32 or 64 bit unsigned integer variables. For example, 42 and -23.
• Float − This is used to represent a 32-bit floating-point number. It is used to hold numbers with smaller decimal points. For example, 3.14159, 0.1, and -273.158.
• Double − This is used to represent a 64-bit floating-point number and used when floating-point values must be very large. For example 3.14159, 0.1, and -273.158.
• Bool − This represents a Boolean value which is either true or false.
• String − This is an ordered collection of characters. For example, "Hello, World!"
• Character − This is a single-character string literal. For example, "C"

Swift also allows to define various other types of variables, which we will cover in subsequent chapters, such as Optional, Array, Dictionaries, Structures, and Classes.

The following section will cover how to declare and use various types of variables in Swift programming.

Variable Declaration

---

A variable declaration tells the compiler where and how much to create the storage for the variable. Before you use variables, you must declare them using var keyword as follows −

var variableName = <initial value>

The following example shows how to declare a variable in Swift −

import Cocoa var varA = 42 println(varA)

When we run the above program using playground, we get the following result −

42

Type Annotations

---

You can provide a type annotation when you declare a variable, to be clear about the kind of values the variable can store. Here is the syntax −

var variableName:<data type> = <optional initial value>

The following example shows how to declare a variable in Swift using Annotation. Here it is important to note that if we are not using type annotation, then it becomes mandatory to provide an initial value for the variable, otherwise we can just declare our variable using type annotation.

import Cocoa var varA = 42 println(varA) var varB:Float varB = 3.14159 println(varB)

When we run the above program using playground, we get the following result −

42
3.1415901184082

Naming Variables

---

The name of a variable can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because Swift is a case-sensitive programming language.

You can use simple or Unicode characters to name your variables. The following examples shows how you can name the variables −

import Cocoa var _var = "Hello, Swift!" println(_var) var 你好 = "你好世界" println(你好)

When we run the above program using playground, we get the following result −

Hello, Swift!
你好世界

Printing Variables

---

You can print the current value of a constant or variable with the println function. You can interpolate a variable value by wrapping the name in parentheses and escape it with a backslash before the opening parenthesis: Following are valid examples −

import Cocoa var varA = "Godzilla" var varB = 1000.00 println("Value of \(varA) is more than \(varB) millions")

When we run the above program using playground, we get the following result −

Value of Godzilla is more than 1000.0 millions

6 - SWIFT OPTIONALS

Swift also introduces Optionals type, which handles the absence of a value. Optionals say either "there is a value, and it equals x" or "there isn't a value at all".

An Optional is a type on its own, actually one of Swift’s new super-powered enums. It has two possible values, None and Some(T), where T is an associated value of the correct data type available in Swift.

Here’s an optional Integer declaration −

var perhapsInt: Int?

Here’s an optional String declaration −

var perhapsStr: String?

The above declaration is equivalent to explicitly initializing it to nil which means no value −

var perhapsStr: String? = nil

Let's take the following example to understand how optionals work in Swift −

import Cocoa var myString:String? = nil if myString != nil { println(myString) }else { println("myString has nil value") }

When we run the above program using playground, we get the following result −

myString has nil value

Optionals are similar to using nil with pointers in Objective-C, but they work for any type, not just classes.

Forced Unwrapping

---

If you defined a variable as optional, then to get the value from this variable, you will have to unwrap it. This just means putting an exclamation mark at the end of the variable.

Let's take a simple example −

import Cocoa var myString:String? myString = "Hello, Swift!" if myString != nil { println(myString) }else { println("myString has nil value") }

When we run the above program using playground, we get the following result −

Optional("Hello, Swift!")

Now let's apply unwrapping to get the correct value of the variable −

import Cocoa var myString:String? myString = "Hello, Swift!" if myString != nil { println( myString! ) }else { println("myString has nil value") }

When we run the above program using playground, we get the following result −

Hello, Swift!

Automatic Unwrapping

---

You can declare optional variables using exclamation mark instead of a question mark. Such optional variables will unwrap automatically and you do not need to use any further exclamation mark at the end of the variable to get the assigned value. Let's take a simple example −

import Cocoa var myString:String! myString = "Hello, Swift!" if myString != nil { println(myString) }else { println("myString has nil value") }

When we run the above program using playground, we get the following result −

Hello, Swift!

Optional Binding

---

Use optional binding to find out whether an optional contains a value, and if so, to make that value available as a temporary constant or variable.

An optional binding for the if statement is as follows −

if let constantName = someOptional { statements }

Let's take a simple example to understand the usage of optional binding −

import Cocoa var myString:String? myString = "Hello, Swift!" if let yourString = myString { println("Your string has - \(yourString)") }else { println("Your string does not have a value") }

When we run the above program using playground, we get the following result −

Your string has - Hello, Swift!

7 - SWIFT CONSTANTS

Constants refer to fixed values that a program may not alter during its execution. Constants can be of any of the basic data types like an integer constant, a floating constant, a character constant, or a string literal. There are enumeration constants as well.

Constants are treated just like regular variables except the fact that their values cannot be modified after their definition.

Constants Declaration

---

Before you use constants, you must declare them using let keyword as follows −

let constantName = <initial value>

Following is a simple example to show how to declare a constant in Swift −

import Cocoa let constA = 42 println(constA)

When we run the above program using playground, we get the following result −

42

Type Annotations

---

You can provide a type annotation when you declare a constant, to be clear about the kind of values the constant can store. Following is the syntax −

var constantName:<data type> = <optional initial value>

The following example shows how to declare a constant in Swift using Annotation. Here it is important to note that it is mandatory to provide an initial value while creating a constant −

import Cocoa let constA = 42 println(constA) let constB:Float = 3.14159 println(constB)

When we run the above program using playground, we get the following result −

42
3.1415901184082

Naming Constants

---

The name of a constant can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because Swift is a case-sensitive programming language. You can use simple or Unicode characters to name your variables. Following are valid examples −

import Cocoa let _const = "Hello, Swift!" println(_const) let 你好 = "你好世界" println(你好)

When we run the above program using playground, we get the following result −

Hello, Swift!
你好世界

Printing Constants

---

You can print the current value of a constant or variable using println function. You can interpolate a variable value by wrapping the name in parentheses and escape it with a backslash before the opening parenthesis: Following are valid examples −

import Cocoa let constA = "Godzilla" let constB = 1000.00 println("Value of \(constA) is more than \(constB) millions"

When we run the above program using playground, we get the following result −

Value of Godzilla is more than 1000.0 millions

8 - SWIFT LITERALS

A literal is the source code representation of a value of an integer, floating-point number, or string type. The following are examples of literals −

42 // Integer literal 3.14159 // Floating-point literal "Hello, world!" // String literal

Integer Literals

---

An integer literal can be a decimal, binary, octal, or hexadecimal constant. Binary literals begin with 0b, octal literals begin with 0o, and hexadecimal literals begin with 0x and nothing for decimal.

Here are some examples of integer literals −

let decimalInteger = 17 // 17 in decimal notation let binaryInteger = 0b10001 // 17 in binary notation let octalInteger = 0o21 // 17 in octal notation let hexadecimalInteger = 0x11 // 17 in hexadecimal notation

Floating-point Literals

---

A floating-point literal has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point literals either in decimal form or hexadecimal form.

Decimal floating-point literals consist of a sequence of decimal digits followed by either a decimal fraction, a decimal exponent, or both.

Hexadecimal floating-point literals consist of a 0x prefix, followed by an optional hexadecimal fraction, followed by a hexadecimal exponent.

Here are some examples of floating-point literals −

let decimalDouble = 12.1875 let exponentDouble = 1.21875e1 let hexadecimalDouble = 0xC.3p0

String Literals

---

A string literal is a sequence of characters surrounded by double quotes, with the following form −

"characters"

String literals cannot contain an unescaped double quote ("), an unescaped backslash (\), a carriage return, or a line feed. Special characters can be included in string literals using the following escape sequences −

Escape sequence	Meaning
\0	Null Character
\\	\character
\b	Backspace
\f	Form feed
\n	Newline
\r	Carriage return
\t	Horizontal tab
\v	Vertical tab
\'	Single Quote
\"	Double Quote
\000	Octal number of one to three digits
\xhh...	Hexadecimal number of one or more digits

The following example shows how to use a few string literals −

import Cocoa let stringL = "Hello\tWorld\n\nHello\'Swift\'" println(stringL)

When we run the above program using playground, we get the following result −

Hello World

Hello'Swift'

Boolean Literals

---

There are three Boolean literals and they are part of standard Swift keywords −

• A value of true representing true.
• A value of false representing false.
• A value of nil representing no value.

9 - SWIFT OPERATORS

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. Objective-C is rich in built-in operators and provides the following types of operators −

• Arithmetic Operators
• Comparison Operators
• Logical Operators
• Bitwise Operators
• Assignment Operators
• Range Operators
• Misc Operators

This tutorial will explain the arithmetic, relational, logical, bitwise, assignment and other operators one by one.

Arithmetic Operators

---

The following table shows all the arithmetic operators supported by Swift language. Assume variable A holds 10 and variable B holds 20, then −

Operator	Description	Example
+	Adds two operands	A + B will give 30
−	Subtracts second operand from the first	A − B will give -10
*	Multiplies both operands	A * B will give 200
/	Divides numerator by denominator	B / A will give 2
%	Modulus Operator and remainder of after an integer/float division	B % A will give 0
++	Increment operator increases integer value by one	A++ will give 11
--	Decrement operator decreases integer value by one	A-- will give 9

Comparison Operators

---

The following table shows all the relational operators supported by Swift language. Assume variable A holds 10 and variable B holds 20, then −

Operator	Description	Example
==	Checks if the values of two operands are equal or not; if yes, then condition becomes true.	(A == B) is not true.
!=	Checks if the values of two operands are equal or not; if values are not equal, then the condition becomes true.	(A != B) is true.
>	Checks if the value of left operand is greater than the value of right operand; if yes, then the condition becomes true.	(A > B) is not true.
<	Checks if the value of left operand is less than the value of right operand; if yes, then the condition becomes true.	(A < B) is true.
>=	Checks if the value of left operand is greater than or equal to the value of right operand; if yes, then the condition becomes true.	(A >= B) is not true.
<=	Checks if the value of left operand is less than or equal to the value of right operand; if yes, then the condition becomes true.	(A <= B) is true.

Logical Operators

---

The following table shows all the logical operators supported by Swift language. Assume variable A holds 1 and variable B holds 0, then −

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are non-zero, then the condition becomes true.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands is non-zero, then the condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then the Logical NOT operator will make it false.	!(A && B) is true.

Bitwise Operators

---

Bitwise operators work on bits and perform bit by bit operation. The truth tables for &, |, and ^ are as follows −

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assume if A = 60; and B = 13; now in binary format they will be as follows:

A = 0011 1100

B = 0000 1101

-----------------

A & B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

Bitwise operators supported by Swift language are listed in the following table. Assume variable A holds 60 and variable B holds 13, then −

Operator	Description	Example
&	Binary AND Operator copies a bit to the result, if it exists in both operands.	(A & B) will give 12, which is 0000 1100
|	Binary OR Operator copies a bit, if it exists in either operand.	(A | B) will give 61, which is 0011 1101
^	Binary XOR Operator copies the bit, if it is set in one operand but not both.	(A ^ B) will give 49, which is 0011 0001
~	Binary Ones Complement Operator is unary and has the effect of 'flipping' bits.	(~A ) will give -61, which is 1100 0011 in 2's complement form.
<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	A << 2 will give 240, which is 1111 0000
>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >> 2 will give 15, which is 0000 1111

Assignment Operators

---

Swift supports the following assignment operators −

Operator	Description	Example
=	Simple assignment operator, Assigns values from right side operands to left side operand	C = A + B will assign value of A + B into C
+=	Add AND assignment operator, It adds right operand to the left operand and assigns the result to left operand	C += A is equivalent to C = C + A
-=	Subtract AND assignment operator, It subtracts right operand from the left operand and assigns the result to left operand	C -= A is equivalent to C = C - A
*=	Multiply AND assignment operator, It multiplies right operand with the left operand and assigns the result to left operand	C *= A is equivalent to C = C * A
/=	Divide AND assignment operator, It divides left operand with the right operand and assigns the result to left operand	C /= A is equivalent to C = C / A
%=	Modulus AND assignment operator, It takes modulus using two operands and assigns the result to left operand	C %= A is equivalent to C = C % A
<<=	Left shift AND assignment operator	C <<= 2 is same as C = C << 2
>>=	Right shift AND assignment operator	C >>= 2 is same as C = C >> 2
&=	Bitwise AND assignment operator	C &= 2 is same as C = C & 2
^=	bitwise exclusive OR and assignment operator	C ^= 2 is same as C = C ^ 2
|=	bitwise inclusive OR and assignment operator	C |= 2 is same as C = C | 2

Range Operators

---

Swift includes two range operators, which are shortcuts for expressing a range of values. The following table explains these two operators.

Operator	Description	Example
Closed Range	(a...b) defines a range that runs from a to b, and includes the values a and b.	1...5 gives 1, 2, 3, 4 and 5
Half-Open Range	(a..< b) defines a range that runs from a to b, but does not include b.	1..< 5 gives 1, 2, 3, and 4

Misc Operators

---

Swift supports a few other important operators including range and ? : which are explained in the following table.

Operator	Description	Example
Unary Minus	The sign of a numeric value can be toggled using a prefixed -	-3 or -4
Unary Plus	Returns the value it operates on, without any change.	+6 gives 6
Ternary Conditional	Condition ? X : Y	If Condition is true ? Then value X : Otherwise value Y

Operators Precedence

---

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator.

For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Operator Type	Operator	Associativity
Primary Expression Operators	() [] . expr++ expr--	left-to-right
Unary Operators	* & + - ! ~ ++expr --expr * / % + - >> << < > <= >= == !=	right-to-left
Binary Operators	& ^ | && ||	left-to-right
Ternary Operator	?:	right-to-left
Assignment Operators	= += -= *= /= %= >>= <<= &= ^= |=	right-to-left
Comma	,	left-to-right

10 - SWIFT DECISION MAKING

Decision making structures require that the programmer specifies one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general from of a typical decision making structure found in most of the programming languages −

Swift provides the following types of decision making statements. Click the following links to check their detail.

S.No	Statement & Description
1	if statement An if statement consists of a Boolean expression followed by one or more statements.
2	if...else statement An if statement can be followed by an optional else statement, which executes when the Boolean expression is false.
3	if...else if...else Statement An if statement can be followed by an optional else if...else statement, which is very useful to test various conditions using single if...else if statement.
4	nested if statements You can use one if or else if statement inside another if or else if statement(s).
5	switch statement A switch statement allows a variable to be tested for equality against a list of values.

The ? : Operator

---

We have covered conditional operator ? : in the previous chapter which can be used to replace if...else statements. It has the following general form −

Exp1 ? Exp2 : Exp3;

Where Exp1, Exp2, and Exp3 are expressions. Notice the use and placement of the colon.

The value of a ? expression is determined like this: Exp1 is evaluated. If it is true, then Exp2 is evaluated and becomes the value of the entire ? expression. If Exp1 is false, then Exp3 is evaluated and its value becomes the value of the expression.

11 - SWIFT LOOPS

There may be a situation when you need to execute a block of code several number of times. In general statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times. Following is the general from of a loop statement in most of the programming languages −

Swift programming language provides the following kinds of loop to handle looping requirements. Click the following links to check their detail.

S.No	Loop Type & Description
1	for-in This loop performs a set of statements for each item in a range, sequence, collection, or progression.
2	for loop Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.
3	while loop Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body.
4	do...while loop Like a while statement, except that it tests the condition at the end of the loop body.

Loop Control Statements

---

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

Swift supports the following control statements. Click the following links to check their detail.

S.No	Control Statement & Description
1	continue statement This statement tells a loop to stop what it is doing and start again at the beginning of the next iteration through the loop.
2	break statement Terminates the loop statement and transfers execution to the statement immediately following the loop.
3	fallthrough statement The fallthrough statement simulates the behavior of swift switch to C-style switch.

12 - SWIFT STRINGS

Strings in Swift are an ordered collection of characters, such as "Hello, World!" and they are represented by the Swift data type String, which in turn represents a collection of values of Character type.

Create a String

---

You can create a String either by using a string literal or creating an instance of a String class as follows −

import Cocoa // String creation using String literal var stringA = "Hello, Swift!" println( stringA ) // String creation using String instance var stringB = String("Hello, Swift!") println( stringB )

When the above code is compiled and executed, it produces the following result −

Hello, Swift!
Hello, Swift!

Empty String

---

You can create an empty String either by using an empty string literal or creating an instance of String class as shown below. You can also check whether a string is empty or not using the Boolean property isEmpty.

import Cocoa // Empty string creation using String literal var stringA = "" if stringA.isEmpty { println( "stringA is empty" ) }else { println( "stringA is not empty" ) } // Empty string creation using String instance let stringB = String() if stringB.isEmpty { println( "stringB is empty" ) }else { println( "stringB is not empty" ) }

When the above code is compiled and executed, it produces the following result −

stringA is empty
stringB is empty

String Constants

---

You can specify whether your String can be modified (or mutated) by assigning it to a variable, or it will be constant by assigning it to a constant using let keyword as shown below −

import Cocoa // stringA can be modified var stringA = "Hello, Swift!" stringA + = "--Readers--" println( stringA ) // stringB can not be modified let stringB = String("Hello, Swift!") stringB + = "--Readers--" println( stringB )

When the above code is compiled and executed, it produces the following result −

Playground execution failed: error: <EXPR>:10:1: error: 'String' is not convertible to '@lvalue UInt8'
stringB + = "--Readers--"

String Interpolation

---

String interpolation is a way to construct a new String value from a mix of constants, variables, literals, and expressions by including their values inside a string literal.

Each item (variable or constant) that you insert into the string literal is wrapped in a pair of parentheses, prefixed by a backslash. Here is a simple example −

import Cocoa var varA = 20 let constA = 100 var varC:Float = 20.0 var stringA = "\(varA) times \(constA) is equal to \(varC * 100)" println( stringA )

When the above code is compiled and executed, it produces the following result −

20 times 100 is equal to 2000.0

String Concatenation

---

You can use the + operator to concatenate two strings or a string and a character, or two characters. Here is a simple example −

import Cocoa let constA = "Hello," let constB = "World!" var stringA = constA + constB println( stringA )

When the above code is compiled and executed, it produces the following result −

Hello,World!

String Length

---

Swift strings do not have a length property, but you can use the global count() function to count the number of characters in a string. Here is a simple example −

import Cocoa var varA = "Hello, Swift!" println( "\(varA), length is \(count(varA))" )

When the above code is compiled and executed, it produces the following result −

Hello, Swift!, length is 13

String Comparison

---

You can use the == operator to compare two strings variables or constants. Here is a simple example −

import Cocoa var varA = "Hello, Swift!" var varB = "Hello, World!" if varA == varB { println( "\(varA) and \(varB) are equal" ) }else { println( "\(varA) and \(varB) are not equal" ) }

When the above code is compiled and executed, it produces the following result −

Hello, Swift! and Hello, World! are not equal

Unicode Strings

---

You can access a UTF-8 and UTF-16 representation of a String by iterating over its utf8 and utf16 properties as demonstrated in the following example −

import Cocoa var unicodeString = "Dog‼🐶" println("UTF-8 Codes: ") for code in unicodeString.utf8 { print("\(code) ") } print("\n") println("UTF-16 Codes: ") for code in unicodeString.utf16 { print("\(code) ") }

When the above code is compiled and executed, it produces the following result −

UTF-8 Codes:
68 111 103 226 128 188 240 159 144 182
UTF-16 Codes:
68 111 103 8252 55357 56374

String Functions & Operators

---

Swift supports a wide range of methods and operators related to Strings −

S.No	Functions/Operators & Purpose
1	isEmpty A Boolean value that determines whether a string is empty or not.
2	hasPrefix(prefix: String) Function to check whether a given parameter string exists as a prefix of the string or not.
3	hasSuffix(suffix: String) Function to check whether a given parameter string exists as a prefix of the string or not.
4	toInt() Function to convert numeric String value into Integer.
5	count() Global function to count the number of Characters in a string.
6	utf8 Property to return a UTF-8 representation of a string.
7	utf16 Property to return a UTF-16 representation of a string.
8	unicodeScalars Property to return a Unicode Scalar representation of a string.
9	+ Operator to concatenate two strings, or a string and a character, or two characters.
10	+= Operator to append a string or character to an existing string.
11	== Operator to determine the equality of two strings.
12	< Operator to perform a lexicographical comparison to determine whether one string evaluates as less than another.
13	== Operator to determine the equality of two strings.

13 - SWIFT CHARACTERS

A character in Swift is a single character String literal, addressed by the data type character. Take a look at the following example. It uses two Character constants −

import Cocoa let char1: Character = "A" let char2: Character = "B" println("Value of char1 \(char1)") println("Value of char2 \(char2)")

When the above code is compiled and executed, it produces the following result −

Value of char1 A
Value of char2 B

If you try to store more than one character in a Character type variable or constant, then Swift will not allow that. Try to type the following example in Swift Playground and you will get an error even before compilation.

import Cocoa // Following is wrong in Swift let char: Character = "AB" println("Value of char \(char)")

Empty Character Variables

---

It is not possible to create an empty Character variable or constant which will have an empty value. The following syntax is not possible −

import Cocoa // Following is wrong in Swift let char1: Character = "" var char2: Character = "" println("Value of char1 \(char1)") println("Value of char2 \(char2)")

Accessing Characters from Strings

---

As explained while discussing Swift's Strings, String represents a collection of Character values in a specified order. So we can access individual characters from the given String by iterating over that string with a for-in loop −

import Cocoa for ch in "Hello" { println(ch) }

When the above code is compiled and executed, it produces the following result −

H
e
l
l
o

Concatenating Strings with Characters

---

The following example demonstrates how a Swift's Character can be concatenated with Swift's String.

import Cocoa var varA:String = "Hello " let varB:Character = "G" varA.append( varB ) println("Value of varC = \(varA)")

When the above code is compiled and executed, it produces the following result −

Value of varC Hello G

14 - SWIFT ARRAYS

Swift arrays are used to store ordered lists of values of the same type. Swift puts strict checking which does not allow you to enter a wrong type in an array even by mistake.

If you assign a created array to a variable then its always mutable which means you can change it by adding, removing, or changing its items but if you assign an array to a constant then that array is immutable, and its size and contents cannot be changed.

Creating Arrays

---

You can create an empty array of a certain type using the following initializer syntax −

var someArray = [SomeType]()

Here is the syntax to create an array of a given size a* and initialize it with a value −

var someArray = [SomeType](count: NumbeOfElements, repeatedValue: InitialValue)

You can use the following statement to create an empty array of Int type having 3 elements and the initial value as zero −

var someInts = [Int](count: 3, repeatedValue: 0)

---

Following is one more example to create an array of three elements and assign three values to that array −

var someInts:[Int] = [10, 20, 30]

Accessing Arrays

---

You can retrieve a value from an array by using subscript syntax, passing the index of the value you want to retrieve within square brackets immediately after the name of the array as follows −

var someVar = someArray[index]

Here, the index starts from 0 which means the first element can be accessed using the index as 0, the second element can be accessed using the index as 1 and so on. The following example shows how to create, initialize, and access arrays −

import Cocoa var someInts = [Int](count: 3, repeatedValue: 10) var someVar = someInts[0] println( "Value of first element is \(someVar)" ) println( "Value of second element is \(someInts[1])" ) println( "Value of third element is \(someInts[2])" )

When the above code is compiled and executed, it produces the following result −

Value of first element is 10
Value of second element is 10
Value of third element is 10

Modifying Arrays

---

You can use append() method or addition assignment operator (+=) to add a new item at the end of an array. Take a look at the following example. Here, initially, we create an empty array and then add new elements into the same array −

import Cocoa var someInts = [Int]() someInts.append(20) someInts.append(30) someInts += [40] var someVar = someInts[0] println( "Value of first element is \(someVar)" ) println( "Value of second element is \(someInts[1])" ) println( "Value of third element is \(someInts[2])" )

When the above code is compiled and executed, it produces the following result −

Value of first element is 20
Value of second element is 30
Value of third element is 40

You can modify an existing element of an Array by assigning a new value at a given index as shown in the following example −

import Cocoa var someInts = [Int]() someInts.append(20) someInts.append(30) someInts += [40] // Modify last element someInts[2] = 50 var someVar = someInts[0] println( "Value of first element is \(someVar)" ) println( "Value of second element is \(someInts[1])" ) println( "Value of third element is \(someInts[2])" )

When the above code is compiled and executed, it produces the following result −

Value of first element is 20
Value of second element is 30
Value of third element is 50

Iterating Over an Array

---

You can use for-in loop to iterate over the entire set of values in an array as shown in the following example −

import Cocoa var someStrs = [String]() someStrs.append("Apple") someStrs.append("Amazon") someStrs += ["Google"] for item in someStrs { println(item) }

When the above code is compiled and executed, it produces the following result −

Apple
Amazon
Google

You can use enumerate() function which returns the index of an item along with its value as shown below in the following example −

import Cocoa var someStrs = [String]() someStrs.append("Apple") someStrs.append("Amazon") someStrs += ["Google"] for (index, item) in enumerate(someStrs) { println("Value at index = \(index) is \(item)") }

When the above code is compiled and executed, it produces the following result −

Value at index = 0 is Apple
Value at index = 1 is Amazon
Value at index = 2 is Google

Adding Two Arrays

---

You can use the addition operator (+) to add two arrays of the same type which will yield a new array with a combination of values from the two arrays as follows −

import Cocoa var intsA = [Int](count:2, repeatedValue: 2) var intsB = [Int](count:3, repeatedValue: 1) var intsC = intsA + intsB for item in intsC { println(item) }

When the above code is compiled and executed, it produces the following result −

2
2
1
1
1

The count Property

---

You can use the read-only count property of an array to find out the number of items in an array shown below −

import Cocoa var intsA = [Int](count:2, repeatedValue: 2) var intsB = [Int](count:3, repeatedValue: 1) var intsC = intsA + intsB println("Total items in intsA = \(intsA.count)") println("Total items in intsB = \(intsB.count)") println("Total items in intsC = \(intsC.count)")

When the above code is compiled and executed, it produces the following result −

Total items in intsA = 2
Total items in intsB = 3
Total items in intsC = 5

The empty Property

---

You can use the read-only empty property of an array to find out whether an array is empty or not as shown below −

import Cocoa var intsA = [Int](count:2, repeatedValue: 2) var intsB = [Int](count:3, repeatedValue: 1) var intsC = [Int]() println("intsA.isEmpty = \(intsA.isEmpty)") println("intsB.isEmpty = \(intsB.isEmpty)") println("intsC.isEmpty = \(intsC.isEmpty)")

When the above code is compiled and executed, it produces the following result −

intsA.isEmpty = false
intsB.isEmpty = false
intsC.isEmpty = true

15 - SWIFT DICTIONARIES

Swift dictionaries are used to store unordered lists of values of the same type. Swift puts strict checking which does not allow you to enter a wrong type in a dictionary even by mistake.

Swift dictionaries use unique identifier known as a key to store a value which later can be referenced and looked up through the same key. Unlike items in an array, items in a dictionary do not have a specified order. You can use a dictionary when you need to look up values based on their identifiers.

A dictionary key can be either an integer or a string without a restriction, but it should be unique within a dictionary.

If you assign a created dictionary to a variable, then it is always mutable which means you can change it by adding, removing, or changing its items. But if you assign a dictionary to a constant, then that dictionary is immutable, and its size and contents cannot be changed.

Creating Dictionary

---

You can create an empty dictionary of a certain type using the following initializer syntax −

var someDict = [KeyType: ValueType]()

You can use the following simple syntax to create an empty dictionary whose key will be of Int type and the associated values will be strings −

var someDict = [Int: String]()

Here is an example to create a dictionary from a set of given values −

var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"]

Accessing Dictionaries

---

You can retrieve a value from a dictionary by using subscript syntax, passing the key of the value you want to retrieve within square brackets immediately after the name of the dictionary as follows −

var someVar = someDict[key]

Let's check the following example to create, initialize, and access values from a dictionary −

import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var someVar = someDict[1] println( "Value of key = 1 is \(someVar)" ) println( "Value of key = 2 is \(someDict[2])" ) println( "Value of key = 3 is \(someDict[3])" )

When the above code is compiled and executed, it produces the following result −

Value of key = 1 is Optional("One") Value of key = 2 is Optional("Two") Value of key = 3 is Optional("Three")

Modifying Dictionaries

---

You can use updateValue(forKey:) method to add an existing value to a given key of the dictionary. This method returns an optional value of the dictionary's value type. Here is a simple example −

import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var oldVal = someDict.updateValue("New value of one", forKey: 1) var someVar = someDict[1] println( "Old value of key = 1 is \(oldVal)" ) println( "Value of key = 1 is \(someVar)" ) println( "Value of key = 2 is \(someDict[2])" ) println( "Value of key = 3 is \(someDict[3])" )

When the above code is compiled and executed, it produces the following result −

Old value of key = 1 is Optional("One")
Value of key = 1 is Optional("New value of one")
Value of key = 2 is Optional("Two")
Value of key = 3 is Optional("Three")

You can modify an existing element of a dictionary by assigning new value at a given key as shown in the following example −

import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var oldVal = someDict[1] someDict[1] = "New value of one" var someVar = someDict[1] println( "Old value of key = 1 is \(oldVal)" ) println( "Value of key = 1 is \(someVar)" ) println( "Value of key = 2 is \(someDict[2])" ) println( "Value of key = 3 is \(someDict[3])" )

When the above code is compiled and executed, it produces the following result −

Old value of key = 1 is Optional("One") Value of key = 1 is Optional("New value of one") Value of key = 2 is Optional("Two") Value of key = 3 is Optional("Three")

Remove Key-Value Pairs

---

You can use removeValueForKey() method to remove a key-value pair from a dictionary. This method removes the key-value pair if it exists and returns the removed value, or returns nil if no value existed. Here is a simple example −

import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var removedValue = someDict.removeValueForKey(2) println( "Value of key = 1 is \(someDict[1])" ) println( "Value of key = 2 is \(someDict[2])" ) println( "Value of key = 3 is \(someDict[3])" )

When the above code is compiled and executed, it produces the following result −

Value of key = 1 is Optional("One")
Value of key = 2 is nil
Value of key = 3 is Optional("Three")

You can also use subscript syntax to remove a key-value pair from a dictionary by assigning a value of nil for that key. Here is a simple example −

import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] someDict[2] = nil println( "Value of key = 1 is \(someDict[1])" ) println( "Value of key = 2 is \(someDict[2])" ) println( "Value of key = 3 is \(someDict[3])" )

When the above code is compiled and executed, it produces the following result −

Value of key = 1 is Optional("One")
Value of key = 2 is nil
Value of key = 3 is Optional("Three")

Iterating Over a Dictionary

---

You can use a for-in loop to iterate over the entire set of key-value pairs in a Dictionary as shown in the following example −

import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] for (key, value) in someDict { println("Dictionary key \(key) - Dictionary value \(value)") }

When the above code is compiled and executed, it produces the following result −

Dictionary key 2 - Dictionary value Two
Dictionary key 3 - Dictionary value Three
Dictionary key 1 - Dictionary value One

You can use enumerate() function which returns the index of the item along with its (key, value) pair as shown below in the example −

import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] for (key, value) in enumerate(someDict) { println("Dictionary key \(key) - Dictionary value \(value)") }

When the above code is compiled and executed, it produces the following result −

Dictionary key 0 - Dictionary value (2, Two)
Dictionary key 1 - Dictionary value (3, Three)
Dictionary key 2 - Dictionary value (1, One)

Convert to Arrays

---

You can extract a list of key-value pairs from a given dictionary to build separate arrays for both keys and values. Here is an example −

import Cocoa var someDict:[Int:String] = [1:"One", 2:"Two", 3:"Three"] let dictKeys = [Int](someDict.keys) let dictValues = [String](someDict.values) println("Print Dictionary Keys") for (key) in dictKeys { println("\(key)") } println("Print Dictionary Values") for (value) in dictValues { println("\(value)") }

When the above code is compiled and executed, it produces the following result −

Print Dictionary Keys
2
3
1
Print Dictionary Values
Two
Three
One

The count Property

---

You can use the read-only count property of a dictionary to find out the number of items in a dictionary as shown below −

import Cocoa var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var someDict2:[Int:String] = [4:"Four", 5:"Five"] println("Total items in someDict1 = \(someDict1.count)") println("Total items in someDict2 = \(someDict2.count)")

When the above code is compiled and executed, it produces the following result −

Total items in someDict1 = 3
Total items in someDict2 = 2

The empty Property

---

You can use read-only empty property of a dictionary to find out whether a dictionary is empty or not, as shown below −

import Cocoa var someDict1:[Int:String] = [1:"One", 2:"Two", 3:"Three"] var someDict2:[Int:String] = [4:"Four", 5:"Five"] var someDict3:[Int:String] = [Int:String]() println("someDict1 = \(someDict1.isEmpty)") println("someDict2 = \(someDict2.isEmpty)") println("someDict3 = \(someDict3.isEmpty)")

When the above code is compiled and executed, it produces the following result −

someDict1 = false
someDict2 = false
someDict3 = true

16 - SWIFT FUNCTIONS

A function is a set of statements organized together to perform a specific task. A Swift function can be as simple as a simple C function to as complex as an Objective C language function. It allows us to pass local and global parameter values inside the function calls.

• Function Declaration − It tells the compiler about a function's name, return type, and parameters.
• Function Definition − It provides the actual body of the function.

Swift functions contain parameter type and its return types.

Function Definition

---

In Swift, a function is defined by the "func" keyword. When a function is newly defined, it may take one or several values as input 'parameters' to the function and it will process the functions in the main body and pass back the values to the functions as output 'return types'.

Every function has a function name, which describes the task that the function performs. To use a function, you "call" that function with its name and pass input values (known as arguments) that match the types of the function's parameters. Function parameters are also called as 'tuples'.

A function's arguments must always be provided in the same order as the function's parameter list and the return values are followed by →.

Syntax

---

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

Take a look at the following code. The student’s name is declared as string datatype declared inside the function 'student' and when the function is called, it will return student’s name.

unc student(name: String) -> String { return name } println(student("First Program")) println(student("About Functions"))

When we run the above program using playground, we get the following result −

First Program
About Functions

Calling a Function

---

Let us suppose we defined a function called 'display' to Consider for example to display the numbers a function with function name 'display' is initialized first with argument 'no1' which holds integer data type. Then the argument 'no1' is assigned to argument 'a' which hereafter will point to the same data type integer. Now the argument 'a' is returned to the function. Here display() function will hold the integer value and return the integer values when each and every time the function is invoked.

func display(no1: Int) -> Int { let a = no1 return a } println(display(100)) println(display(200))

When we run above program using playground, we get the following result −

100
200

Parameters and Return Values

---

Swift provides flexible function parameters and its return values from simple to complex values. Similar to that of C and Objective C, functions in Swift may also take several forms.

Functions with Parameters

---

A function is accessed by passing its parameter values to the body of the function. We can pass single to multiple parameter values as tuples inside the function.

func mult(no1: Int, no2: Int) -> Int { return no1*no2 } println(mult(2,20)) println(mult(3,15)) println(mult(4,30))

When we run above program using playground, we get the following result −

40
45
120

Functions without Parameters

---

We may also have functions without any parameters.

Syntax

func funcname() -> datatype { return datatype }

Following is an example having a function without a parameter −

func votersname() -> String { return "Alice" } println(votersname())

When we run the above program using playground, we get the following result −

Alice

Functions with Return Values

---

Functions are also used to return string, integer, and float data type values as return types. To find out the largest and smallest number in a given array function 'ls' is declared with large and small integer datatypes.

An array is initialized to hold integer values. Then the array is processed and each and every value in the array is read and compared for its previous value. When the value is lesser than the previous one it is stored in 'small' argument, otherwise it is stored in 'large' argument and the values are returned by calling the function.

func ls(array: [Int]) -> (large: Int, small: Int) { var lar = array[0] var sma = array[0] for i in array[1..<array.count] { if i < sma { sma = i }else if i > lar { lar = i } } return (lar, sma) } let num = ls([40,12,-5,78,98]) println("Largest number is: \(num.large) and smallest number is: \(num.small)")

When we run the above program using playground, we get the following result −

Largest number is: 98 and smallest number is: -5

Functions Without Return Values

---

Some functions may have arguments declared inside the function without any return values. The following program declares a and b as arguments to the sum() function. inside the function itself the values for arguments a and b are passed by invoking the function call sum() and its values are printed thereby eliminating return values.

func sum(a: Int, b: Int) { let a = a + b let b = a - b println(a, b) } sum(20, 10) sum(40,10) sum(24,6)

When we run the above program using playground, we get the following result −

(30, 20)
(50, 40)
(30, 24)

Functions with Optional Return Types

---

Swift introduces 'optional' feature to get rid of problems by introducing a safety measure. Consider for example we are declaring function values return type as integer but what will happen when the function returns a string value or either a nil value. In that case compiler will return an error value. 'optional' are introduced to get rid of these problems.

Optional functions will take two forms 'value' and a 'nil'. We will mention 'Optionals' with the key reserved character '?' to check whether the tuple is returning a value or a nil value.

func minMax(array: [Int]) -> (min: Int, max: Int)? { if array.isEmpty { return nil } var currentMin = array[0] var currentMax = array[0] for value in array[1..<array.count] { if value < currentMin { currentMin = value }else if value > currentMax { currentMax = value } } return (currentMin, currentMax) } if let bounds = minMax([8, -6, 2, 109, 3, 71]) { println("min is \(bounds.min) and max is \(bounds.max)") }

When we run the above program using playground, we get the following result −

min is -6 and max is 109

'Optionals' are used to check 'nil' or garbage values thereby consuming lot of time in debugging and make the code efficient and readable for the user.

Functions Local Vs External Parameter Names

---

Local Parameter Names

Local parameter names are accessed inside the function alone.

func sample(number: Int) { println(number) }

Here, the func sample argument number is declared as internal variable since it is accessed internally by the function sample(). Here the 'number' is declared as local variable but the reference to the variable is made outside the function with the following statement −

func sample(number: Int) { println(number) } sample(1) sample(2) sample(3)

When we run the above program using playground, we get the following result −

1
2
3

External Parameter Names

External parameter names allow us to name a function parameters to make their purpose more clear. For example below you can name two function parameters and then call that function as follows −

func pow(firstArg a: Int, secondArg b: Int) -> Int { var res = a for _ in 1..<b { res = res * a } println(res) return res } pow(firstArg:5, secondArg:3)

When we run the above program using playground, we get the following result −

125

Variadic Parameters

---

When we want to define function with multiple number of arguments, then we can declare the members as 'variadic' parameters. Parameters can be specified as variadic by (···) after the parameter name.

func vari<N>(members: N...) { for i in members { println(i) } } vari(4,3,5) vari(4.5, 3.1, 5.6) vari("Swift", "Enumerations", "Closures")

When we run the above program using playground, we get the following result −

4
3
5
4.5
3.1
5.6
Swift
Enumerations
Closures

Constant, Variable and I/O Parameters

---

Functions by default consider the parameters as 'constant', whereas the user can declare the arguments to the functions as variables also. We already discussed that 'let' keyword is used to declare constant parameters and variable parameters is defined with 'var' keyword.

I/O parameters in Swift provide functionality to retain the parameter values even though its values are modified after the function call. At the beginning of the function parameter definition, 'inout' keyword is declared to retain the member values.

It derives the keyword 'inout' since its values are passed 'in' to the function and its values are accessed and modified by its function body and it is returned back 'out' of the function to modify the original argument.

Variables are only passed as an argument for in-out parameter since its values alone are modified inside and outside the function. Hence no need to declare strings and literals as in-out parameters. '&' before a variable name refers that we are passing the argument to the in-out parameter.

func temp(inout a1: Int, inout b1: Int) { let t = a1 a1 = b1 b1 = t } var no = 2 var co = 10 temp(&no, &co) println("Swapped values are \(no), \(co)")

When we run the above program using playground, we get the following result −

Swapped values are 10, 2

Function Types & its Usage

---

Each and every function follows the specific function by considering the input parameters and outputs the desired result.

func inputs(no1: Int, no2: Int) -> Int { return no1/no2 }

Following is an example −

func inputs(no1: Int, no2: Int) -> Int { return no1/no2 } println(inputs(20,10)) println(inputs(36,6))

When we run the above program using playground, we get the following result −

2
6

Here the function is initialized with two arguments no1 and no2 as integer data types and its return type is also declared as 'int'.

Here the function is declared as string datatype. Functions may also have void data types and such functions won't return anything.

Here the function is declared as string datatype.

Functions may also have void data types and such functions won't return anything.

func inputstr() { println("Swift Functions") println("Types and its Usage") } inputstr()

When we run the above program using playground, we get the following result −

Swift Functions
Types and its Usage

The above function is declared as a void function with no arguments and no return values.

Using Function Types

---

Functions are first passed with integer, float or string type arguments and then it is passed as constants or variables to the function as mentioned below.

var addition: (Int, Int) -> Int = sum

Here sum is a function name having 'a' and 'b' integer variables which is now declared as a variable to the function name addition. Hereafter both addition and sum function both have same number of arguments declared as integer datatype and also return integer values as references.

func sum(a: Int, b: Int) -> Int { return a + b } var addition: (Int, Int) -> Int = sum println("Result: \(addition(40, 89))")

When we run the above program using playground, we get the following result −

Result: 129

Function Types as Parameter Types & Return Types

---

We can also pass the function itself as parameter types to another function.

func sum(a: Int, b: Int) -> Int { return a + b } var addition: (Int, Int) -> Int = sum println("Result: \(addition(40, 89))") func another(addition: (Int, Int) -> Int, a: Int, b: Int) { println("Result: \(addition(a, b))") } another(sum, 10, 20)

When we run the above program using playground, we get the following result −

Result: 129
Result: 30

Nested Functions

---

A nested function provides the facility to call the outer function by invoking the inside function.

func calcDecrement(forDecrement total: Int) -> () -> Int { var overallDecrement = 0 func decrementer() -> Int { overallDecrement -= total return overallDecrement } return decrementer } let decrem = calcDecrement(forDecrement: 30) println(decrem())

When we run the above program using playground, we get the following result −

-30

17 - SWIFT CLOSURES

Closures in Swift are similar to that of self-contained functions organized as blocks and called anywhere like C and Objective C languages. Constants and variable references defined inside the functions are captured and stored in closures. Functions are considered as special cases of closures and it takes the following three forms −

Global Functions	Nested Functions	Closure Expressions
Have a name. Do not capture any values	Have a name. Capture values from enclosing function	Unnamed Closures capture values from the adjacent blocks

Closure expressions in Swift language follow crisp, optimization and lightweight syntax styles which includes.

• Inferring parameter and return value types from context.
• Implicit returns from single-expression closures.
• Shorthand argument names and
• Trailing closure syntax

Syntax

Following is a generic syntax to define closure which accepts parameters and returns a data type −

{(parameters) -> return type in statements }

Following is a simple example −

let studname = { println("Welcome to Swift Closures") } studname()

When we run the above program using playground, we get the following result −

Welcome to Swift Closures

The following closure accepts two parameters and returns a Bool value −

{(Int, Int) -> Bool in Statement1 Statement 2 --- Statement n }

Following is a simple example −

let divide = {(val1: Int, val2: Int) -> Int in return val1 / val2 } let result = divide(200, 20) println (result)

When we run the above program using playground, we get the following result −

10

Expressions in Closures

---

Nested functions provide a convenient way of naming and defining blocks of code. Instead of representing the whole function declaration and name constructs are used to denote shorter functions. Representing the function in a clear brief statement with focused syntax is achieved through closure expressions.

Ascending Order Program

Sorting a string is achieved by the Swifts key reserved function "sorted" which is already available in the standard library. The function will sort the given strings in the ascending order and returns the elements in a new array with same size and data type mentioned in the old array. The old array remains the same.

Two arguments are represented inside the sorted function −

Values of Known type represented as arrays.

Array contents (Int, Int) and returns a Boolean value (Bool) if the array is sorted properly it will return true value otherwise it will return false.

A normal function with input string is written and passed to the sorted function to get the strings sorted to new array which is shown below −

func ascend(s1: String, s2: String) -> Bool { return s1 > s2 } let stringcmp = ascend("swift", "great") println (stringcmp)

When we run the above program using playground, we get the following result −

true

The initial array to be sorted for icecream is given as "Swift" and "great". Function to sort the array is declared as string datatype and its return type is mentioned as Boolean. Both the strings are compared and sorted in ascending order and stored in a new array. If the sorting is performed successful the function will return a true value else it will return false.

Closure expression syntax uses −

• constant parameters,
• variable parameters, and
• inout parameters.

Closure expression did not support default values. Variadic parameters and Tuples can also be used as parameter types and return types.

let sum = {(no1: Int, no2: Int) -> Int in return no1 + no2 } let digits = sum(10, 20) println(digits)

When we run the above program using playground, we get the following result −

30

The parameters and return type declarations mentioned in the function statement can also be represented by the inline closure expression function with 'in' keyword. Once declaring parameter and return types 'in' keyword is used to denote that the body of the closure.

Single Expression Implicit Returns

---

Here, the function type of the sorted function's second argument makes it clear that a Bool value must be returned by the closure. Because the closure's body contains a single expression (s1 > s2) that returns a Bool value, there is no ambiguity, and the return keyword can be omitted.

To return a Single expression statement in expression closures 'return' keyword is omitted in its declaration part.

let count = [5, 10, -6, 75, 20] var descending = sorted(count, { n1, n2 in n1 > n2 }) var ascending = sorted(count, { n1, n2 in n1 < n2 }) println(descending) println(ascending)

When we run the above program using playground, we get the following result −

[75, 20, 10, 5, -6]
[-6, 5, 10, 20, 75]

The statement itself clearly defines that when string1 is greater than string 2 return true otherwise false hence return statement is omitted here.

Known Type Closures

---

Consider the addition of two numbers. We know that addition will return the integer datatype. Hence known type closures are declared as −

let sub = {(no1: Int, no2: Int) -> Int in return no1 - no2 } let digits = sub(10, 20) println(digits)

When we run the above program using playground, we get the following result −

-10

Declaring Shorthand Argument Names as Closures

---

Swift automatically provides shorthand argument names to inline closures, which can be used to refer to the values of the closure's arguments by the names $0, $1, $2, and so on.

var shorthand: (String, String) -> String shorthand = { $1 } println(shorthand("100", "200"))

Here, $0 and $1 refer to the closure's first and second String arguments.

When we run the above program using playground, we get the following result −

200

Swift facilitates the user to represent Inline closures as shorthand argument names by representing $0, $1, $2 --- $n.

Closures argument list is omitted in definition section when we represent shorthand argument names inside closure expressions. Based on the function type the shorthand argument names will be derived. Since the shorthand argument is defined in expression body the 'in' keyword is omitted.

Closures as Operator Functions

---

Swift provides an easy way to access the members by just providing operator functions as closures. In the previous examples keyword 'Bool' is used to return either 'true' when the strings are equal otherwise it returns 'false'.

The expression is made even simpler by operator function in closure as −

let numb = [98, -20, -30, 42, 18, 35] var sortedNumbers = numb.sorted({ (left: Int, right: Int) -> Bool in return left < right }) let asc = numb.sorted(<) println(asc)

When we run the above program using playground, we get the following result −

[-30, -20, 18, 35, 42, 98]

Closures as Trailers

---

Passing the function's final argument to a closure expression is declared with the help of 'Trailing Closures'. It is written outside the function () with {}. Its usage is needed when it is not possible to write the function inline on a single line.

reversed = sorted(names) { $0 > $1}

where {$0 > $1} are represented as trailing closures declared outside (names).

import Foundation var letters = ["North", "East", "West", "South"] let twoletters = letters.map({ (state: String) -> String in return state.substringToIndex(advance(state.startIndex, 2)).uppercaseString }) let stletters = letters.map() { $0.substringToIndex(advance($0.startIndex, 2)).uppercaseString } println(stletters)

When we run the above program using playground, we get the following result −

[NO, EA, WE, SO]

Capturing Values and Reference Types

---

In Swift, capturing constants and variables values is done with the help of closures. It further refers and modify the values for those constants and variables inside the closure body even though the variables no longer exists.

Capturing constant and variable values is achieved by using nested function by writing function with in the body of other function.

A nested function captures −

• Outer function arguments.
• Capture constants and variables defined within the Outer function.

In Swift, when a constant or a variable is declared inside a function, reference to that variables are also automatically created by the closure. It also provides the facility to refer more than two variables as the same closure as follows −

let decrem = calcDecrement(forDecrement: 18) decrem()

Here oneDecrement and Decrement variables will both point the same memory block as closure reference.

func calcDecrement(forDecrement total: Int) -> () -> Int { var overallDecrement = 100 func decrementer() -> Int { overallDecrement -= total println(overallDecrement) return overallDecrement } return decrementer } let decrem = calcDecrement(forDecrement: 18) decrem() decrem() decrem()

When we run the above program using playground, we get the following result −

82
64
46

When each and every time the outer function calcDecrement is called it invokes the decrementer() function and decrements the value by 18 and returns the result with the help of outer function calcDecrement. Here calcDecrement acts as a closure.

Even though the function decrementer() does not have any arguments closure by default refers to variables 'overallDecrement' and 'total' by capturing its existing values. The copy of the values for the specified variables are stored with the new decrementer() function. Swift handles memory management functions by allocating and deallocating memory spaces when the variables are not in use.

18 - SWIFT ENUMERATIONS

An enumeration is a user-defined data type which consists of set of related values. Keyword enum is used to defined enumerated data type.

Enumeration Functionality

---

Enumeration in swift also resembles the structure of C and Objective C.

• It is declared in a class and its values are accessed through the instance of that class.
• Initial member value is defined using enum intializers.
• Its functionality is also extended by ensuring standard protocol functionality.

Syntax

Enumerations are introduced with the enum keyword and place their entire definition within a pair of braces −

enum enumname { // enumeration values are described here }

For example, you can define an enumeration for days of week as follows −

enum DaysofaWeek { case Sunday case Monday --- case Saturday }

Example

enum names { case Swift case Closures } var lang = names.Closures lang = .Closures switch lang { case .Swift: println("Welcome to Swift") case .Closures: println("Welcome to Closures") default: println("Introduction") }

When we run the above program using playground, we get the following result −

Welcome to Closures

Swift enumeration does not assign its members default value like C and Objective C. Instead the members are explicitly defined by their enumeration names. Enumeration name should start with a capital letter (Ex: enum DaysofaWeek).

var weekDay = DaysofaWeek.Sunday

Here the Enumeration name 'DaysofaWeek' is assigned to a variable weekday.Sunday. It informs the compiler that the datatype belongs to Sunday will be assigned to subsequent enum members of that particular class. Once the enum member datatype is defined, the members can be accessed by passing values and further computations.

Enumeration with Switch Statement

---

Swift 'Switch' statement also follows the multi way selection. Only one variable is accessed at a particular time based on the specified condition. Default case in switch statement is used to trap unspecified cases.

enum Climate { case India case America case Africa case Australia } var season = Climate.America season = .America switch season { case .India: println("Climate is Hot") case .America: println("Climate is Cold") case .Africa: println("Climate is Moderate") case .Australia: println("Climate is Rainy") default: println("Climate is not predictable") }

When we run the above program using playground, we get the following result −

Climte is Cold

The program first defines Climate as the enumeration name. Then its members like 'India', 'America', 'Africa' and 'Australia' are declared belonging to class 'Climate'. Now the member America is assigned to a Season Variable. Further, Switch case will see the values corresponding to .America and it will branch to that particular statement. The output will be displayed as "Climate is Cold". Likewise all the members can be accessed through switch statements. When the condition is not satisfied it prints by default 'Climate is not predictable'.

Enumeration can be further classified in to associated values and raw values.

Difference between Associated Values and Raw Values

---

Associated Values	Raw Values
Different Datatypes	Same Datatypes
Ex: enum {10,0.8,"Hello"}	Ex: enum {10,35,50}
Values are created based on constant or variable	Prepopulated Values
Varies when declared each time	Value for member is same

Enum with Associated Values

---

enum Student { case Name(String) case Mark(Int,Int,Int) } var studDetails = Student.Name("Swift") var studMarks = Student.Mark(98,97,95) switch studMarks { case .Name(let studName): println("Student name is: \(studName).") case .Mark(let Mark1, let Mark2, let Mark3): println("Student Marks are: \(Mark1),\(Mark2),\(Mark3).") default: println("Nothing") }

When we run the above program using playground, we get the following result −

Swift
98
97
95

Consider for example to access the students name and marks secured in three subjects enumeration name is declared as student and the members present in enum class are name which belongs to string datatype, marks are represented as mark1, mark2 and mark3 of datatype Integer. To access either the student name or marks they have scored.

var studDetails = Student.Name("Swift") var studMarks = Student.Mark(98,97,95)

Now, the switch case will print student name if that case block is executed otherwise it will print the marks secured by the student. If both the conditions fail, the default block will be executed.

Enum with Raw Values

---

Raw values can be strings, characters, or any of the integer or floating-point number types. Each raw value must be unique within its enumeration declaration. When integers are used for raw values, they auto-increment if no value is specified for some of the enumeration members.

enum Month: Int { case January = 1, February, March, April, May, June, July, August, September, October, November, December } let yearMonth = Month.May.rawValue println("Value of the Month is: \(yearMonth).")

When we run the above program using playground, we get the following result −

Value of the Month is: 5.

19 - SWIFT STRUCTURES

Swift provides a flexible building block of making use of constructs as Structures. By making use of these structures once can define constructs methods and properties.

Unlike C and Objective C

---

• Structure need not require implementation files and interface.
• Structure allows us to create a single file and to extend its interface automatically to other blocks.

In Structure the variable values are copied and passed in subsequent codes by returning a copy of the old values so that the values cannot be altered.

Syntax

Structures are defined with a 'Struct' Keyword. struct nameStruct { Definition 1 Definition 2 --- Definition N }

Definition of a Structure

---

Consider for example, suppose we have to access students record containing marks of three subjects and to find out the total of three subjects. Here markStruct is used to initialize a structure with three marks as datatype 'Int'.

struct MarkStruct { var mark1: Int var mark2: Int var mark3: Int }

Accessing the Structure and its Properties

---

The members of the structure are accessed by its structure name. The instances of the structure are initialized by the 'let' keyword.

struct studentMarks { var mark1 = 100 var mark2 = 200 var mark3 = 300 } let marks = studentMarks() println("Mark1 is \(marks.mark1)") println("Mark2 is \(marks.mark2)") println("Mark3 is \(marks.mark3)")

When we run the above program using playground, we get the following result −

Mark1 is 100
Mark2 is 200
Mark3 is 300

Students marks are accessed by the structure name 'studentMarks'. The structure members are initialized as mark1, mark2, mark3 with integer type values. Then the structure studentMarks() is passed to the 'marks' with 'let' keyword. Hereafter 'marks' will contain the structure member values. Now the values are printed by accessing the structure member values by '.' with its initialized names.

struct MarksStruct { var mark: Int init(mark: Int) { self.mark = mark } } var aStruct = MarksStruct(mark: 98) var bStruct = aStruct // aStruct and bStruct are two structs with the same value! bStruct.mark = 97 println(aStruct.mark) // 98 println(bStruct.mark) // 97

When we run the above program using playground, we get the following result −

98
97

Best Usage Practices of Structures

---

Swift language provides the functionality to define structures as custom data types for building the function blocks. The instances of structure are passed by its value to the defined blocks for further manipulations.

Need for having structures

• To encapsulate simple data values.
• To copy the encapsulated data and its associated properties by 'values' rather than by 'references'.
• Structure to 'Copy' and 'Reference'.

Structures in swift pass their members with their values rather than by its references.

struct markStruct { var mark1: Int var mark2: Int var mark3: Int init(mark1: Int, mark2: Int, mark3: Int) { self.mark1 = mark1 self.mark2 = mark2 self.mark3 = mark3 } } var marks = markStruct(mark1: 98, mark2: 96, mark3:100) println(marks.mark1) println(marks.mark2) println(marks.mark3)

When we run the above program using playground, we get the following result −

98
96
100

Another Example

---

struct markStruct { var mark1: Int var mark2: Int var mark3: Int init(mark1: Int, mark2: Int, mark3: Int){ self.mark1 = mark1 self.mark2 = mark2 self.mark3 = mark3 } } var fail = markStruct(mark1: 34, mark2: 42, mark3: 13) println(fail.mark1) println(fail.mark2) println(fail.mark3)

When we run the above program using playground, we get the following result −

34
42
13

The structure 'markStruct' is defined first with its members mark1, mark2 and mark3. Now the variables of member classes are initialized to hold integer values. Then the copy of the structure members are created with 'self' Keyword. Once the copy of the structure members are created structure block with its parameter marks are passed to 'marks' variable which will now hold the students marks. Then the marks are printed as 98, 96, 100. Next step for the same structure members another instance named 'fail' is used to point the same structure members with different marks. Then the results are now printed as 34, 42, 13. This clearly explains that structures will have a copy of the member variables then pass the members to their upcoming function blocks.

20 - SWIFT CLASSES

Classes in Swift are building blocks of flexible constructs. Similar to constants, variables and functions the user can define class properties and methods. Swift provides us the functionality that while declaring classes the users need not create interfaces or implementation files. Swift allows us to create classes as a single file and the external interfaces will be created by default once the classes are initialized.

Benefits of having Classes

---

• Inheritance acquires the properties of one class to another class
• Type casting enables the user to check class type at run time
• Deinitializers take care of releasing memory resources
• Reference counting allows the class instance to have more than one reference

Common Characteristics of Classes and structures

---

• Properties are defined to store values
• Subscripts are defined for providing access to values
• Methods are initialized to improve functionality
• Initial state are defined by initializers
• Functionality are expanded beyond default values
• Confirming protocol functionality standards

Syntax

Class classname { Definition 1 Definition 2 --- Definition N }

Class Definition

---

class student { var studname: String var mark: Int var mark2: Int }

The syntax for creating instances

let studrecord = student()

Example

class MarksStruct { var mark: Int init(mark: Int) { self.mark = mark } } class studentMarks { var mark = 300 } let marks = studentMarks() println("Mark is \(marks.mark)")

When we run the above program using playground, we get the following result −

Mark is 300

Accessing Class Properties as Reference Types

---

Class properties can be accessed by the '.' syntax. Property name is separated by a '.' after the instance name.

class MarksStruct { var mark: Int init(mark: Int) { self.mark = mark } } class studentMarks { var mark1 = 300 var mark2 = 400 var mark3 = 900 } let marks = studentMarks() println("Mark1 is \(marks.mark1)") println("Mark2 is \(marks.mark2)") println("Mark3 is \(marks.mark3)")

When we run the above program using playground, we get the following result −

Mark1 is 300
Mark2 is 400
Mark3 is 900

Class Identity Operators

---

Classes in Swift refers multiple constants and variables pointing to a single instance. To know about the constants and variables pointing to a particular class instance identity operators are used. Class instances are always passed by reference. In Classes NSString, NSArray, and NSDictionary instances are always assigned and passed around as a reference to an existing instance, rather than as a copy.

Identical to Operators	Not Identical to Operators
Operator used is (===)	Operator used is (!==)
Returns true when two constants or variables pointing to a same instance	Returns true when two constants or variables pointing to a different instance

class SampleClass: Equatable { let myProperty: String init(s: String) { myProperty = s } } func ==(lhs: SampleClass, rhs: SampleClass) -> Bool { return lhs.myProperty == rhs.myProperty } let spClass1 = SampleClass(s: "Hello") let spClass2 = SampleClass(s: "Hello") spClass1 === spClass2 // false println("\(spClass1)") spClass1 !== spClass2 // true println("\(spClass2)")

When we run the above program using playground, we get the following result −

main.SampleClass
main.SampleClass

21 - SWIFT PROPERTIES

Swift language provides properties for class, enumeration or structure to associate values. Properties can be further classified into Stored properties and Computed properties.

Difference between Stored Properties and Computed Properties.

Stored Property	Computed Property
Store constant and variable values as instance.	Calculate a value rather than storing the value.
Provided by classes and structures.	Provided by classes, enumerations and structures.

Both Stored and Computed properties are associated with instances type. When the properties are associated with its type values then it is defined as 'Type Properties'. Stored and computed properties are usually associated with instances of a particular type. However, properties can also be associated with the type itself. Such properties are known as type properties. Property observers are also used.

• To observe the value of the stored properties.
• To observe the property of inherited subclass derived from superclass.

Stored Properties

---

Swift introduces Stored Property concept to store the instances of constants and variables. Stored properties of constants are defined by the 'let' keyword and Stored properties of variables are defined by the 'var' keyword.

• During definition Stored property provides 'default value'.
• During Initialization the user can initialize and modify the initial values.

struct Number{ var digits: Int let pi = 3.1415 } var n = Number(digits: 12345) n.digits = 67 println("\(n.digits)") println("\(n.pi)")

When we run the above program using playground, we get the following result −

67
3.1415

Consider the following line in the above code −

let pi = 3.1415

Here, the variable pi is initialized as a stored property value with the instance pi = 3.1415. So, whenever the instance is referred it will hold the value 3.1415 alone.

Another method to have stored property is to have as constant structures. So the whole instance of the structures will be considered as 'Stored Properties of Constants'.

struct Number { var digits: Int let numbers = 3.1415 } var n = Number(digits: 12345) n.digits = 67 println("\(n.digits)") println("\(n.numbers)") n.numbers = 8.7

When we run the above program using playground, we get the following result −

error: cannot assign to 'numbers' in 'n'
n.numbers = 8.7

Instead of reinitializing the 'number' to 8.7 it will return an error message indicating that the 'number' is declared as constant.

Lazy Stored Property

---

Swift provides a flexible property called 'Lazy Stored Property' where it won't calculate the initial values when the variable is initialized for the first time. 'lazy' modifier is used before the variable declaration to have it as a lazy stored property.

Lazy Properties are used −

• To delay object creation.
• When the property is dependent on other parts of a class, that are not known yet.

class sample { lazy var no = number() // `var` declaration is required. } class number { var name = "Swift" } var firstsample = sample() println(firstsample.no.name)

When we run the above program using playground, we get the following result −

Swift

Instance Variables

---

In Objective C, Stored properties also have instance variables for back up purposes to store the values declared in stored property.

Swift integrates both these concepts into a single 'stored property' declaration. Instead of having a corresponding instance variable and back up value 'stored property' contains all integrated information defined in a single location about the variables property by variable name, data type and memory management functionalities.

Computed Properties

---

Rather than storing the values computed properties provide a getter and an optional setter to retrieve and set other properties and values indirectly.

class sample { var no1 = 0.0, no2 = 0.0 var length = 300.0, breadth = 150.0 var middle: (Double, Double) { get{ return (length / 2, breadth / 2) }set(axis) { no1 = axis.0 - (length / 2) no2 = axis.1 - (breadth / 2) } } } var result = sample() println(result.middle) result.middle = (0.0, 10.0) println(result.no1) println(result.no2)

When we run the above program using playground, we get the following result −

(150.0, 75.0)
-150.0
-65.0

When a computed property left the new value as undefined, the default value will be set for that particular variable.

Computed Properties as Read-Only Properties

A read-only property in computed property is defined as a property with getter but no setter. It is always used to return a value. The variables are further accessed through a '.' Syntax but cannot be set to another value.

class film { var head = "" var duration = 0.0 var metaInfo: [String:String] { return [ "head": self.head, "duration":"\(self.duration)" ] } } var movie = film() movie.head = "Swift Properties" movie.duration = 3.09 println(movie.metaInfo["head"]!) println(movie.metaInfo["duration"]!)

When we run the above program using playground, we get the following result −

Swift Properties
3.09

Computed Properties as Property Observers

---

In Swift to observe and respond to property values Property Observers are used. Each and every time when property values are set property observers are called. Except lazy stored properties we can add property observers to 'inherited' property by method 'overriding'.

Property Observers can be defined by either.

• Before Storing the value - willset.
• After Storing the new value - didset.
• When a property is set in an initializer willset and didset observers cannot be called.

class Samplepgm { var counter: Int = 0 { willSet(newTotal) { println("Total Counter is: \(newTotal)") } didSet { if counter > oldValue { println("Newly Added Counter \(counter - oldValue)") } } } } let NewCounter = Samplepgm() NewCounter.counter = 100 NewCounter.counter = 800

When we run the above program using playground, we get the following result −

Total Counter is: 100
Newly Added Counter 100
Total Counter is: 800
Newly Added Counter 700

Local and Global Variables

---

Local and global variable are declared for computing and observing the properties.

Local Variables	Global Variables
Variables that are defined within a function, method, or closure context.	Variables that are defined outside function, method, closure, or type context.
Used to store and retrieve values.	Used to store and retrieve values.
Stored properties is used to get and set the values.	Stored properties is used to get and set the values.
Computed properties are also used.	Computed properties are also used.

Type Properties

---

Properties are defined in the Type definition section with curly braces {} and scope of the variables are also defined previously. For defining type properties for value types 'static' keyword is used and for class types 'class' keyword is used.

Syntax

struct Structname { static var storedTypeProperty = " " static var computedTypeProperty: Int { // return an Int value here } } enum Enumname { static var storedTypeProperty = " " static var computedTypeProperty: Int { // return an Int value here } } class Classname { class var computedTypeProperty: Int { // return an Int value here } }

Querying and Setting Properties

---

Just like instance properties Type properties are queried and set with '.' Syntax just on the type alone instead of pointing to the instance.

struct StudMarks { static let markCount = 97 static var totalCount = 0 var InternalMarks: Int = 0 { didSet { if InternalMarks > StudMarks.markCount { InternalMarks = StudMarks.markCount } if InternalMarks > StudMarks.totalCount { StudMarks.totalCount = InternalMarks } } } } var stud1Mark1 = StudMarks() var stud1Mark2 = StudMarks() stud1Mark1.InternalMarks = 98 println(stud1Mark1.InternalMarks) stud1Mark2.InternalMarks = 87 println(stud1Mark2.InternalMarks)

When we run the above program using playground, we get the following result −

97
87

22 - SWIFT METHODS

In Swift language Functions associated with particular types are referred to as Methods. In Objective C Classes are used to define methods, whereas Swift language provides the user flexibility to have methods for Classes, Structures and Enumerations.

Instance Methods

---

In Swift language, Classes, Structures and Enumeration instances are accessed through the instance methods.

Instance methods provide functionality.

• To access and modify instance properties.
• functionality related to the instance's need.

Instance method can be written inside the {} curly braces. It has implicit access to methods and properties of the type instance. When a specific instance of the type is called it will get access to that particular instance.

Syntax

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

Example

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 } func tot(c: Int) -> Int { return res - c } func result() { println("Result is: \(tot(20))") println("Result is: \(tot(50))") } } let pri = calculations(a: 600, b: 300) pri.result()

When we run the above program using playground, we get the following result −

Result is: 880
Result is: 850

Class Calculations defines two instance methods −

• init() is defined to add two numbers a and b and store it in result 'res'
• tot() is used to subtract the 'res' from passing 'c' value

Finally, to print the calculations methods with values for a and b is called. Instance methods are accessed with '.' dot syntax

Local and External Parameter Names

---

Swift Functions describe both local and global declarations for their variables. Similarly, Swift Methods naming conventions also resembles as that of Objective C. But the characteristics of local and global parameter name declarations are different for functions and methods. The first parameter in swift are referred by preposition names as 'with', 'for' and 'by' for easy to access naming conventions.

Swift provides the flexibility in methods by declaring first parameter name as local parameter names and the remaining parameter names to be of global parameter names. Here 'no1' is declared by swift methods as local parameter names. 'no2' is used for global declarations and accessed through out the program.

class division { var count: Int = 0 func incrementBy(no1: Int, no2: Int) { count = no1 / no2 println(count) } } let counter = division() counter.incrementBy(1800, no2: 3) counter.incrementBy(1600, no2: 5) counter.incrementBy(11000, no2: 3)

When we run the above program using playground, we get the following result −

600
320
3666

External Parameter Name with # and _ Symbol

---

Even though Swift methods provide first parameter names for local declarations, the user has the provision to modify the parameter names from local to global declarations. This can be done by prefixing '#' symbol with the first parameter name. By doing so, the first parameter can be accessed globally throughout the modules.

When the user needs to access the subsequent parameter names with an external name, the methods name is overridden with the help of '_' symbol.

class multiplication { var count: Int = 0 func incrementBy(#no1: Int, no2: Int) { count = no1 * no2 println(count) } } let counter = multiplication() counter.incrementBy(no1: 800, no2: 3) counter.incrementBy(no1: 100, no2: 5) counter.incrementBy(no1: 15000, no2: 3)

When we run the above program using playground, we get the following result −

2400
500
45000

Self property in Methods

---

Methods have an implicit property known as 'self' for all its defined type instances. 'Self' property is used to refer the current instances for its defined methods.

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 println("Inside Self Block: \(res)") } func tot(c: Int) -> Int { return res - c } func result() { println("Result is: \(tot(20))") println("Result is: \(tot(50))") } } let pri = calculations(a: 600, b: 300) let sum = calculations(a: 1200, b: 300) pri.result() sum.result()

When we run the above program using playground, we get the following result −

Inside Self Block: 900
Inside Self Block: 1500
Result is: 880
Result is: 850
Result is: 1480
Result is: 1450

Modifying Value Types from Instance Methods

---

In Swift language structures and enumerations belong to value types which cannot be altered by its instance methods. However, swift language provides flexibility to modify the value types by 'mutating' behavior. Mutate will make any changes in the instance methods and will return back to the original form after the execution of the method. Also, by the 'self' property new instance is created for its implicit function and will replace the existing method after its execution

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

When we run the above program using playground, we get the following result −

9
15
270
450
81000
135000

Self Property for Mutating Method

---

Mutating methods combined with 'self' property assigns a new instance to the defined method.

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 println(length) println(breadth) } } var val = area(length: 3, breadth: 5) val.scaleBy(13)

When we run the above program using playground, we get the following result −

39
65

Type Methods

---

When a particular instance of a method is called, it is called as an Instance method; and when the method calls a particular type of a method, it is called as 'Type Methods'. Type methods for 'classes' are defined by the 'func' keyword and structures and enumerations type methods are defined with the 'static' keyword before the 'func' keyword.

Type methods are called and accessed by '.' syntax where instead of calling a particular instance the whole method is invoked.

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) println(no) println(num)

When we run the above program using playground, we get the following result −

35
5

23 - SWIFT SUBSCRIPTS

Accessing the element members of a collection, sequence and a list in Classes, Structures and Enumerations are carried out with the help of subscripts. These subscripts are used to store and retrieve the values with the help of index. Array elements are accessed with the help of someArray[index] and its subsequent member elements in a Dictionary instance can be accessed as someDicitonary[key].

For a single type, subscripts can range from single to multiple declarations. We can use the appropriate subscript to overload the type of index value passed to the subscript. Subscripts also ranges from single dimension to multiple dimension according to the users requirements for their input data type declarations.

Subscript Declaration Syntax and its Usage

---

Let's have a recap to the computed properties. Subscripts too follow the same syntax as that of computed properties. For querying type instances, subscripts are written inside a square bracket followed with the instance name. Subscript syntax follows the same syntax structure as that of 'instance method' and 'computed property' syntax. 'subscript' keyword is used for defining subscripts and the user can specify single or multiple parameters with their return types. Subscripts can have read-write or read-only properties and the instances are stored and retrieved with the help of 'getter' and 'setter' properties as that of computed properties.

Syntax

subscript(index: Int) -> Int { get { // used for subscript value declarations } set(newValue) { // definitions are written here } }

Example 1

struct subexample { let decrementer: Int subscript(index: Int) -> Int { return decrementer / index } } let division = subexample(decrementer: 100) println("The number is divisible by \(division[9]) times") println("The number is divisible by \(division[2]) times") println("The number is divisible by \(division[3]) times") println("The number is divisible by \(division[5]) times") println("The number is divisible by \(division[7]) times")

When we run the above program using playground, we get the following result −

The number is divisible by 11 times
The number is divisible by 50 times
The number is divisible by 33 times
The number is divisible by 20 times
The number is divisible by 14 times

Example 2

class daysofaweek { private var days = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "saturday"] subscript(index: Int) -> String { get { return days[index] } set(newValue) { self.days[index] = newValue } } } var p = daysofaweek() println(p[0]) println(p[1]) println(p[2]) println(p[3])

When we run the above program using playground, we get the following result −

Sunday
Monday
Tuesday
Wednesday

Options in Subscript

---

Subscripts takes single to multiple input parameters and these input parameters also belong to any datatype. They can also use variable and variadic parameters. Subscripts cannot provide default parameter values or use any in-out parameters.

Defining multiple subscripts are termed as 'subscript overloading' where a class or structure can provide multiple subscript definitions as required. These multiple subscripts are inferred based on the types of values that are declared within the subscript braces.

struct Matrix { let rows: Int, columns: Int var print: [Double] init(rows: Int, columns: Int) { self.rows = rows self.columns = columns print = Array(count: rows * columns, repeatedValue: 0.0) } subscript(row: Int, column: Int) -> Double { get { return print[(row * columns) + column] } set { print[(row * columns) + column] = newValue } } } var mat = Matrix(rows: 3, columns: 3) mat[0,0] = 1.0 mat[0,1] = 2.0 mat[1,0] = 3.0 mat[1,1] = 5.0 println("\(mat[0,0])") println("\(mat[0,1])") println("\(mat[1,0])") println("\(mat[1,1])")

When we run the above program using playground, we get the following result −

1.0
2.0
3.0
5.0

Swift subscript supports single parameter to multiple parameter declarations for appropriate data types. The program declares 'Matrix' structure as a 2 * 2 dimensional array matrix to store 'Double' data types. The Matrix parameter is inputted with Integer data types for declaring rows and columns.

New instance for the Matrix is created by passing row and column count to the initialize as shown below.

var mat = Matrix(rows: 3, columns: 3)

Matrix values can be defined by passing row and column values into the subscript, separated by a comma as shown below.

mat[0,0] = 1.0 mat[0,1] = 2.0 mat[1,0] = 3.0 mat[1,1] = 5.0

24 - SWIFT INHERITANCE

The ability to take than more form is defined as Inheritance. Generally a class can inherit methods, properties and functionalities from another class. Classes can be further categorized in to sub class and super class.

• Sub Class − when a class inherits properties, methods and functions from another class it is called as sub class
• Super Class − Class containing properties, methods and functions to inherit other classes from itself is called as a super class

Swift classes contain superclass which calls and access methods, properties, functions and overriding methods. Also, property observers are also used to add a property and modify the stored or computed property methods.

Base Class

---

A Class that does not inherit methods, properties or functions from another class is called as 'Base Class'.

class StudDetails { var stname: String! var mark1: Int! var mark2: Int! var mark3: Int! init(stname: String, mark1: Int, mark2: Int, mark3: Int) { self.stname = stname self.mark1 = mark1 self.mark2 = mark2 self.mark3 = mark3 } } let stname = "swift" let mark1 = 98 let mark2 = 89 let mark3 = 76 println(stname) println(mark1) println(mark2) println(mark3)

When we run the above program using playground, we get the following result −

swift
98
89
76

Class with classname StudDetails are defined as a base class here which is used to contain students name, and three subjects mark as mark1, mark2 and mark3. 'let' keyword is used to initialize the value for the base class and base class value is displayed in the playground with the help of 'println' function.

Subclass

---

The act of basing a new class on an existing class is defined as 'Subclass'. The subclass inherits the properties, methods and functions of its base class. To define a subclass ':' is used before the base class name.

class StudDetails { var mark1: Int; var mark2: Int; init(stm1:Int, results stm2:Int) { mark1 = stm1; mark2 = stm2; } func print() { println("Mark1:\(mark1), Mark2:\(mark2)") } } class display : StudDetails { init() { super.init(stm1: 93, results: 89) } } let marksobtained = display() marksobtained.print()

When we run the above program using playground, we get the following result −

Mark1:93, Mark2:89

Class 'StudDetails' is defined as super class where student marks are declared and the subclass 'display' is used to inherit the marks from its super class. Sub class defines students marks and calls the print() method to display the students mark.

Overriding

---

Accessing the super class instance, type methods, instance, type properties and subscripts subclass provides the concept of overriding. 'override' keyword is used to override the methods declared in the superclass.

Access to Super class Methods, Properties and Subscripts

'super' keyword is used as a prefix to access the methods, properties and subscripts declared in the super class.

Overriding	Access to methods, properties and subscripts
Methods	super.somemethod()
Properties	super.someProperty()
Subscripts	super[someIndex]

Methods Overriding

---

Inherited instance and type methods can be overridden by the 'override' keyword to our methods defined in our subclass. Here print() is overridden in subclass to access the type property mentioned in the super class print(). Also new instance of cricket() super class is created as 'cricinstance'.

class cricket { func print() { println("Welcome to Swift Super Class") } } class tennis: cricket { override func print() { println("Welcome to Swift Sub Class") } } let cricinstance = cricket() cricinstance.print() let tennisinstance = tennis() tennisinstance.print()

When we run the above program using playground, we get the following result −

Welcome to Swift Super Class
Welcome to Swift Sub Class

Property Overriding

---

You can override an inherited instance or class property to provide your own custom getter and setter for that property, or to add property observers to enable the overriding property to observe when the underlying property value changes.

Overriding Property Getters and Setters

Swift allows the user to provide custom getter and setter to override the inherited property whether it is a stored or computed property. The subclass does not know the inherited property name and type. Therefore it is essential that the user needs to specify in subclass, the name and type of the overriding property specified in super class.

This can be done in two ways −

• When setter is defined for overriding property the user has to define getter too.
• When we don't want to modify the inherited property getter, we can simply pass the inherited value by the syntax 'super.someProperty' to the super class.

class Circle { var radius = 12.5 var area: String { return "of rectangle for \(radius) " } } class Rectangle: Circle { var print = 7 override var area: String { return super.area + " is now overridden as \(print)" } } let rect = Rectangle() rect.radius = 25.0 rect.print = 3 println("Radius \(rect.area)")

When we run the above program using playground, we get the following result −

Radius of rectangle for 25.0 is now overridden as 3

Overriding Property Observers

---

When a new property needs to be added for an inherited property, 'property overriding' concept is introduced in Swift. This notifies the user when the inherited property value is altered. But overriding is not applicable for inherited constant stored properties and inherited read-only computed properties.

class Circle { var radius = 12.5 var area: String { return "of rectangle for \(radius) " } } class Rectangle: Circle { var print = 7 override var area: String { return super.area + " is now overridden as \(print)" } } let rect = Rectangle() rect.radius = 25.0 rect.print = 3 println("Radius \(rect.area)") class Square: Rectangle { override var radius: Double { didSet { print = Int(radius/5.0)+1 } } } let sq = Square() sq.radius = 100.0 println("Radius \(sq.area)")

When we run the above program using playground, we get the following result −

Radius of rectangle for 25.0 is now overridden as 3
Radius of rectangle for 100.0 is now overridden as 21

Final Property to prevent Overriding

---

When the user need not want others to access super class methods, properties or subscripts swift introduces 'final' property to prevent overriding. Once 'final' property is declared the subscripts won't allow the super class methods, properties and its subscripts to be overridden. There is no provision to have 'final' property in 'super class'. When 'final' property is declared the user is restricted to create further sub classes.

final class Circle { final var radius = 12.5 var area: String { return "of rectangle for \(radius) " } } class Rectangle: Circle { var print = 7 override var area: String { return super.area + " is now overridden as \(print)" } } let rect = Rectangle() rect.radius = 25.0 rect.print = 3 println("Radius \(rect.area)") class Square: Rectangle { override var radius: Double { didSet { print = Int(radius/5.0)+1 } } } let sq = Square() sq.radius = 100.0 println("Radius \(sq.area)")

When we run the above program using playground, we get the following result −

<stdin>:14:18: error: var overrides a 'final' var
override var area: String {
^
<stdin>:7:9: note: overridden declaration is here
var area: String {
^
<stdin>:12:11: error: inheritance from a final class 'Circle'
class Rectangle: Circle {
^
<stdin>:25:14: error: var overrides a 'final' var
override var radius: Double {
^ <stdin>:6:14: note: overridden declaration is here
final var radius = 12.5

Since the super class is declared as 'final' and its data types are also declared as 'final' the program won't allow to create subclasses further and it will throw errors.

25 - SWIFT INITIALIZATION

Classes, structures and enumerations once declared in Swift are initialized for preparing instance of a class. Initial value is initialized for stored property and also for new instances too the values are initialized to proceed further. The keyword to create initialization function is carried out by 'init()' method. Swift initializer differs from Objective-C that it does not return any values. Its function is to check for initialization of newly created instances before its processing. Swift also provides 'deinitialization' process for performing memory management operations once the instances are deallocated.

Initializer Role for Stored Properties

---

Stored property have to initialize the instances for its classes and structures before processing the instances. Stored properties use initializer to assign and initialize values thereby eradicating the need to call property observers. Initializer is used in stored property.

• To create an initial value.
• To assign default property value within the property definition.
• To initialize an instance for a particular data type 'init()' is used. No arguments are passed inside the init() function.

Syntax

init() { //New Instance initialization goes here }

Example

struct rectangle { var length: Double var breadth: Double init() { length = 6 breadth = 12 } } var area = rectangle() println("area of rectangle is \(area.length*area.breadth)")

area of rectangle is 72.0

area of rectangle is 72.0

Here the structure 'rectangle' is initialized with members length and breadth as 'Double' datatypes. Init() method is used to initialize the values for the newly created members length and double. Area of rectangle is calculated and returned by calling the rectangle function.

Setting Property Values by Default

---

Swift language provides Init() function to initialize the stored property values. Also, the user has provision to initialize the property values by default while declaring the class or structure members. When the property takes the same value alone throughout the program we can declare it in the declaration section alone rather than initializing it in init(). Setting property values by default enables the user when inheritance is defined for classes or structures.

struct rectangle { var length = 6 var breadth = 12 } var area = rectangle() println("area of rectangle is \(area.length*area.breadth)")

When we run the above program using playground, we get the following result −

area of rectangle is 72.0

Here instead of declaring length and breadth in init() the values are initialized in declaration itself.

Parameters Initialization

---

In Swift language the user has the provision to initialize parameters as part of the initializer's definition using init().

struct Rectangle { var length: Double var breadth: Double var area: Double init(fromLength length: Double, fromBreadth breadth: Double) { self.length = length self.breadth = breadth area = length * breadth } init(fromLeng leng: Double, fromBread bread: Double) { self.length = leng self.breadth = bread area = leng * bread } } let ar = Rectangle(fromLength: 6, fromBreadth: 12) println("area is: \(ar.area)") let are = Rectangle(fromLeng: 36, fromBread: 12) println("area is: \(are.area)")

When we run the above program using playground, we get the following result −

area is: 72.0
area is: 432.0

Local & External Parameters

---

Initialization parameters have both local and global parameter names similar to that of function and method parameters. Local parameter declaration is used to access within the initialize body and external parameter declaration is used to call the initializer. Swift initializers differ from function and method initializer that they do not identify which initializer are used to call which functions.

To overcome this, Swift introduces an automatic external name for each and every parameter in init(). This automatic external name is as equivalent as local name written before every initialization parameter.

struct Days { let sunday, monday, tuesday: Int init(sunday: Int, monday: Int, tuesday: Int) { self.sunday = sunday self.monday = monday self.tuesday = tuesday } init(daysofaweek: Int) { sunday = daysofaweek monday = daysofaweek tuesday = daysofaweek } } let week = Days(sunday: 1, monday: 2, tuesday: 3) println("Days of a Week is: \(week.sunday)") println("Days of a Week is: \(week.monday)") println("Days of a Week is: \(week.tuesday)") let weekdays = Days(daysofaweek: 4) println("Days of a Week is: \(weekdays.sunday)") println("Days of a Week is: \(weekdays.monday)") println("Days of a Week is: \(weekdays.tuesday)")

When we run the above program using playground, we get the following result −

Days of a Week is: 1
Days of a Week is: 2
Days of a Week is: 3
Days of a Week is: 4
Days of a Week is: 4
Days of a Week is: 4

Parameters without External Names

---

When an external name is not needed for an initialize underscore '_' is used to override the default behavior.

struct Rectangle { var length: Double init(frombreadth breadth: Double) { length = breadth * 10 } init(frombre bre: Double) { length = bre * 30 } init(_ area: Double) { length = area } } let rectarea = Rectangle(180.0) println("area is: \(rectarea.length)") let rearea = Rectangle(370.0) println("area is: \(rearea.length)") let recarea = Rectangle(110.0) println("area is: \(recarea.length)")

When we run the above program using playground, we get the following result −

area is: 180.0
area is: 370.0
area is: 110.0

Optional Property Types

---

When the stored property at some instance does not return any value that property is declared with an 'optional' type indicating that 'no value' is returned for that particular type. When the stored property is declared as 'optional' it automatically initializes the value to be 'nil' during initialization itself.

struct Rectangle { var length: Double? init(frombreadth breadth: Double) { length = breadth * 10 } init(frombre bre: Double) { length = bre * 30 } init(_ area: Double) { length = area } } let rectarea = Rectangle(180.0) println("area is: \(rectarea.length)") let rearea = Rectangle(370.0) println("area is: \(rearea.length)") let recarea = Rectangle(110.0) println("area is: \(recarea.length)")

When we run the above program using playground, we get the following result −

area is: Optional(180.0)
area is: Optional(370.0)
area is: Optional(110.0)

Modifying Constant Properties During Initialization

---

Initialization also allows the user to modify the value of constant property too. During initialization, class property allows its class instances to be modified by the super class and not by the subclass. Consider for example in the previous program 'length' is declared as 'variable' in the main class. The below program variable 'length' is modified as 'constant' variable.

struct Rectangle { let length: Double? init(frombreadth breadth: Double) { length = breadth * 10 } init(frombre bre: Double) { length = bre * 30 } init(_ area: Double) { length = area } } let rectarea = Rectangle(180.0) println("area is: \(rectarea.length)") let rearea = Rectangle(370.0) println("area is: \(rearea.length)") let recarea = Rectangle(110.0) println("area is: \(recarea.length)")

When we run the above program using playground, we get the following result −

area is: Optional(180.0)
area is: Optional(370.0)
area is: Optional(110.0)

Default Initializers

---

Default initializers provide a new instance to all its declared properties of base class or structure with default values.

class defaultexample { var studname: String? var stmark = 98 var pass = true } var result = defaultexample() println("result is: \(result.studname)") println("result is: \(result.stmark)") println("result is: \(result.pass)")

When we run the above program using playground, we get the following result −

result is: nil
result is: 98
result is: true

The above program is defined with class name as 'defaultexample'. Three member functions are initialized by default as 'studname?' to store 'nil' values, 'stmark' as 98 and 'pass' as Boolean value 'true'. Likewise the member values in the class can be initialized as default before processing the class member types.

Memberwise Initializers for Structure Types

---

When the custom initializers are not provided by the user, Structure types in Swift will automatically receive the 'memberwise initializer'. Its main function is to initialize the new structure instances with the default memberwise initialize and then the new instance properties are passed to the memberwise initialize by name.

struct Rectangle { var length = 100.0, breadth = 200.0 } let area = Rectangle(length: 24.0, breadth: 32.0) println("Area of rectangle is: \(area.length)") println("Area of rectangle is: \(area.breadth)")

When we run the above program using playground, we get the following result −

Area of rectangle is: 24.0
Area of rectangle is: 32.0

Structures are initialized by default for their membership functions during initialization for 'length' as '100.0' and 'breadth' as '200.0'. But the values are overridden during the processing of variables length and breadth as 24.0 and 32.0.

Initializer Delegation for Value Types

---

Initializer Delegation is defined as calling initializers from other initializers. Its main function is to act as reusability to avoid code duplication across multiple initializers.

struct Stmark { var mark1 = 0.0, mark2 = 0.0 } struct stdb { var m1 = 0.0, m2 = 0.0 } struct block { var average = stdb() var result = Stmark() init() {} init(average: stdb, result: Stmark) { self.average = average self.result = result } init(avg: stdb, result: Stmark) { let tot = avg.m1 - (result.mark1 / 2) let tot1 = avg.m2 - (result.mark2 / 2) self.init(average: stdb(m1: tot, m2: tot1), result: result) } } let set1 = block() println("student result is: \(set1.average.m1, set1.average.m2) \(set1.result.mark1, set1.result.mark2)") let set2 = block(average: stdb(m1: 2.0, m2: 2.0), result: Stmark(mark1: 5.0, mark2: 5.0)) println("student result is: \(set2.average.m1, set2.average.m2) \(set2.result.mark1, set2.result.mark2)") let set3 = block(avg: stdb(m1: 4.0, m2: 4.0), result: Stmark(mark1: 3.0, mark2: 3.0)) println("student result is: \(set3.average.m1, set3.average.m2) \(set3.result.mark1, set3.result.mark2)")

When we run the above program using playground, we get the following result −

student result is: (0.0, 0.0) (0.0, 0.0)
student result is: (2.0, 2.0) (5.0, 5.0)
student result is: (2.5, 2.5) (3.0, 3.0)

Rules for Initializer Delegation

---

Value Types	Class Types
Inheritance is not supported for value types like structures and enumerations. Referring other initializers is done through self.init.	Inheritance is supported. Checks all stored property values are initialized.

Class Inheritance and Initialization

---

Class types have two kinds of initializers to check whether defined stored properties receive an initial value namely designated initializers and convenience initializers.

Designated Initializers and Convenience Initializers

Designated Initializer	Convenience Initializer
Considered as primary initializes for a class.	Considered as supporting initialize for a class.
All class properties are initialized and appropriate superclass initializer are called for further initialization.	Designated initializer is called with convenience initializer to create class instance for a specific use case or input value type.
At least one designated initializer is defined for every class.	No need to have convenience initializers compulsory defined when the class does not require initializers.
Init(parameters) { statements }	convenience init(parameters) { statements }

Program for Designated Initializers

class mainClass { var no1 : Int // local storage init(no1 : Int) { self.no1 = no1 // initialization } } class subClass : mainClass { var no2 : Int // new subclass storage init(no1 : Int, no2 : Int) { self.no2 = no2 // initialization super.init(no1:no1) // redirect to superclass } } let res = mainClass(no1: 10) let print = subClass(no1: 10, no2: 20) println("res is: \(res.no1)") println("res is: \(print.no1)") println("res is: \(print.no2)") When we run the above program using playground, we get the following result −

res is: 10
res is: 10
res is: 20

Program for Convenience Initializers

class mainClass { var no1 : Int // local storage init(no1 : Int) { self.no1 = no1 // initialization } } class subClass : mainClass { var no2 : Int init(no1 : Int, no2 : Int) { self.no2 = no2 super.init(no1:no1) } // Requires only one parameter for convenient method override convenience init(no1: Int) { self.init(no1:no1, no2:0) } } let res = mainClass(no1: 20) let print = subClass(no1: 30, no2: 50) println("res is: \(res.no1)") println("res is: \(print.no1)") println("res is: \(print.no2)")

When we run the above program using playground, we get the following result −

res is: 20
res is: 30
res is: 50

Initializer Inheritance and Overriding

---

Swift does not allow its subclasses to inherit its superclass initializers for their member types by default. Inheritance is applicable to Super class initializers only to some extent which will be discussed in Automatic Initializer Inheritance.

When the user needs to have initializers defined in super class, subclass with initializers has to be defined by the user as custom implementation. When overriding has to be taken place by the sub class to the super class 'override' keyword has to be declared.

class sides { var corners = 4 var description: String { return "\(corners) sides" } } let rectangle = sides() println("Rectangle: \(rectangle.description)") class pentagon: sides { override init() { super.init() corners = 5 } } let bicycle = pentagon() println("Pentagon: \(bicycle.description)")

When we run the above program using playground, we get the following result −

Rectangle: 4 sides
Pentagon: 5 sides

Designated and Convenience Initializers in Action

---

class Planet { var name: String init(name: String) { self.name = name } convenience init() { self.init(name: "[No Planets]") } } let plName = Planet(name: "Mercury") println("Planet name is: \(plName.name)") let noplName = Planet() println("No Planets like that: \(noplName.name)") class planets: Planet { var count: Int init(name: String, count: Int) { self.count = count super.init(name: name) } override convenience init(name: String) { self.init(name: name, count: 1) } }

When we run the above program using playground, we get the following result −

Planet name is: Mercury
No Planets like that: [No Planets]

Failable Initializer

---

The user has to be notified when there are any initializer failures while defining a class, structure or enumeration values. Initialization of variables sometimes become a failure one due to −

• Invalid parameter values.
• Absence of required external source.
• Condition preventing initialization from succeeding.

To catch exceptions thrown by initialization method, swift produces a flexible initialize called 'failable initializer' to notify the user that something is left unnoticed while initializing the structure, class or enumeration members. Keyword to catch the failable initializer is 'init?'. Also, failable and non failable initializers cannot be defined with same parameter types and names.

struct studrecord { let stname: String init?(stname: String) { if stname.isEmpty {return nil } self.stname = stname } } let stmark = studrecord(stname: "Swing") if let name = stmark { println("Student name is specified") } let blankname = studrecord(stname: "") if blankname == nil { println("Student name is left blank") }

When we run the above program using playground, we get the following result −

Student name is specified
Student name is left blank

Failable Initializers for Enumerations

---

Swift language provides the flexibility to have Failable initializers for enumerations too to notify the user when the enumeration members are left from initializing values.

enum functions { case a, b, c, d init?(funct: String) { switch funct { case "one": self = .a case "two": self = .b case "three": self = .c case "four": self = .d default: return nil } } } let result = functions(funct: "two") if result != nil { println("With In Block Two") } let badresult = functions(funct: "five") if badresult == nil { println("Block Does Not Exist") }

When we run the above program using playground, we get the following result −

With In Block Two
Block Does Not Exist

Failable Initializers for Classes

---

A failable initializer when declared with enumerations and structures alerts an initialization failure at any circumstance within its implementation. However, failable initializer in classes will alert the failure only after the stored properties have been set to an initial value.

class studrecord { let studname: String! init?(studname: String) { self.studname = studname if studname.isEmpty { return nil } } } if let stname = studrecord(studname: "Failable Initializers") { println("Module is \(stname.studname)") }

When we run the above program using playground, we get the following result −

Module is Failable Initializers

Overriding a Failable Initializer

---

Like that of initialize the user also has the provision to override a superclass failable initializer inside the sub class. Super class failable initialize can also be overridden with in a sub class non-failable initializer.

Subclass initializer cannot delegate up to the superclass initializer when overriding a failable superclass initializer with a non-failable subclass initialize.

A non-failable initializer can never delegate to a failable initializer.

The program given below describes the failable and non-failable initializers.

class Planet { var name: String init(name: String) { self.name = name } convenience init() { self.init(name: "[No Planets]") } } let plName = Planet(name: "Mercury") println("Planet name is: \(plName.name)") let noplName = Planet() println("No Planets like that: \(noplName.name)") class planets: Planet { var count: Int init(name: String, count: Int) { self.count = count super.init(name: name) } override convenience init(name: String) { self.init(name: name, count: 1) } }

When we run the above program using playground, we get the following result −

Planet name is: Mercury
No Planets like that: [No Planets]

The init! Failable Initializer

---

Swift provides 'init?' to define an optional instance failable initializer. To define an implicitly unwrapped optional instance of the specific type 'init!' is specified.

struct studrecord { let stname: String init!(stname: String) { if stname.isEmpty {return nil } self.stname = stname } } let stmark = studrecord(stname: "Swing") if let name = stmark { println("Student name is specified") } let blankname = studrecord(stname: "") if blankname == nil { println("Student name is left blank") }

When we run the above program using playground, we get the following result −

Student name is specified
Student name is left blank

Required Initializers

---

To declare each and every subclass of the initialize 'required' keyword needs to be defined before the init() function.

class classA { required init() { var a = 10 println(a) } } class classB: classA { required init() { var b = 30 println(b) } } let res = classA() let print = classB()

When we run the above program using playground, we get the following result −

10
30
10

26 - SWIFT DEINITIALIZATION

Before a class instance needs to be deallocated 'deinitializer' has to be called to deallocate the memory space. The keyword 'deinit' is used to deallocate the memory spaces occupied by the system resources. Deinitialization is available only on class types.

Deinitialization to Deallocate Memory Space

---

Swift automatically deallocates your instances when they are no longer needed, to free up resources. Swift handles the memory management of instances through automatic reference counting (ARC), as described in Automatic Reference Counting. Typically you don't need to perform manual clean-up when your instances are deallocated. However, when you are working with your own resources, you might need to perform some additional clean-up yourself. For example, if you create a custom class to open a file and write some data to it, you might need to close the file before the class instance is deallocated.

var counter = 0; // for reference counting class baseclass { init() { counter++; } deinit { counter--; } } var print: baseclass? = baseclass() println(counter) print = nil println(counter)

When we run the above program using playground, we get the following result −

1
0

When print = nil statement is omitted the values of the counter retains the same since it is not deinitialized.

var counter = 0; // for reference counting class baseclass { init() { counter++; } deinit { counter--; } } var print: baseclass? = baseclass() println(counter) println(counter

When we run the above program using playground, we get the following result −

1
1

27 - SWIFT ARC OVERVIEW

Memory management functions and its usage are handled in Swift language through Automatic reference counting (ARC). ARC is used to initialize and deinitialize the system resources thereby releasing memory spaces used by the class instances when the instances are no longer needed. ARC keeps track of information about the relationships between our code instances to manage the memory resources effectively.

Functions of ARC

---

• ARC allocates a chunk of memory to store the information each and every time when a new class instance is created by init().
• Information about the instance type and its values are stored in memory.
• When the class instance is no longer needed it automatically frees the memory space by deinit() for further class instance storage and retrieval.
• ARC keeps in track of currently referring class instances properties, constants and variables so that deinit() is applied only to those unused instances.
• ARC maintains a 'strong reference' to those class instance property, constants and variables to restrict deallocation when the class instance is currently in use.

ARC Program

---

class StudDetails { var stname: String! var mark1: Int! init(stname: String, mark1: Int) { self.stname = stname self.mark1 = mark1 } deinit { println("Deinitialized \(self.stname)") println("Deinitialized \(self.mark1)") } } let stname = "swift" let mark1 = 98 println(stname) println(mark1)

When we run the above program using playground, we get the following result −

swift
98

ARC Strong Reference Cycles Class Instances

---

class studmarks { let name: String var stud1: student? init (name: String) { println("Initializing: \(name)") self.name = name } deinit { println("Deallocating: \(self.name)") } } class student { let name: String var strname: studmarks? init (name: String) { println("Initializing: \(name)") self.name = name } deinit { println("Deallocating: \(self.name)") } } var shiba: studmarks? var mari: student? shiba = studmarks(name: "Swift") mari = student(name: "ARC") shiba!.stud1 = mari mari!.strname = shiba

When we run the above program using playground, we get the following result −

Initializing: Swift
Initializing: ARC

ARC Weak and Unowned References

---

Class type properties has two ways to resolve strong reference cycles −

• Weak References
• Unowned References

These references are used to enable one instance to refer other instances in a reference cycle. Then the instances may refer to each and every instances instead of caring about strong reference cycle. When the user knows that some instance may return 'nil' values we may point that using weak reference. When the instance going to return something rather than nil then declare it with unowned reference.

Weak Reference Program

---

class module { let name: String init(name: String) { self.name = name } var sub: submodule? deinit { println("\(name) Is The Main Module") } } class submodule { let number: Int init(number: Int) { self.number = number } weak var topic: module? deinit { println("Sub Module with its topic number is \(number)") } } var toc: module? var list: submodule? toc = module(name: "ARC") list = submodule(number: 4) toc!.sub = list list!.topic = toc toc = nil list = nil

When we run the above program using playground, we get the following result −

ARC Is The Main Module
Sub Module with its topic number is 4

Unowned Reference Program

---

class student { let name: String var section: marks? init(name: String) { self.name = name } deinit { println("\(name)") } } class marks { let marks: Int unowned let stname: student init(marks: Int, stname: student) { self.marks = marks self.stname = stname } deinit { println("Marks Obtained by the student is \(marks)") } } var module: student? module = student(name: "ARC") module!.section = marks(marks: 98, stname: module!) module = nil

When we run the above program using playground, we get the following result −

ARC
Marks Obtained by the student is 98

Strong Reference Cycles for Closures

---

When we assign a closure to the class instance property and to the body of the closure to capture particular instance strong reference cycle can occur. Strong reference to the closure is defined by 'self.someProperty' or 'self.someMethod()'. Strong reference cycles are used as reference types for the closures.

class HTMLElement { let samplename: String let text: String? lazy var asHTML: () -> String = { if let text = self.text { return "<\(self.samplename)>\(text)</\(self.samplename)>" }else { return "<\(self.samplename) />" } } init(samplename: String, text: String? = nil) { self.samplename = samplename self.text = text } deinit { println("\(samplename) is being deinitialized") } } var paragraph: HTMLElement? = HTMLElement(samplename: "p", text: "Welcome to Closure SRC") println(paragraph!.asHTML())

When we run the above program using playground, we get the following result −

<p>Welcome to Closure SRC</p>

Weak and Unowned References

---

When the closure and the instance refer to each other the user may define the capture in a closure as an unowned reference. Then it would not allow the user to deallocate the instance at the same time. When the instance sometime return a 'nil' value define the closure with the weak instance.

class HTMLElement { let module: String let text: String? lazy var asHTML: () -> String = { [unowned self] in if let text = self.text { return "<\(self.module)>\(text)</\(self.module)>" }else { return "<\(self.module) />" } } init(module: String, text: String? = nil) { self.module = module self.text = text } deinit { println("\(module) the deinit()") } } var paragraph: HTMLElement? = HTMLElement(module: "Inside", text: "ARC Weak References") println(paragraph!.asHTML()) paragraph = nil

When we run the above program using playground, we get the following result −

<Inside>ARC Weak References</Inside>
Inside the deinit()

28 - SWIFT OPTIONAL CHAINING

The process of querying, calling properties, subscripts and methods on an optional that may be 'nil' is defined as optional chaining. Optional chaining return two values −

• if the optional contains a 'value' then calling its related property, methods and subscripts returns values.
• if the optional contains a 'nil' value all its its related property, methods and subscripts returns nil.

Since multiple queries to methods, properties and subscripts are grouped together failure to one chain will affect the entire chain and results in 'nil' value.

Optional Chaining as an Alternative to Forced Unwrapping

---

Optional chaining is specified after the optional value with '?' to call a property, method or subscript when the optional value returns some values.

Optional Chaining '?'	Access to methods,properties and subscriptsOptional Chaining '!' to force Unwrapping
? is placed after the optional value to call property, method or subscript	! is placed after the optional value to call property, method or subscript to force unwrapping of value
Fails gracefully when the optional is 'nil'	Forced unwrapping triggers a run time error when the optional is 'nil'

Program for Optional Chaining with '!'

class ElectionPoll { var candidate: Pollbooth? } class Pollbooth { var name = "MP" } let cand = ElectionPoll() let candname = cand.candidate!.name

When we run the above program using playground, we get the following result −

fatal error: unexpectedly found nil while unwrapping an Optional value
0  swift                    0x0000000103410b68 llvm::sys::PrintStackTrace(__sFILE*) + 40
1  swift                    0x0000000103411054 SignalHandler(int) + 452
2  libsystem_platform.dylib 0x00007fff9176af1a _sigtramp + 26
3  libsystem_platform.dylib 0x000000000000000b _sigtramp + 1854492939
4  libsystem_platform.dylib 0x00000001074a0214 _sigtramp + 1976783636
5  swift                    0x0000000102a85c39 llvm::JIT::runFunction(llvm::Function*, std::__1::vector<llvm::GenericValue, std::__1::allocator<llvm::GenericValue> > const&) + 329
6  swift                    0x0000000102d320b3 llvm::ExecutionEngine::runFunctionAsMain(llvm::Function*, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&, char const* const*) + 1523
7  swift                    0x000000010296e6ba swift::RunImmediately(swift::CompilerInstance&, std::__1::vector<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> >, std::__1::allocator<std::__1::basic_string<char, std::__1::char_traits<char>, std::__1::allocator<char> > > > const&, swift::IRGenOptions&, swift::SILOptions const&) + 1066
8  swift                    0x000000010275764b frontend_main(llvm::ArrayRef<char const*>, char const*, void*) + 5275
9  swift                    0x0000000102754a6d main + 1677
10 libdyld.dylib            0x00007fff8bb9e5c9 start + 1
11 libdyld.dylib            0x000000000000000c start + 1950751300
Stack dump:
0.	Program arguments: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swift -frontend -interpret - -target x86_64-apple-darwin14.0.0 -target-cpu core2 -sdk /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX10.10.sdk -module-name main 
/bin/sh: line 47: 15672 Done                    cat  <<'SWIFT'
import Foundation

The above program declares 'election poll' as class name and contains 'candidate' as membership function. The subclass is declared as 'poll booth' and 'name' as its membership function which is initialized as 'MP'. The call to the super class is initialized by creating an instance 'cand' with optional '!'. Since the values are not declared in its base class, 'nil' value is stored thereby returning a fatal error by the force unwrapping procedure.

Program for Optional Chaining with '?'

class ElectionPoll { var candidate: Pollbooth? } class Pollbooth { var name = "MP" } let cand = ElectionPoll() if let candname = cand.candidate?.name { println("Candidate name is \(candname)") }else { println("Candidate name cannot be retreived") }

When we run the above program using playground, we get the following result −

Candidate name cannot be retreived

The program above declares 'election poll' as class name and contains 'candidate' as membership function. The subclass is declared as 'poll booth' and 'name' as its membership function which is initialized as 'MP'. The call to the super class is initialized by creating an instance 'cand' with optional '?'. Since the values are not declared in its base class 'nil' value is stored and printed in the console by the else handler block.

Defining Model Classes for Optional Chaining & Accessing Properties

---

Swift language also provides the concept of optional chaining, to declare more than one subclasses as model classes. This concept will be very useful to define complex models and to access the properties, methods and subscripts sub properties.

class rectangle { var print: circle? } class circle { var area = [radius]() var cprint: Int { return area.count } subscript(i: Int) -> radius { get { return area[i] }set { area[i] = newValue } } func circleprint() { println("The number of rooms is \(cprint)") } var rectarea: circumference? } class radius { let radiusname: String init(radiusname: String) { self.radiusname = radiusname } } class circumference { var circumName: String? var circumNumber: String? var street: String? func buildingIdentifier() -> String? { if circumName != nil { return circumName }else if circumNumber != nil { return circumNumber }else { return nil } } } let rectname = rectangle() if let rectarea = rectname.print?.cprint { println("Area of rectangle is \(rectarea)") } else { println("Rectangle Area is not specified") }

When we run the above program using playground, we get the following result −

Rectangle Area is not specified

Calling Methods Through Optional Chaining

---

class rectangle { var print: circle? } class circle { var area = [radius]() var cprint: Int { return area.count } subscript(i: Int) -> radius { get { return area[i] }set { area[i] = newValue } } func circleprint() { println("Area of Circle is: \(cprint)") } var rectarea: circumference? } class radius { let radiusname: String init(radiusname: String) { self.radiusname = radiusname } } class circumference { var circumName: String? var circumNumber: String? var circumarea: String? func buildingIdentifier() -> String? { if circumName != nil { return circumName }else if circumNumber != nil { return circumNumber }else { return nil } } } let circname = rectangle() if circname.print?.circleprint() != nil { println("Area of circle is specified)") } else { println("Area of circle is not specified") }

When we run the above program using playground, we get the following result −

Area of circle is not specified

The function circleprint() declared inside the circle() sub class is called by creating an instance named 'circname'. The function will return a value if it contains some value otherwise it will return some user defined print message by checking the statement 'if circname.print?.circleprint() != nil'.

Accessing Subscripts through Optional Chaining

---

Optional chaining is used to set and retrieve a subscript value to validate whether call to that subscript returns a value. '?' is placed before the subscript braces to access the optional value on the particular subscript.

Program 1

class rectangle { var print: circle? } class circle { var area = [radius]() var cprint: Int { return area.count } subscript(i: Int) -> radius { get { return area[i] }set { area[i] = newValue } } func circleprint() { println("The number of rooms is \(cprint)") } var rectarea: circumference? } class radius { let radiusname: String init(radiusname: String) { self.radiusname = radiusname } } class circumference { var circumName: String? var circumNumber: String? var circumarea: String? func buildingIdentifier() -> String? { if circumName != nil { return circumName }else if circumNumber != nil { return circumNumber }else { return nil } } } let circname = rectangle() if let radiusName = circname.print?[0].radiusname { println("The first room name is \(radiusName).") } else { println("Radius is not specified.") }

When we run the above program using playground, we get the following result −

Radius is not specified.

In the above program the instance values for the membership function 'radiusName' is not specified. Hence program call to the function will return only else part whereas to return the values we have to define the values for the particular membership function.

Program 2

---

class rectangle { var print: circle? } class circle { var area = [radius]() var cprint: Int { return area.count } subscript(i: Int) -> radius { get { return area[i] }set { area[i] = newValue } } func circleprint() { println("The number of rooms is \(cprint)") } var rectarea: circumference? } class radius { let radiusname: String init(radiusname: String) { self.radiusname = radiusname } } class circumference { var circumName: String? var circumNumber: String? var circumarea: String? func buildingIdentifier() -> String? { if circumName != nil { return circumName }else if circumNumber != nil { return circumNumber }else { return nil } } } let circname = rectangle() circname.print?[0] = radius(radiusname: "Diameter") let printing = circle() printing.area.append(radius(radiusname: "Units")) printing.area.append(radius(radiusname: "Meter")) circname.print = printing if let radiusName = circname.print?[0].radiusname { println("Radius is measured in \(radiusName).") }else { println("Radius is not specified.") }

When we run the above program using playground, we get the following result −

Radius is measured in Units.

In the above program, the instance values for the membership function 'radiusName' is specified. Hence program call to the function will now return values.

Accessing Subscripts of Optional Type

---

class rectangle { var print: circle? } class circle { var area = [radius]() var cprint: Int { return area.count } subscript(i: Int) -> radius { get { return area[i] }set { area[i] = newValue } } func circleprint() { println("The number of rooms is \(cprint)") } var rectarea: circumference? } class radius { let radiusname: String init(radiusname: String) { self.radiusname = radiusname } } class circumference { var circumName: String? var circumNumber: String? var circumarea: String? func buildingIdentifier() -> String? { if circumName != nil { return circumName }else if circumNumber != nil { return circumNumber }else { return nil } } } let circname = rectangle() circname.print?[0] = radius(radiusname: "Diameter") let printing = circle() printing.area.append(radius(radiusname: "Units")) printing.area.append(radius(radiusname: "Meter")) circname.print = printing var area = ["Radius": [35, 45, 78, 101], "Circle": [90, 45, 56]] area["Radius"]?[1] = 78 area["Circle"]?[1]-- println(area["Radius"]?[0]) println(area["Radius"]?[1]) println(area["Radius"]?[2]) println(area["Radius"]?[3]) println(area["Circle"]?[0]) println(area["Circle"]?[1]) println(area["Circle"]?[2])

When we run the above program using playground, we get the following result −

Optional(35)
Optional(78)
Optional(78)
Optional(101)
Optional(90)
Optional(44)
Optional(56)

The optional values for subscripts can be accessed by referring their subscript values. It can be accessed as subscript[0], subscript[1] etc. The default subscript values for 'radius' are first assigned as [35, 45, 78, 101] and for 'Circle' [90, 45, 56]]. Then the subscript values are changed as Radius[0] to 78 and Circle[1] to 45.

Linking Multiple Levels of Chaining

---

Multiple sub classes can also be linked with its super class methods, properties and subscripts by optional chaining.

Multiple chaining of optional can be linked −

If retrieving type is not optional, optional chaining will return an optional value. For example if String through optional chaining it will return String? Value

class rectangle { var print: circle? } class circle { var area = [radius]() var cprint: Int { return area.count } subscript(i: Int) -> radius { get { return area[i] }set { area[i] = newValue } } func circleprint() { println("The number of rooms is \(cprint)") } var rectarea: circumference? } class radius { let radiusname: String init(radiusname: String) { self.radiusname = radiusname } } class circumference { var circumName: String? var circumNumber: String? var circumarea: String? func buildingIdentifier() -> String? { if circumName != nil { return circumName }else if circumNumber != nil { return circumNumber }else { return nil } } } let circname = rectangle() if let radiusName = circname.print?[0].radiusname { println("The first room name is \(radiusName).") }else { println("Radius is not specified.") }

When we run the above program using playground, we get the following result −

Radius is not specified.

In the above program, the instance values for the membership function 'radiusName' is not specified. Hence, the program call to the function will return only else part whereas to return the values we have to define the values for the particular membership function.

If the retrieving type is already optional, then optional chaining will also return an optional value. For example if String? Is accessed through optional chaining it will return String? Value.

class rectangle { var print: circle? } class circle { var area = [radius]() var cprint: Int { return area.count } subscript(i: Int) -> radius { get { return area[i] }set { area[i] = newValue } } func circleprint() { println("The number of rooms is \(cprint)") } var rectarea: circumference? } class radius { let radiusname: String init(radiusname: String) { self.radiusname = radiusname } } class circumference { var circumName: String? var circumNumber: String? var circumarea: String? func buildingIdentifier() -> String? { if circumName != nil { return circumName }else if circumNumber != nil { return circumNumber }else { return nil } } } let circname = rectangle() circname.print?[0] = radius(radiusname: "Diameter") let printing = circle() printing.area.append(radius(radiusname: "Units")) printing.area.append(radius(radiusname: "Meter")) circname.print = printing if let radiusName = circname.print?[0].radiusname { println("Radius is measured in \(radiusName).") }else { println("Radius is not specified.") }

When we run the above program using playground, we get the following result −

Radius is measured in Units.

In the above program, the instance values for the membership function 'radiusName' is specified. Hence, the program call to the function will now return values.

Chaining on Methods with Optional Return Values

---

Optional chaining is used to access subclasses defined methods too.

class rectangle { var print: circle? } class circle { var area = [radius]() var cprint: Int { return area.count } subscript(i: Int) -> radius { get { return area[i] }set { area[i] = newValue } } func circleprint() { println("Area of Circle is: \(cprint)") } var rectarea: circumference? } class radius { let radiusname: String init(radiusname: String) { self.radiusname = radiusname } } class circumference { var circumName: String? var circumNumber: String? var circumarea: String? func buildingIdentifier() -> String? { if circumName != nil { return circumName }else if circumNumber != nil { return circumNumber }else { return nil } } } let circname = rectangle() if circname.print?.circleprint() != nil { println("Area of circle is specified)") }else { println("Area of circle is not specified") }

When we run the above program using playground, we get the following result −

Area of circle is not specified

29 - SWIFT TYPE CASTING

To validate the type of an instance 'Type Casting' comes into play in Swift language. It is used to check whether the instance type belongs to a particular super class or subclass or it is defined in its own hierarchy.

Swift type casting provides two operators 'is' to check the type of a value and 'as' and to cast the type value to a different type. Type casting also checks whether the instance type follows particular protocol conformance standard.

Defining a Class Hierarchy

---

Type casting is used to check the type of instances to find out whether it belongs to particular class type. Also, it checks hierarchy of classes and its subclasses to check and cast those instances to make it as a same hierarchy.

class Subjects { var physics: String init(physics: String) { self.physics = physics } } class Chemistry: Subjects { var equations: String init(physics: String, equations: String) { self.equations = equations super.init(physics: physics) } } class Maths: Subjects { var formulae: String init(physics: String, formulae: String) { self.formulae = formulae super.init(physics: physics) } } let sa = [ Chemistry(physics: "solid physics", equations: "Hertz"), Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz")] let samplechem = Chemistry(physics: "solid physics", equations: "Hertz") println("Instance physics is: \(samplechem.physics)") println("Instance equation is: \(samplechem.equations)") let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz") println("Instance physics is: \(samplemaths.physics)") println("Instance formulae is: \(samplemaths.formulae)")

When we run the above program using playground, we get the following result −

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz

Type Checking

---

Type checking is done with the 'is' operator. The 'is' type check operator checks whether the instance belongs to particular subclass type and returns 'true' if it belongs to that instance else it will return 'false'.

class Subjects { var physics: String init(physics: String) { self.physics = physics } } class Chemistry: Subjects { var equations: String init(physics: String, equations: String) { self.equations = equations super.init(physics: physics) } } class Maths: Subjects { var formulae: String init(physics: String, formulae: String) { self.formulae = formulae super.init(physics: physics) } } let sa = [ Chemistry(physics: "solid physics", equations: "Hertz"), Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"), Chemistry(physics: "Thermo physics", equations: "Decibels"), Maths(physics: "Astro Physics", formulae: "MegaHertz"), Maths(physics: "Differential Equations", formulae: "Cosine Series")] let samplechem = Chemistry(physics: "solid physics", equations: "Hertz") println("Instance physics is: \(samplechem.physics)") println("Instance equation is: \(samplechem.equations)") let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz") println("Instance physics is: \(samplemaths.physics)") println("Instance formulae is: \(samplemaths.formulae)") var chemCount = 0 var mathsCount = 0 for item in sa { if item is Chemistry { ++chemCount }else if item is Maths { ++mathsCount } } println("Subjects in chemistry contains \(chemCount) topics and maths contains \(mathsCount) topics")

When we run the above program using playground, we get the following result −

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Subjects in chemistry contains 2 topics and maths contains 3 topics

Downcasting

---

Downcasting the subclass type can be done with two operators (as? and as!).'as?' returns an optional value when the value returns nil. It is used to check successful downcast.

'as!' returns force unwrapping as discussed in the optional chaining when the downcasting returns nil value. It is used to trigger runtime error in case of downcast failure

class Subjects { var physics: String init(physics: String) { self.physics = physics } } class Chemistry: Subjects { var equations: String init(physics: String, equations: String) { self.equations = equations super.init(physics: physics) } } class Maths: Subjects { var formulae: String init(physics: String, formulae: String) { self.formulae = formulae super.init(physics: physics) } } let sa = [ Chemistry(physics: "solid physics", equations: "Hertz"), Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"), Chemistry(physics: "Thermo physics", equations: "Decibels"), Maths(physics: "Astro Physics", formulae: "MegaHertz"), Maths(physics: "Differential Equations", formulae: "Cosine Series")] let samplechem = Chemistry(physics: "solid physics", equations: "Hertz") println("Instance physics is: \(samplechem.physics)") println("Instance equation is: \(samplechem.equations)") let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz") println("Instance physics is: \(samplemaths.physics)") println("Instance formulae is: \(samplemaths.formulae)") var chemCount = 0 var mathsCount = 0 for item in sa { if let print = item as? Chemistry { println("Chemistry topics are: '\(print.physics)', \(print.equations)") }else if let example = item as? Maths { println("Maths topics are: '\(example.physics)', \(example.formulae)") } }

When we run the above program using playground, we get the following result −

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Chemistry topics are: 'solid physics', Hertz
Maths topics are: 'Fluid Dynamics', Giga Hertz
Chemistry topics are: 'Thermo physics', Decibels
Maths topics are: 'Astro Physics', MegaHertz
Maths topics are: 'Differential Equations', Cosine Series

Typecasting: Any and Any Object

---

The keyword 'Any' is used to represent an instance which belongs to any type including function types.

class Subjects { var physics: String init(physics: String) { self.physics = physics } } class Chemistry: Subjects { var equations: String init(physics: String, equations: String) { self.equations = equations super.init(physics: physics) } } class Maths: Subjects { var formulae: String init(physics: String, formulae: String) { self.formulae = formulae super.init(physics: physics) } } let sa = [ Chemistry(physics: "solid physics", equations: "Hertz"), Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"), Chemistry(physics: "Thermo physics", equations: "Decibels"), Maths(physics: "Astro Physics", formulae: "MegaHertz"), Maths(physics: "Differential Equations", formulae: "Cosine Series")] let samplechem = Chemistry(physics: "solid physics", equations: "Hertz") println("Instance physics is: \(samplechem.physics)") println("Instance equation is: \(samplechem.equations)") let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz") println("Instance physics is: \(samplemaths.physics)") println("Instance formulae is: \(samplemaths.formulae)") var chemCount = 0 var mathsCount = 0 for item in sa { if let print = item as? Chemistry { println("Chemistry topics are: '\(print.physics)', \(print.equations)") }else if let example = item as? Maths { println("Maths topics are: '\(example.physics)', \(example.formulae)") } } var exampleany = [Any]() exampleany.append(12) exampleany.append(3.14159) exampleany.append("Example for Any") exampleany.append(Chemistry(physics: "solid physics", equations: "Hertz")) for print in exampleany { switch print { case let someInt as Int: println("Integer value is \(someInt)") case let someDouble as Double where someDouble > 0: println("Pi value is \(someDouble)") case let someString as String: println("\(someString)") case let phy as Chemistry: println("Topics '\(phy.physics)', \(phy.equations)") default: println("None") } }

When we run the above program using playground, we get the following result −

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Chemistry topics are: 'solid physics', Hertz
Maths topics are: 'Fluid Dynamics', Giga Hertz
Chemistry topics are: 'Thermo physics', Decibels
Maths topics are: 'Astro Physics', MegaHertz
Maths topics are: 'Differential Equations', Cosine Series
Integer value is 12
Pi value is 3.14159
Example for Any
Topics 'solid physics', Hertz

AnyObject

---

To represent the instance of any class type, 'AnyObject' keyword is used.

class Subjects { var physics: String init(physics: String) { self.physics = physics } } class Chemistry: Subjects { var equations: String init(physics: String, equations: String) { self.equations = equations super.init(physics: physics) } } class Maths: Subjects { var formulae: String init(physics: String, formulae: String) { self.formulae = formulae super.init(physics: physics) } } let saprint: [AnyObject] = [Chemistry(physics: "solid physics", equations: "Hertz"), Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz"), Chemistry(physics: "Thermo physics", equations: "Decibels"), Maths(physics: "Astro Physics", formulae: "MegaHertz"), Maths(physics: "Differential Equations", formulae: "Cosine Series")] let samplechem = Chemistry(physics: "solid physics", equations: "Hertz") println("Instance physics is: \(samplechem.physics)") println("Instance equation is: \(samplechem.equations)") let samplemaths = Maths(physics: "Fluid Dynamics", formulae: "Giga Hertz") println("Instance physics is: \(samplemaths.physics)") println("Instance formulae is: \(samplemaths.formulae)") var chemCount = 0 var mathsCount = 0 for item in saprint { if let print = item as? Chemistry { println("Chemistry topics are: '\(print.physics)', \(print.equations)") }else if let example = item as? Maths { println("Maths topics are: '\(example.physics)', \(example.formulae)") } } var exampleany = [Any]() exampleany.append(12) exampleany.append(3.14159) exampleany.append("Example for Any") exampleany.append(Chemistry(physics: "solid physics", equations: "Hertz")) for print in exampleany { switch print { case let someInt as Int: println("Integer value is \(someInt)") case let someDouble as Double where someDouble > 0: println("Pi value is \(someDouble)") case let someString as String: println("\(someString)") case let phy as Chemistry: println("Topics '\(phy.physics)', \(phy.equations)") default: println("None") } }

When we run the above program using playground, we get the following result −

Instance physics is: solid physics
Instance equation is: Hertz
Instance physics is: Fluid Dynamics
Instance formulae is: Giga Hertz
Chemistry topics are: 'solid physics', Hertz
Maths topics are: 'Fluid Dynamics', Giga Hertz
Chemistry topics are: 'Thermo physics', Decibels
Maths topics are: 'Astro Physics', MegaHertz
Maths topics are: 'Differential Equations', Cosine Series
Integer value is 12
Pi value is 3.14159
Example for Any
Topics 'solid physics', Hertz

30 - SWIFT EXTENSIONS

Functionality of an existing class, structure or enumeration type can be added with the help of extensions. Type functionality can be added with extensions but overriding the functionality is not possible with extensions.

Swift Extension Functionalities −

---

• Adding computed properties and computed type properties.
• Defining instance and type methods.
• Providing new initializers.
• Defining subscripts.
• Defining and using new nested types.
• Making an existing type conform to a protocol.

Extensions are declared with the keyword 'extension'.

Syntax

extension SomeType { // new functionality can be added here }

Existing type can also be added with extensions to make it as a protocol standard and its syntax is similar to that of classes or structures.

extension SomeType: SomeProtocol, AnotherProtocol { // protocol requirements is described here }

Computed 'instance' and 'type' properties can also be extended with the help of extensions.

---

Computed 'instance' and 'type' properties can also be extended with the help of extensions.

extension Int { var add: Int {return self + 100 } var sub: Int { return self - 10 } var mul: Int { return self * 10 } var div: Int { return self / 5 } } let addition = 3.add println("Addition is \(addition)") let subtraction = 120.sub println("Subtraction is \(subtraction)") let multiplication = 39.mul println("Multiplication is \(multiplication)") let division = 55.div println("Division is \(division)") let mix = 30.add + 34.sub println("Mixed Type is \(mix)")

When we run the above program using playground, we get the following result −

Addition is 103
Subtraction is 110
Multiplication is 390
Division is 11
Mixed Type is 154

Initializers

---

Swift provides the flexibility to add new initializers to an existing type by extensions. The user can add their own custom types to extend the types already defined and additional initialization options are also possible. Extensions supports only init(). deinit() is not supported by the extensions.

struct sum { var num1 = 100, num2 = 200 } struct diff { var no1 = 200, no2 = 100 } struct mult { var a = sum() var b = diff() } let calc = mult() println ("Inside mult block \(calc.a.num1, calc.a.num2)") println("Inside mult block \(calc.b.no1, calc.b.no2)") let memcalc = mult(a: sum(num1: 300, num2: 500),b: diff(no1: 300, no2: 100)) println("Inside mult block \(memcalc.a.num1, memcalc.a.num2)") println("Inside mult block \(memcalc.b.no1, memcalc.b.no2)") extension mult { init(x: sum, y: diff) { let X = x.num1 + x.num2 let Y = y.no1 + y.no2 } } let a = sum(num1: 100, num2: 200) println("Inside Sum Block:\( a.num1, a.num2)") let b = diff(no1: 200, no2: 100) println("Inside Diff Block: \(b.no1, b.no2)")

When we run the above program using playground, we get the following result −

Inside mult block (100, 200)
Inside mult block (200, 100)
Inside mult block (300, 500)
Inside mult block (300, 100)
Inside Sum Block:(100, 200)
Inside Diff Block: (200, 100)

Methods

---

New instance methods and type methods can be added further to the subclass with the help of extensions.

extension Int { func topics(summation: () -> ()) { for _ in 0..<self { summation() } } } 4.topics({ println("Inside Extensions Block") }) 3.topics({ println("Inside Type Casting Block") })

When we run the above program using playground, we get the following result −

Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Extensions Block
Inside Type Casting Block
Inside Type Casting Block
Inside Type Casting Block

topics() function takes argument of type '(summation: () → ())' to indicate the function does not take any arguments and it won't return any values. To call that function multiple number of times, for block is initialized and call to the method with topic() is initialized.

Mutating Instance Methods

---

Instance methods can also be mutated when declared as extensions.

Structure and enumeration methods that modify self or its properties must mark the instance method as mutating, just like mutating methods from an original implementation.

extension Double { mutating func square() { let pi = 3.1415 self = pi * self * self } } var Trial1 = 3.3 Trial1.square() println("Area of circle is: \(Trial1)") var Trial2 = 5.8 Trial2.square() println("Area of circle is: \(Trial2)") var Trial3 = 120.3 Trial3.square() println("Area of circle is: \(Trial3)")

When we run the above program using playground, we get the following result −

Area of circle is: 34.210935
Area of circle is: 105.68006
Area of circle is: 45464.070735

Subscripts

---

Adding new subscripts to already declared instances can also be possible with extensions.

extension Int { subscript(var multtable: Int) -> Int { var no1 = 1 while multtable > 0 { no1 *= 10 --multtable } return (self / no1) % 10 } } println(12[0]) println(7869[1]) println(786543[2])

When we run the above program using playground, we get the following result −

2
6
5

Nested Types

---

Nested types for class, structure and enumeration instances can also be extended with the help of extensions.

extension Int { enum calc { case add case sub case mult case div case anything } var print: calc { switch self { case 0: return .add case 1: return .sub case 2: return .mult case 3: return .div default: return .anything } } } func result(numb: [Int]) { for i in numb { switch i.print { case .add: println(" 10 ") case .sub: println(" 20 ") case .mult: println(" 30 ") case .div: println(" 40 ") default: println(" 50 ") } } } result([0, 1, 2, 3, 4, 7])

When we run the above program using playground, we get the following result −

20
30
40
50
50

31 - SWIFT PROTOCOLS

Protocols provide a blueprint for Methods, properties and other requirements functionality. It is just described as a methods or properties skeleton instead of implementation. Methods and properties implementation can further be done by defining classes, functions and enumerations. Conformance of a protocol is defined as the methods or properties satisfying the requirements of the protocol.

Syntax

Protocols also follow the similar syntax as that of classes, structures, and enumerations −

protocol SomeProtocol { // protocol definition }

Protocols are declared after the class, structure or enumeration type names. Single and Multiple protocol declarations are also possible. If multiple protocols are defined they have to be separated by commas.

struct SomeStructure: Protocol1, Protocol2 { // structure definition }

When a protocol has to be defined for super class, the protocol name should follow the super class name with a comma.

class SomeClass: SomeSuperclass, Protocol1, Protocol2 { // class definition }

Property and Method Requirements

---

Protocol is used to specify particular class type property or instance property. It just specifies the type or instance property alone rather than specifying whether it is a stored or computed property. Also, it is used to specify whether the property is 'gettable' or 'settable'.

Property requirements are declared by 'var' keyword as property variables. {get set} is used to declare gettable and settable properties after their type declaration. Gettable is mentioned by {get} property after their type declaration.

protocol classa { var marks: Int { get set } var result: Bool { get } func attendance() -> String func markssecured() -> String } protocol classb: classa { var present: Bool { get set } var subject: String { get set } var stname: String { get set } } class classc: classb { var marks = 96 let result = true var present = false var subject = "Swift Protocols" var stname = "Protocols" func attendance() -> String { return "The \(stname) has secured 99% attendance" } func markssecured() -> String { return "\(stname) has scored \(marks)" } } let studdet = classc() studdet.stname = "Swift" studdet.marks = 98 studdet.markssecured() println(studdet.marks) println(studdet.result) println(studdet.present) println(studdet.subject) println(studdet.stname)

When we run the above program using playground, we get the following result −

98
true
false
Swift Protocols
Swift

Mutating Method Requirements

---

protocol daysofaweek { mutating func print() } enum days: daysofaweek { case sun, mon, tue, wed, thurs, fri, sat mutating func print() { switch self { case sun: self = sun println("Sunday") case mon: self = mon println("Monday") case tue: self = tue println("Tuesday") case wed: self = wed println("Wednesday") case mon: self = thurs println("Thursday") case tue: self = fri println("Friday") case sat: self = sat println("Saturday") default: println("NO Such Day") } } } var res = days.wed res.print()

When we run the above program using playground, we get the following result −

Wednesday

Initializer Requirements

---

Swing allows the user to initialize protocols to follow type conformance similar to that of normal initializers.

Syntax

protocol SomeProtocol { init(someParameter: Int) }

For example

protocol tcpprotocol { init(aprot: Int) }

Class Implementations of Protocol Initializer Requirements

---

Designated or convenience initializer allows the user to initialize a protocol to conform its standard by the reserved 'required' keyword.

class SomeClass: SomeProtocol { required init(someParameter: Int) { // initializer implementation statements } } protocol tcpprotocol { init(aprot: Int) } class tcpClass: tcpprotocol { required init(aprot: Int) {} }

Protocol conformance is ensured on all subclasses for explicit or inherited implementation by 'required' modifier.

When a subclass overrides its super class initialization requirement it is specified by the 'override' modifier keyword.

protocol tcpprotocol { init(no1: Int) } class mainClass { var no1: Int // local storage init(no1: Int) { self.no1 = no1 // initialization } } class subClass: mainClass, tcpprotocol { var no2: Int init(no1: Int, no2 : Int) { self.no2 = no2 super.init(no1:no1) } // Requires only one parameter for convenient method required override convenience init(no1: Int) { self.init(no1:no1, no2:0) } } let res = mainClass(no1: 20) let print = subClass(no1: 30, no2: 50) println("res is: \(res.no1)") println("res is: \(print.no1)") println("res is: \(print.no2)")

When we run the above program using playground, we get the following result −

res is: 20 res is: 30 res is: 50

Protocols as Types

---

Instead of implementing functionalities in a protocol they are used as types for functions, classes, methods etc.

Protocols can be accessed as types in −

• Function, method or initialize as a parameter or return type.
• Constant, variable or property.
• Arrays, dictionaries or other containers as items.

protocol Generator { typealias members func next() -> members? } var items = [10,20,30].generate() while let x = items.next() { println(x) } for lists in map([1,2,3], {i in i*5}) { println(lists) } println([100,200,300]) println(map([1,2,3], {i in i*10}))

When we run the above program using playground, we get the following result −

10
20
30
5
10
15
[100, 200, 300]
[10, 20, 30]

Adding Protocol Conformance with an Extension

---

Existing type can be adopted and conformed to a new protocol by making use of extensions. New properties, methods and subscripts can be added to existing types with the help of extensions.

protocol AgeClasificationProtocol { var age: Int { get } func agetype() -> String } class Person { let firstname: String let lastname: String var age: Int init(firstname: String, lastname: String) { self.firstname = firstname self.lastname = lastname self.age = 10 } } extension Person : AgeClasificationProtocol { func fullname() -> String { var c: String c = firstname + " " + lastname return c } func agetype() -> String { switch age { case 0...2: return "Baby" case 2...12: return "Child" case 13...19: return "Teenager" case let x where x > 65: return "Elderly" default: return "Normal" } } }

Protocol Inheritance

---

Swift allows protocols to inherit properties from its defined properties. It is similar to that of class inheritance, but with the choice of listing multiple inherited protocols separated by commas.

protocol classa { var no1: Int { get set } func calc(sum: Int) } protocol result { func print(target: classa) } class student2: result { func print(target: classa) { target.calc(1) } } class classb: result { func print(target: classa) { target.calc(5) } } class student: classa { var no1: Int = 10 func calc(sum: Int) { no1 -= sum println("Student attempted \(sum) times to pass") if no1 <= 0 { println("Student is absent for exam") } } } class Player { var stmark: result! init(stmark: result) { self.stmark = stmark } func print(target: classa) { stmark.print(target) } } var marks = Player(stmark: student2()) var marksec = student() marks.print(marksec) marks.print(marksec) marks.print(marksec) marks.stmark = classb() marks.print(marksec) marks.print(marksec) marks.print(marksec)

When we run the above program using playground, we get the following result −

Student attempted 1 times to pass
Student attempted 1 times to pass
Student attempted 1 times to pass
Student attempted 5 times to pass
Student attempted 5 times to pass
Student is absent for exam
Student attempted 5 times to pass
Student is absent for exam

Class Only Protocols

---

When protocols are defined and the user wants to define protocol with classes it should be added by defining class first followed by protocol's inheritance list.

protocol tcpprotocol { init(no1: Int) } class mainClass { var no1: Int // local storage init(no1: Int) { self.no1 = no1 // initialization } } class subClass: mainClass, tcpprotocol { var no2: Int init(no1: Int, no2 : Int) { self.no2 = no2 super.init(no1:no1) } // Requires only one parameter for convenient method required override convenience init(no1: Int) { self.init(no1:no1, no2:0) } } let res = mainClass(no1: 20) let print = subClass(no1: 30, no2: 50) println("res is: \(res.no1)") println("res is: \(print.no1)") println("res is: \(print.no2)")

When we run the above program using playground, we get the following result −

res is: 20
res is: 30
res is: 50

Protocol Composition

---

Swift allows multiple protocols to be called at once with the help of protocol composition.

Syntax

protocol<SomeProtocol, AnotherProtocol>

Example

protocol stname { var name: String { get } } protocol stage { var age: Int { get } } struct Person: stname, stage { var name: String var age: Int } func print(celebrator: protocol<stname, stage>) { println("\(celebrator.name) is \(celebrator.age) years old") } let studname = Person(name: "Priya", age: 21) print(studname) let stud = Person(name: "Rehan", age: 29) print(stud) let student = Person(name: "Roshan", age: 19) print(student)

When we run the above program using playground, we get the following result −

Priya is 21 years old
Rehan is 29 years old
Roshan is 19 years old

Checking for Protocol Conformance

---

Protocol conformance is tested by 'is' and 'as' operators similar to that of type casting.

• The is operator returns true if an instance conforms to protocol standard and returns false if it fails.
• The as? version of the downcast operator returns an optional value of the protocol's type, and this value is nil if the instance does not conform to that protocol.
• The as version of the downcast operator forces the downcast to the protocol type and triggers a runtime error if the downcast does not succeed.

import Foundation @objc protocol rectangle { var area: Double { get } } @objc class Circle: rectangle { let pi = 3.1415927 var radius: Double var area: Double { return pi * radius * radius } init(radius: Double) { self.radius = radius } } @objc class result: rectangle { var area: Double init(area: Double) { self.area = area } } class sides { var rectsides: Int init(rectsides: Int) { self.rectsides = rectsides } } let objects: [AnyObject] = [Circle(radius: 2.0),result(area: 198),sides(rectsides: 4)] for object in objects { if let objectWithArea = object as? rectangle { println("Area is \(objectWithArea.area)") } else { println("Rectangle area is not defined") } }

When we run the above program using playground, we get the following result −

Area is 12.5663708
Area is 198.0
Rectangle area is not defined

32 - SWIFT GENERICS

Swift language provides 'Generic' features to write flexible and reusable functions and types. Generics are used to avoid duplication and to provide abstraction. Swift standard libraries are built with generics code. Swifts 'Arrays' and 'Dictionary' types belong to generic collections. With the help of arrays and dictionaries the arrays are defined to hold 'Int' values and 'String' values or any other types.

func exchange(inout a: Int, inout b: Int) { let temp = a a = b b = temp } var numb1 = 100 var numb2 = 200 println("Before Swapping values are: \(numb1) and \(numb2)") exchange(&numb1, &numb2) println("After Swapping values are: \(numb1) and \(numb2)")

When we run the above program using playground, we get the following result −

Before Swapping values are: 100 and 200
After Swapping values are: 200 and 100

Generic Functions: Type Parameters

---

Generic functions can be used to access any data type like 'Int' or 'String'.

func exchange<T>(inout a: T, inout b: T) { let temp = a a = b b = temp } var numb1 = 100 var numb2 = 200 println("Before Swapping Int values are: \(numb1) and \(numb2)") exchange(&numb1, &numb2) println("After Swapping Int values are: \(numb1) and \(numb2)") var str1 = "Generics" var str2 = "Functions" println("Before Swapping String values are: \(str1) and \(str2)") exchange(&str1, &str2) println("After Swapping String values are: \(str1) and \(str2)")

When we run the above program using playground, we get the following result −

Before Swapping Int values are: 100 and 200
After Swapping Int values are: 200 and 100
Before Swapping String values are: Generics and Functions
After Swapping String values are: Functions and Generics

The function exchange() is used to swap values which is described in the above program and <T> is used as a type parameter. For the first time, function exchange() is called to return 'Int' values and second call to the function exchange() will return 'String' values. Multiple parameter types can be included inside the angle brackets separated by commas.

Type parameters are named as user defined to know the purpose of the type parameter that it holds. Swift provides <T> as generic type parameter name. However type parameters like Arrays and Dictionaries can also be named as key, value to identify that they belong to type 'Dictionary'.

Generic Types

---

struct TOS<T> { var items = [T]() mutating func push(item: T) { items.append(item) } mutating func pop() -> T { return items.removeLast() } } var tos = TOS<String>() tos.push("Swift") println(tos.items) tos.push("Generics") println(tos.items) tos.push("Type Parameters") println(tos.items) tos.push("Naming Type Parameters") println(tos.items) let deletetos = tos.pop()

When we run the above program using playground, we get the following result −

[Swift]
[Swift, Generics]
[Swift, Generics, Type Parameters]
[Swift, Generics, Type Parameters, Naming Type Parameters]

Extending a Generic Type

---

Extending the stack property to know the top of the item is included with 'extension' keyword.

struct TOS<T> { var items = [T]() mutating func push(item: T) { items.append(item) } mutating func pop() -> T { return items.removeLast() } } var tos = TOS<String>() tos.push("Swift") println(tos.items) tos.push("Generics") println(tos.items) tos.push("Type Parameters") println(tos.items) tos.push("Naming Type Parameters") println(tos.items) extension TOS { var first: T? { return items.isEmpty ? nil : items[items.count - 1] } } if let first = tos.first { println("The top item on the stack is \(first).") }

When we run the above program using playground, we get the following result −

[Swift]
[Swift, Generics]
[Swift, Generics, Type Parameters]
[Swift, Generics, Type Parameters, Naming Type Parameters]
The top item on the stack is Naming Type Parameters.

The top item on the stack is Naming Type Parameters.

Type Constraints

---

Swift language allows 'type constraints' to specify whether the type parameter inherits from a specific class, or to ensure protocol conformance standard.

unc exchange<T>(inout a: T, inout b: T) { let temp = a a = b b = temp } var numb1 = 100 var numb2 = 200 println("Before Swapping Int values are: \(numb1) and \(numb2)") exchange(&numb1, &numb2) println("After Swapping Int values are: \(numb1) and \(numb2)") var str1 = "Generics" var str2 = "Functions" println("Before Swapping String values are: \(str1) and \(str2)") exchange(&str1, &str2) println("After Swapping String values are: \(str1) and \(str2)")

When we run the above program using playground, we get the following result −

Before Swapping Int values are: 100 and 200
After Swapping Int values are: 200 and 100
Before Swapping String values are: Generics and Functions
After Swapping String values are: Functions and Generics

Associated Types

---

Swift allows associated types to be declared inside the protocol definition by the keyword 'typealias'.

protocol Container { typealias ItemType mutating func append(item: ItemType) var count: Int { get } subscript(i: Int) -> ItemType { get } } struct TOS<T>: Container { // original Stack<T> implementation var items = [T]() mutating func push(item: T) { items.append(item) } mutating func pop() -> T { return items.removeLast() } // conformance to the Container protocol mutating func append(item: T) { self.push(item) } var count: Int { return items.count } subscript(i: Int) -> T { return items[i] } } var tos = TOS<String>() tos.push("Swift") println(tos.items) tos.push("Generics") println(tos.items) tos.push("Type Parameters") println(tos.items) tos.push("Naming Type Parameters") println(tos.items)

When we run the above program using playground, we get the following result −

[Swift]
[Swift, Generics]
[Swift, Generics, Type Parameters]
[Swift, Generics, Type Parameters, Naming Type Parameters]

Where Clauses

---

Type constraints enable the user to define requirements on the type parameters associated with a generic function or type. For defining requirements for associated types 'where' clauses are declared as part of type parameter list. 'where' keyword is placed immediately after the list of type parameters followed by constraints of associated types, equality relationships between types and associated types.

protocol Container { typealias ItemType mutating func append(item: ItemType) var count: Int { get } subscript(i: Int) -> ItemType { get } } struct Stack<T>: Container { // original Stack<T> implementation var items = [T]() mutating func push(item: T) { items.append(item) } mutating func pop() -> T { return items.removeLast() } // conformance to the Container protocol mutating func append(item: T) { self.push(item) } var count: Int { return items.count } subscript(i: Int) -> T { return items[i] } } func allItemsMatch< C1: Container, C2: Container where C1.ItemType == C2.ItemType, C1.ItemType: Equatable> (someContainer: C1, anotherContainer: C2) -> Bool { // check that both containers contain the same number of items if someContainer.count != anotherContainer.count { return false } // check each pair of items to see if they are equivalent for i in 0..<someContainer.count { if someContainer[i] != anotherContainer[i] { return false } } // all items match, so return true return true } var tos = Stack<String>() tos.push("Swift") println(tos.items) tos.push("Generics") println(tos.items) tos.push("Where Clause") println(tos.items) var eos = ["Swift", "Generics", "Where Clause"] println(eos)

When we run the above program using playground, we get the following result −

[Swift]
[Swift, Generics]
[Swift, Generics, Where Clause]
[Swift, Generics, Where Clause]

33 - SWIFT ACCESS CONTROL

To restrict access to code blocks, modules and abstraction is done through access control. Classes, structures and enumerations can be accessed according to their properties, methods, initializers and subscripts by access control mechanisms. Constants, variables and functions in a protocol are restricted and allowed access as global and local through access control. Access control applied to properties, types and functions can be referred as 'entities'.

Access control model is based on modules and source files.

Module is defined as a single unit of code distribution and can be imported using the keyword 'import'. A source file is defined as a single source code file with in a module to access multiple types and functions.

Three different access levels are provided by Swift language. They are Public, Internal and Private access.

S.No	Access Levels & Definition
1	Public Enables entities to be processed with in any source file from their defining module, a source file from another module that imports the defining module.
2	Internal Enables entities to be used within any source file from their defining module, but not in any source file outside of that module.
3	Private Restricts the use of an entity to its own defining source file. Private access plays role to hide the implementation details of a specific code functionality.

Syntax

public class SomePublicClass {} internal class SomeInternalClass {} private class SomePrivateClass {} public var somePublicVariable = 0 internal let someInternalConstant = 0 private func somePrivateFunction() {}

Access Control for Function types

---

Some functions may have arguments declared inside the function without any return values. The following program declares a and b as arguments to the sum() function. Inside the function itself the values for arguments a and b are passed by invoking the function call sum() and its values are printed thereby eliminating return values. To make the function's return type as private, declare the function's overall access level with the private modifier.

private func sum(a: Int, b: Int) { let a = a + b let b = a - b println(a, b) } sum(20, 10) sum(40,10) sum(24,6)

When we run the above program using playground, we get the following result −

(30, 20)
(50, 40)
(30, 24)

Access Control for Enumeration types

---

public enum Student { case Name(String) case Mark(Int,Int,Int) } var studDetails = Student.Name("Swift") var studMarks = Student.Mark(98,97,95) switch studMarks { case .Name(let studName): println("Student name is: \(studName).") case .Mark(let Mark1, let Mark2, let Mark3): println("Student Marks are: \(Mark1),\(Mark2),\(Mark3).") default: println("Nothing") }

When we run the above program using playground, we get the following result −

Student Marks are: 98,97,95

Enumeration in Swift language automatically receive the same access level for individual cases of an enumeration. Consider for example to access the students name and marks secured in three subjects enumeration name is declared as student and the members present in enum class are name which belongs to string datatype, marks are represented as mark1, mark2 and mark3 of datatype Integer. To access either the student name or marks they have scored. Now, the switch case will print student name if that case block is executed otherwise it will print the marks secured by the student. If both condition fails the default block will be executed.

Access Control for SubClasses

---

Swift allows the user to subclass any class that can be accessed in the current access context. A subclass cannot have a higher access level than its superclass. The user is restricted from writing a public subclass of an internal superclass.

public class cricket { private func print() { println("Welcome to Swift Super Class") } } internal class tennis: cricket { override internal func print() { println("Welcome to Swift Sub Class") } } let cricinstance = cricket() cricinstance.print() let tennisinstance = tennis() tennisinstance.print()

When we run the above program using playground, we get the following result −

Welcome to Swift Super Class
Welcome to Swift Sub Class

Access Control for Constants, variables, properties and subscripts

---

Swift constant, variable, or property cannot be defined as public than its type. It is not valid to write a public property with a private type. Similarly, a subscript cannot be more public than its index or return type.

When a constant, variable, property, or subscript makes use of a private type, the constant, variable, property, or subscript must also be marked as private −

private var privateInstance = SomePrivateClass()

Getters and Setters

---

Getters and setters for constants, variables, properties, and subscripts automatically receive the same access level as the constant, variable, property, or subscript they belong to.

class Samplepgm { private var counter: Int = 0 { willSet(newTotal) { println("Total Counter is: \(newTotal)") } didSet{ if counter > oldValue { println("Newly Added Counter \(counter - oldValue)") } } } } let NewCounter = Samplepgm() NewCounter.counter = 100 NewCounter.counter = 800

When we run the above program using playground, we get the following result −

Total Counter is: 100
Newly Added Counter 100
Total Counter is: 800
Newly Added Counter 700

Access Control for Initializers and Default Initializers

---

Custom initializers can be assigned an access level less than or equal to the type that they initialize. A required initializer must have the same access level as the class it belongs to. The types of an initializer's parameters cannot be more private than the initializer's own access level.

To declare each and every subclass of the initialize 'required' keyword needs to be defined before the init() function.

class classA { required init() { var a = 10 println(a) } } class classB: classA { required init() { var b = 30 println(b) } } let res = classA() let print = classB()

When we run the above program using playground, we get the following result −

10
30
10

A default initializer has the same access level as the type it initializes, unless that type is defined as public. When default initialize is defined as public it is considered internal. When the user needs a public type to be initializable with a no-argument initializer in another module, provide explicitly a public no-argument initializer as part of the type's definition.

Access Control for Protocols

---

When we define a new protocol to inherit functionalities from an existing protocol, both has to be declared the same access levels to inherit the properties of each other. Swift access control won't allow the users to define a 'public' protocol that inherits from an 'internal' protocol.

public protocol tcpprotocol { init(no1: Int) } public class mainClass { var no1: Int // local storage init(no1: Int) { self.no1 = no1 // initialization } } class subClass: mainClass, tcpprotocol { var no2: Int init(no1: Int, no2 : Int) { self.no2 = no2 super.init(no1:no1) } // Requires only one parameter for convenient method required override convenience init(no1: Int) { self.init(no1:no1, no2:0) } } let res = mainClass(no1: 20) let print = subClass(no1: 30, no2: 50) println("res is: \(res.no1)") println("res is: \(print.no1)") println("res is: \(print.no2)")

When we run the above program using playground, we get the following result −

res is: 20
res is: 30
res is: 50

Access Control for Extensions

---

Swift does not allow the users to provide an explicit access level modifier for an extension when the user uses that extension to add protocol conformance. The default access level for each protocol requirement implementation within the extension is provided with its own protocol access level.

Access Control for Generics

---

Generics allow the user to specify minimum access levels to access the type constraints on its type parameters.

public struct TOS<T> { var items = [T]() private mutating func push(item: T) { items.append(item) } mutating func pop() -> T { return items.removeLast() } } var tos = TOS<String>() tos.push("Swift") println(tos.items) tos.push("Generics") println(tos.items) tos.push("Type Parameters") println(tos.items) tos.push("Naming Type Parameters") println(tos.items) let deletetos = tos.pop()

When we run the above program using playground, we get the following result −

[Swift]
[Swift, Generics]
[Swift, Generics, Type Parameters]
[Swift, Generics, Type Parameters, Naming Type Parameters]

Access Control for Type Aliases

---

The user can define type aliases to treat distinct access control types. Same access level or different access levels can be defined by the user. When type alias is 'private' its associated members can be declared as 'private, internal of public type'. When type alias is public the members cannot be alias as an 'internal' or 'private' name

Any type aliases you define are treated as distinct types for the purposes of access control. A type alias can have an access level less than or equal to the access level of the type it aliases. For example, a private type alias can alias a private, internal, or public type, but a public type alias cannot alias an internal or private type.

public protocol Container { typealias ItemType mutating func append(item: ItemType) var count: Int { get } subscript(i: Int) -> ItemType { get } } struct Stack<T>: Container { // original Stack<T> implementation var items = [T]() mutating func push(item: T) { items.append(item) } mutating func pop() -> T { return items.removeLast() } // conformance to the Container protocol mutating func append(item: T) { self.push(item) } var count: Int { return items.count } subscript(i: Int) -> T { return items[i] } } func allItemsMatch< C1: Container, C2: Container where C1.ItemType == C2.ItemType, C1.ItemType: Equatable> (someContainer: C1, anotherContainer: C2) -> Bool { // check that both containers contain the same number of items if someContainer.count != anotherContainer.count { return false } // check each pair of items to see if they are equivalent for i in 0..<someContainer.count { if someContainer[i] != anotherContainer[i] { return false } } // all items match, so return true return true } var tos = Stack<String>() tos.push("Swift") println(tos.items) tos.push("Generics") println(tos.items) tos.push("Where Clause") println(tos.items) var eos = ["Swift", "Generics", "Where Clause"] println(eos)

When we run the above program using playground, we get the following result −

[Swift]
[Swift, Generics]
[Swift, Generics, Where Clause]
[Swift, Generics, Where Clause]

1 - OBJ-C OVERVIEW

Objective-C is general-purpose language that is developed on top of C Programming language by adding features of Small Talk programming language making it an object-oriented language. It is primarily used in developing iOS and Mac OS X operating systems as well as its applications.

Initially, Objective-C was developed by NeXT for its NeXTSTEP OS from whom it was taken over by Apple for its iOS and Mac OS X.

Object-Oriented Programming

---

Fully supports object-oriented programming, including the four pillars of object-oriented development:

• Encapsulation
• Data hiding
• Inheritance
• Polymorphism

Example Code

---

#import <Foundation/Foundation.h> int main (int argc, const char * argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSLog (@"hello world"); [pool drain]; return 0; }

Foundation Framework

---

Foundation Framework provides large set of features and they are listed below.

• It includes a list of extended datatypes like NSArray, NSDictionary, NSSet and so on.
• It consists of a rich set of functions manipulating files, strings, etc.
• It provides features for URL handling, utilities like date formatting, data handling, error handling, etc.

Learning Objective-C

---

The most important thing to do when learning Objective-C is to focus on concepts and not get lost in language technical details.

The purpose of learning a programming language is to become a better programmer; that is, to become more effective at designing and implementing new systems and at maintaining old ones.

Use of Objective-C

---

Objective-C, as mentioned earlier, is used in iOS and Mac OS X. It has large base of iOS users and largely increasing Mac OS X users. And since Apple focuses on quality first and its wonderful for those who started learning Objective-C.

2 - OBJ-C ENVIRONMENT SETUP

Try it Option Online

---

You really do not need to set up your own environment to start learning Objective-C programming language. Reason is very simple, we already have set up Objective-C Programming environment online, so that you can compile and execute all the available examples online at the same time when you are doing your theory work. This gives you confidence in what you are reading and to check the result with different options. Feel free to modify any example and execute it online.

Try the following example using Try it option available at the top right corner of the below sample code box:

#import <Foundation/Foundation.h> int main() { /* my first program in Objective-C */ NSLog(@"Hello, World! \n"); return 0; }

For most of the examples given in this tutorial, you will find Try it option, so just make use of it and enjoy your learning.

Local Environment Setup

---

If you are still willing to set up your environment for Objective-C programming language, you need the following two softwares available on your computer, (a) Text Editor and (b) The GCC Compiler.

Text Editor

---

This will be used to type your program. Examples of few editors include Windows Notepad, OS Edit command, Brief, Epsilon, EMACS, and vim or vi.

Name and version of text editor can vary on different operating systems. For example, Notepad will be used on Windows, and vim or vi can be used on windows as well as Linux or UNIX.

The files you create with your editor are called source files and contain program source code. The source files for Objective-C programs are typically named with the extension ".m".

Before starting your programming, make sure you have one text editor in place and you have enough experience to write a computer program, save it in a file, compile it and finally execute it.

The GCC Compiler

---

The source code written in source file is the human readable source for your program. It needs to be "compiled" to turn into machine language, so that your CPU can actually execute the program as per instructions given.

This GCC compiler will be used to compile your source code into final executable program. I assume you have basic knowledge about a programming language compiler.

GCC compiler is available for free on various platforms and the procedure to set up on various platforms is explained below.

<3>Installation on UNIX/Linux

The initial step is install gcc along with gcc Objective-C package. This is done by:

$ su - $ yum install gcc $ yum install gcc-objc

The next step is to set up package dependencies using following command:

$ yum install make libpng libpng-devel libtiff libtiff-devel libobjc libxml2 libxml2-devel libX11-devel libXt-devel libjpeg libjpeg-devel

In order to get full features of Objective-C, download and install GNUStep. This can be done by downloading the package from

Now, we need to switch to the downloaded folder and unpack the file by:

$ tar xvfz gnustep-startup-.tar.gz

Now, we need to switch to the folder gnustep-startup that gets created using:

$ cd gnustep-startup-

Next, we need to configure the build process:

$ ./configure

Then, we can build by:

$ make

We need to finally set up the environment by:

$ . /usr/GNUstep/System/Library/Makefiles/GNUstep.sh

We have a helloWorld.m Objective-C as follows:

#import <Foundation/Foundation.h> int main (int argc, const char * argv[]) { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; NSLog (@"hello world"); [pool drain]; return 0; }

Now, we can compile and run a Objective-C file say helloWorld.m by switching to folder containing the file using cd and then using the following steps:

$ gcc `gnustep-config --objc-flags` -L/usr/GNUstep/Local/Library/Libraries -lgnustep-base helloWorld.m -o helloWorld $ ./helloWorld

We can see the following output:

2013-09-07 10:48:39.772 tutorialsPoint[12906] hello world

Installation on Mac OS

---

If you use Mac OS X, the easiest way to obtain GCC is to download the Xcode development environment from Apple's web site and follow the simple installation instructions. Once you have Xcode set up, you will be able to use GNU compiler for C/C++.

Xcode is currently available at developer.apple.com/technologies/tools/.

Installation on Windows

---

In order to run Objective-C program on windows, we need to install MinGW and GNUStep Core. Both are available at


First, we need to install the MSYS/MinGW System package. Then, we need to install the GNUstep Core package. Both of which provide a windows installer, which is self-explanatory.

Then to use Objective-C and GNUstep by selecting Start -> All Programs -> GNUstep -> Shell

Switch to the folder containing helloWorld.m

We can compile the program by using:

$ gcc `gnustep-config --objc-flags` -L /GNUstep/System/Library/Libraries hello.m -o hello -lgnustep-base -lobjc

We can run the program by using:

./hello.exe

We get the following output:

2013-09-07 10:48:39.772 tutorialsPoint[1200] hello world

3 - OBJ-C PROGRAM STRUCTURE

Before we study basic building blocks of the Objective-C programming language, let us look a bare minimum Objective-C program structure so that we can take it as a reference in upcoming chapters.

Objective-C Hello World Example

---

A Objective-C program basically consists of the following parts:

Preprocessor Commands

Interface

Implementation

Method

Variables

Statements & Expressions

Comments

Let us look at a simple code that would print the words "Hello World":

#import <Foundation/Foundation.h> @interface SampleClass:NSObject - (void)sampleMethod; @end @implementation SampleClass - (void)sampleMethod{ NSLog(@"Hello, World! \n"); } @end int main() { /* my first program in Objective-C */ SampleClass *sampleClass = [[SampleClass alloc]init]; [sampleClass sampleMethod]; return 0; }

Let us look various parts of the above program:

• The first line of the program #import <Foundation/Foundation.h> is a preprocessor command, which tells a Objective-C compiler to include Foundation.h file before going to actual compilation.
• The next line @interface SampleClass:NSObject shows how to create an interface. It inherits NSObject, which is the base class of all objects.
• The next line - (void)sampleMethod; shows how to declare a method.
• The next line @end marks the end of an interface.
• The next line @implementation SampleClass shows how to implement the interface SampleClass.
• The next line - (void)sampleMethod{} shows the implementation of the sampleMethod.
• The next line @end marks the end of an implementation.
• The next line int main() is the main function where program execution begins.
• The next line /*...*/ will be ignored by the compiler and it has been put to add additional comments in the program. So such lines are called comments in the program.
• The next line NSLog(...) is another function available in Objective-C which causes the message "Hello, World!" to be displayed on the screen.
• The next line return 0; terminates main()function and returns the value 0.

Now when we compile and run the program, we will get the following result.

2013-09-07 22:38:27.932 demo[28001] Hello, World!

4 - OBJ-C BASIC SYNTAX

You have seen a basic structure of Objective-C program, so it will be easy to understand other basic building blocks of the Objective-C programming language.

Tokens in Objective-C

---

A Objective-C program consists of various tokens and a token is either a keyword, an identifier, a constant, a string literal, or a symbol. For example, the following Objective-C statement consists of six tokens:

NSLog(@"Hello, World! \n");

The individual tokens are:

NSLog @ ( "Hello, World! \n" ) ;

Semicolons ;

---

In Objective-C program, the semicolon is a statement terminator. That is, each individual statement must be ended with a semicolon. It indicates the end of one logical entity.

For example, following are two different statements:

NSLog(@"Hello, World! \n"); return 0;

Comments

---

Comments are like helping text in your Objective-C program and they are ignored by the compiler. They start with /* and terminate with the characters */ as shown below:

/* my first program in Objective-C */

You can not have comments with in comments and they do not occur within a string or character literals.

Identifiers

---

An Objective-C identifier is a name used to identify a variable, function, or any other user-defined item. An identifier starts with a letter A to Z or a to z or an underscore _ followed by zero or more letters, underscores, and digits (0 to 9).

Objective-C does not allow punctuation characters such as @, $, and % within identifiers. Objective-C is a case-sensitive programming language. Thus, Manpower and manpower are two different identifiers in Objective-C. Here are some examples of acceptable identifiers:

mohd zara abc move_name a_123 myname50 _temp j a23b9 retVal

Whitespace in Objective-C

---

A line containing only whitespace, possibly with a comment, is known as a blank line, and an Objective-C compiler totally ignores it.

Whitespace is the term used in Objective-C to describe blanks, tabs, newline characters and comments. Whitespace separates one part of a statement from another and enables the compiler to identify where one element in a statement, such as int, ends and the next element begins. Therefore, in the following statement:

int age;

There must be at least one whitespace character (usually a space) between int and age for the compiler to be able to distinguish them. On the other hand, in the following statement,

fruit = apples + oranges; // get the total fruit

no whitespace characters are necessary between fruit and =, or between = and apples, although you are free to include some if you wish for readability purpose.

5 - OBJ-C DATA TYPES

In the Objective-C programming language, data types refer to an extensive system used for declaring variables or functions of different types. The type of a variable determines how much space it occupies in storage and how the bit pattern stored is interpreted.

The types in Objective-C can be classified as follows:

S.N.	Types and Description
1	Basic Types: They are arithmetic types and consist of the two types: (a) integer types and (b) floating-point types.
2	Enumerated types: They are again arithmetic types and they are used to define variables that can only be assigned certain discrete integer values throughout the program.
3	The type void: The type specifier void indicates that no value is available.
4	Derived types: They include (a) Pointer types, (b) Array types, (c) Structure types, (d) Union types and (e) Function types.

To get the exact size of a type or a variable on a particular platform, you can use the sizeof operator. The expression sizeof(type) yields the storage size of the object or type in bytes. Following is an example to get the size of int type on any machine:

#import <Foundation/Foundation.h> int main() { NSLog(@"Storage size for int : %d \n", sizeof(int)); return 0; }

When you compile and execute the above program, it produces the following result on Linux:

2013-09-07 22:21:39.155 demo[1340] Storage size for int : 4

Floating-Point Types

---

Following table gives you details about standard float-point types with storage sizes and value ranges and their precision:

Type	Storage size	Value range	Precision
float	4 byte	1.2E-38 to 3.4E+38	6 decimal places
double	8 byte	2.3E-308 to 1.7E+308	15 decimal places
long double	10 byte	3.4E-4932 to 1.1E+4932	19 decimal places

The header file float.h defines macros that allow you to use these values and other details about the binary representation of real numbers in your programs. Following example will print storage space taken by a float type and its range values:

#import <Foundation/Foundation.h> int main() { NSLog(@"Storage size for float : %d \n", sizeof(float)); return 0; }

When you compile and execute the above program, it produces the following result on Linux:

2013-09-07 22:22:21.729 demo[3927] Storage size for float : 4

The void Type

---

The void type specifies that no value is available. It is used in three kinds of situations:

S.N.	Types and Description
1	Function returns as void There are various functions in Objective-C which do not return value or you can say they return void. A function with no return value has the return type as void. For example, void exit (int status);
2	Function arguments as void There are various functions in Objective-C which do not accept any parameter. A function with no parameter can accept as a void. For example, int rand(void);

The void type may not be understood to you at this point, so let us proceed and we will cover these concepts in upcoming chapters.

6 - OBJ-C VARIABLES

A variable is nothing but a name given to a storage area that our programs can manipulate. Each variable in Objective-C has a specific type, which determines the size and layout of the variable's memory; the range of values that can be stored within that memory; and the set of operations that can be applied to the variable.

The name of a variable can be composed of letters, digits, and the underscore character. It must begin with either a letter or an underscore. Upper and lowercase letters are distinct because Objective-C is case-sensitive. Based on the basic types explained in previous chapter, there will be the following basic variable types:

Type	Description
char	Typically a single octet (one byte). This is an integer type.
int	The most natural size of integer for the machine.
float	A single-precision floating point value.
double	A double-precision floating point value.
void	Represents the absence of type.

Objective-C programming language also allows to define various other types of variables, which we will cover in subsequent chapters like Enumeration, Pointer, Array, Structure, Union, etc. For this chapter, let us study only basic variable types.

Variable Definition in Objective-C:

---

A variable definition means to tell the compiler where and how much to create the storage for the variable. A variable definition specifies a data type and contains a list of one or more variables of that type as follows:

type variable_list;

Here, type must be a valid Objective-C data type including char, w_char, int, float, double, bool or any user-defined object, etc., and variable_list may consist of one or more identifier names separated by commas. Some valid declarations are shown here:

int i, j, k; char c, ch; float f, salary; double d;

The line int i, j, k; both declares and defines the variables i, j and k; which instructs the compiler to create variables named i, j and k of type int.

Variables can be initialized (assigned an initial value) in their declaration. The initializer consists of an equal sign followed by a constant expression as follows:

type variable_name = value;

Some examples are:

extern int d = 3, f = 5; // declaration of d and f. int d = 3, f = 5; // definition and initializing d and f. byte z = 22; // definition and initializes z. char x = 'x'; // the variable x has the value 'x'.

For definition without an initializer: variables with static storage duration are implicitly initialized with NULL (all bytes have the value 0); the initial value of all other variables is undefined.

Variable Declaration in Objective-C:

---

A variable declaration provides assurance to the compiler that there is one variable existing with the given type and name so that compiler proceed for further compilation without needing complete detail about the variable. A variable declaration has its meaning at the time of compilation only, compiler needs actual variable declaration at the time of linking of the program.

A variable declaration is useful when you are using multiple files and you define your variable in one of the files, which will be available at the time of linking of the program. You will use extern keyword to declare a variable at any place. Though you can declare a variable multiple times in your Objective-C program but it can be defined only once in a file, a function or a block of code.

Example

---

Try the following example, where variables have been declared at the top, but they have been defined and initialized inside the main function:

#import <Foundation/Foundation.h> // Variable declaration: extern int a, b; extern int c; extern float f; int main () { /* variable definition: */ int a, b; int c; float f; /* actual initialization */ a = 10; b = 20; c = a + b; NSLog(@"value of c : %d \n", c); f = 70.0/3.0; NSLog(@"value of f : %f \n", f); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-07 22:43:31.695 demo[14019] value of c : 30
2013-09-07 22:43:31.695 demo[14019] value of f : 23.333334

Same concept applies on function declaration where you provide a function name at the time of its declaration and its actual definition can be given anywhere else. In the following example, it's explained using C function and as you know Objective-C supports C style functions also:

// function declaration int func(); int main() { // function call int i = func(); } // function definition int func() { return 0; }

Lvalues and Rvalues in Objective-C:

---

There are two kinds of expressions in Objective-C:

• lvalue : Expressions that refer to a memory location is called "lvalue" expression. An lvalue may appear as either the left-hand or right-hand side of an assignment.
• rvalue : The term rvalue refers to a data value that is stored at some address in memory. An rvalue is an expression that cannot have a value assigned to it which means an rvalue may appear on the right- but not left-hand side of an assignment.

Variables are lvalues and so may appear on the left-hand side of an assignment. Numeric literals are rvalues and so may not be assigned and can not appear on the left-hand side. Following is a valid statement:

int g = 20;

But following is not a valid statement and would generate compile-time error:

10 = 20;

7 - OBJ-C CONSTANTS

The constants refer to fixed values that the program may not alter during its execution. These fixed values are also called literals.

Constants can be of any of the basic data types like an integer constant, a floating constant, a character constant, or a string literal. There are also enumeration constants as well.

The constants are treated just like regular variables except that their values cannot be modified after their definition.

Integer literals

---

An integer literal can be a decimal, octal, or hexadecimal constant. A prefix specifies the base or radix: 0x or 0X for hexadecimal, 0 for octal, and nothing for decimal.

An integer literal can also have a suffix that is a combination of U and L, for unsigned and long, respectively. The suffix can be uppercase or lowercase and can be in any order.

Here are some examples of integer literals:

212 /* Legal */ 215u /* Legal */ 0xFeeL /* Legal */ 078 /* Illegal: 8 is not an octal digit */ 032UU /* Illegal: cannot repeat a suffix */

Following are other examples of various types of Integer literals:

85 /* decimal */ 0213 /* octal */ 0x4b /* hexadecimal */ 30 /* int */ 30u /* unsigned int */ 30l /* long */ 30ul /* unsigned long */

Floating-point literals

---

A floating-point literal has an integer part, a decimal point, a fractional part, and an exponent part. You can represent floating point literals either in decimal form or exponential form.

While representing using decimal form, you must include the decimal point, the exponent, or both and while representing using exponential form, you must include the integer part, the fractional part, or both. The signed exponent is introduced by e or E.

Here are some examples of floating-point literals:

3.14159 /* Legal */ 314159E-5L /* Legal */ 510E /* Illegal: incomplete exponent */ 210f /* Illegal: no decimal or exponent */ .e55 /* Illegal: missing integer or fraction */

Character constants

---

Character literals are enclosed in single quotes e.g., 'x' and can be stored in a simple variable of char type.

A character literal can be a plain character (e.g., 'x'), an escape sequence (e.g., '\t'), or a universal character (e.g., '\u02C0').

There are certain characters in C when they are proceeded by a backslash they will have special meaning and they are used to represent like newline (\n) or tab (\t). Here, you have a list of some of such escape sequence codes:

Escape sequence	Meaning
\\	\ character
\'	' character
\"	" character
\?	? character
\a	Alert or bell
\b	Backspace
\f	Form feed
\n	Newline
\r	Carriage return
\t	Horizontal tab
\v	Vertical tab
\ooo	Octal number of one to three digits
\xhh . . .	Hexadecimal number of one or more digits

Following is the example to show few escape sequence characters:

#import <Foundation/Foundation.h> int main() { NSLog(@"Hello\tWorld\n\n"); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-07 22:17:17.923 demo[17871] Hello          World

String literals

---

String literals or constants are enclosed in double quotes "". A string contains characters that are similar to character literals: plain characters, escape sequences, and universal characters.

You can break a long line into multiple lines using string literals and separating them using whitespaces.

Here are some examples of string literals. All the three forms are identical strings.

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

Defining Constants

---

There are two simple ways in C to define constants:

• Using #define preprocessor.
• Using const keyword.

The #define Preprocessor

---

Following is the form to use #define preprocessor to define a constant:

#define identifier value

Following example explains it in detail:

#import <Foundation/Foundation.h> #define LENGTH 10 #define WIDTH 5 #define NEWLINE '\n' int main() { int area; area = LENGTH * WIDTH; NSLog(@"value of area : %d", area); NSLog(@"%c", NEWLINE); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-07 22:18:16.637 demo[21460] value of area : 50
2013-09-07 22:18:16.638 demo[21460]

The const Keyword

---

You can use const prefix to declare constants with a specific type as follows:

const type variable = value;

Following example explains it in detail:

#import <Foundation/Foundation.h> int main() { const int LENGTH = 10; const int WIDTH = 5; const char NEWLINE = '\n'; int area; area = LENGTH * WIDTH; NSLog(@"value of area : %d", area); NSLog(@"%c", NEWLINE); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-07 22:19:24.780 demo[25621] value of area : 50
2013-09-07 22:19:24.781 demo[25621]

Note that it is a good programming practice to define constants in CAPITALS.

8 - OBJ-C OPERATORS

An operator is a symbol that tells the compiler to perform specific mathematical or logical manipulations. Objective-C language is rich in built-in operators and provides following types of operators:

• Arithmetic Operators
• Relational Operators
• Logical Operators
• Bitwise Operators
• Assignment Operators
• Misc Operators

This tutorial will explain the arithmetic, relational, logical, bitwise, assignment and other operators one by one.

Arithmetic Operators

---

Following table shows all the arithmetic operators supported by Objective-C language. Assume variable A holds 10 and variable B holds 20, then:

Show Examples

Operator	Description	Example
+	Adds two operands	A + B will give 30
-	Subtracts second operand from the first	A - B will give -10
*	Multiplies both operands	A * B will give 200
/	Divides numerator by denominator	B / A will give 2
%	Modulus Operator and remainder of after an integer division	B % A will give 0
++	Increment operator increases integer value by one	A++ will give 11
--	Decrement operator decreases integer value by one	A-- will give 9

Relational Operators

---

Following table shows all the relational operators supported by Objective-C language. Assume variable A holds 10 and variable B holds 20, then:

Show Examples

Operator	Description	Example
==	Checks if the values of two operands are equal or not; if yes, then condition becomes true.	(A == B) is not true.
!=	Checks if the values of two operands are equal or not; if values are not equal, then condition becomes true.	(A != B) is true.
>	Checks if the value of left operand is greater than the value of right operand; if yes, then condition becomes true.	(A > B) is not true.
<	Checks if the value of left operand is less than the value of right operand; if yes, then condition becomes true.	(A < B) is true.
>=	Checks if the value of left operand is greater than or equal to the value of right operand; if yes, then condition becomes true.	(A >= B) is not true.
<=	Checks if the value of left operand is less than or equal to the value of right operand; if yes, then condition becomes true.	(A <= B) is true.

Logical Operators

---

Following table shows all the logical operators supported by Objective-C language. Assume variable A holds 1 and variable B holds 0, then:

Show Examples

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are non zero then condition becomes true.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands is non zero then condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make false.	!(A && B) is true.

Logical Operators

---

Following table shows all the logical operators supported by Objective-C language. Assume variable A holds 1 and variable B holds 0, then:

Show Examples

Operator	Description	Example
&&	Called Logical AND operator. If both the operands are non zero then condition becomes true.	(A && B) is false.
||	Called Logical OR Operator. If any of the two operands is non zero then condition becomes true.	(A || B) is true.
!	Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true, then Logical NOT operator will make false.	!(A && B) is true.

Bitwise Operators

---

Bitwise operator works on bits and perform bit by bit operation. The truth tables for &, |, and ^ are as follows:

p	q	p & q	p | q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Assume if A = 60; and B = 13; now in binary format they will be as follows:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

The Bitwise operators supported by Objective-C language are listed in the following table. Assume variable A holds 60 and variable B holds 13 then:

Show Examples

Operator	Description	Example
&	Binary AND Operator copies a bit to the result if it exists in both operands.	(A & B) will give 12, which is 0000 1100
|	Binary OR Operator copies a bit if it exists in either operand.	(A | B) will give 61, which is 0011 1101
^	Binary XOR Operator copies the bit if it is set in one operand but not both.	(A ^ B) will give 49, which is 0011 0001
~	Binary Ones Complement Operator is unary and has the effect of 'flipping' bits.	(~A ) will give -61, which is 1100 0011 in 2's complement form.
<<	Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand.	A << 2 will give 240, which is 1111 0000
>>	Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand.	A >> 2 will give 15, which is 0000 1111

Assignment Operators

---

There are following assignment operators supported by Objective-C language:

Show Examples

Operator	Description	Example
=	Simple assignment operator, Assigns values from right side operands to left side operand	C = A + B will assign value of A + B into C
+=	Add AND assignment operator, It adds right operand to the left operand and assigns the result to left operand	C += A is equivalent to C = C + A
-=	Subtract AND assignment operator, It subtracts right operand from the left operand and assigns the result to left operand	C -= A is equivalent to C = C - A
*=	Multiply AND assignment operator, It multiplies right operand with the left operand and assigns the result to left operand	C *= A is equivalent to C = C * A
/=	Divide AND assignment operator, It divides left operand with the right operand and assigns the result to left operand	C /= A is equivalent to C = C / A
%=	Modulus AND assignment operator, It takes modulus using two operands and assigns the result to left operand	C %= A is equivalent to C = C % A
<<=	Left shift AND assignment operator	C <<= 2 is same as C = C << 2
>>=	Right shift AND assignment operator	C >>= 2 is same as C = C >> 2
&=	Bitwise AND assignment operator	C &= 2 is same as C = C & 2
^=	bitwise exclusive OR and assignment operator	C ^= 2 is same as C = C ^ 2
|=	bitwise inclusive OR and assignment operator	C |= 2 is same as C = C | 2

Misc Operators ↦ sizeof & ternary

---

There are few other important operators including sizeof and ? : supported by Objective-C Language.

Show Examples

Operator	Description	Example
sizeof()	Returns the size of an variable.	sizeof(a), where a is integer, will return 4.
&	Returns the address of an variable.	&a; will give actual address of the variable.
*	Pointer to a variable.	*a; will pointer to a variable.
? :	Conditional Expression	If Condition is true ? Then value X : Otherwise value Y

Operators Precedence in Objective-C

---

Operator precedence determines the grouping of terms in an expression. This affects how an expression is evaluated. Certain operators have higher precedence than others; for example, the multiplication operator has higher precedence than the addition operator:

For example, x = 7 + 3 * 2; here, x is assigned 13, not 20 because operator * has higher precedence than +, so it first gets multiplied with 3*2 and then adds into 7.

Here, operators with the highest precedence appear at the top of the table, those with the lowest appear at the bottom. Within an expression, higher precedence operators will be evaluated first.

Show Examples

Category	Operator	Associativity
Postfix	() [] -> . ++ - -	Left to right
Unary	+ - ! ~ ++ - - (type)* & sizeof	Right to left
Multiplicative	* / %	Left to right
Additive	+ -	Left to right
Shift	<< >>	Left to right
Relational	< <= > >=	Left to right
Equality	== !=	Left to right
Bitwise XOR	^	Left to right
Bitwise OR	|	Left to right
Logical AND	&&	Left to right
Logical OR	||	Left to right
Conditional	?:	Right to left
Assignment	= += -= *= /= %=>>= <<= &= ^= |=	Right to left
Comma	,	Left to right

9 - OBJ-C LOOPS

There may be a situation, when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on.

Programming languages provide various control structures that allow for more complicated execution paths.

A loop statement allows us to execute a statement or group of statements multiple times and following is the general form of a loop statement in most of the programming languages:

Objective-C programming language provides the following types of loop to handle looping requirements. Click the following links to check their details.

Loop Type	Description
while loop	Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body.
for loop	Execute a sequence of statements multiple times and abbreviates the code that manages the loop variable.
do...while loop	Like a while statement, except that it tests the condition at the end of the loop body.
nested loops	You can use one or more loops inside any another while, for or do..while loop.

Loop Control Statements:

---

Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed.

Objective-C supports the following control statements. Click the following links to check their details.

Control Statement	Description
break statement	Terminates the loop or switch statement and transfers execution to the statement immediately following the loop or switch.
continue statement	Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.

The Infinite Loop:

---

A loop becomes infinite loop if a condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the for loop are required, you can make an endless loop by leaving the conditional expression empty.

#import <Foundation/Foundation.h> int main () { for( ; ; ) { NSLog(@"This loop will run forever.\n"); } return 0; }

When the conditional expression is absent, it is assumed to be true. You may have an initialization and increment expression, but Objective-C programmers more commonly use the for(;;) construct to signify an infinite loop.

10 - OBJ-C DECISION MAKING

Decision making structures require that the programmer specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general form of a typical decision making structure found in most of the programming languages:Decision making structures require that the programmer specify one or more conditions to be evaluated or tested by the program, along with a statement or statements to be executed if the condition is determined to be true, and optionally, other statements to be executed if the condition is determined to be false.

Following is the general form of a typical decision making structure found in most of the programming languages:

Objective-C programming language assumes any non-zero and non-null values as true, and if it is either zero or null, then it is assumed as false value.

Objective-C programming language provides following types of decision making statements. Click the following links to check their details:

Statement	Description
if statement	An if statement consists of a boolean expression followed by one or more statements.
if...else statement	An if statement can be followed by an optional else statement, which executes when the boolean expression is false.
nested if statements	You can use one if or else if statement inside another if or else if statement(s).
switch statement	A switch statement allows a variable to be tested for equality against a list of values.
nested switch statements	You can use one switch statement inside another switch statement(s).

The ? : Operator:

---

We have covered conditional operator ? : in previous chapter which can be used to replace if...else statements. It has the following general form:

Exp1 ? Exp2 : Exp3;

Where Exp1, Exp2, and Exp3 are expressions. Notice the use and placement of the colon.

The value of a ? expression is determined like this: Exp1 is evaluated. If it is true, then Exp2 is evaluated and becomes the value of the entire ? expression. If Exp1 is false, then Exp3 is evaluated and its value becomes the value of the expression.

11 - OBJ-C FUNCTIONS

A function is a group of statements that together perform a task. Every Objective-C program has one C function, which is main(), and all of the most trivial programs can define additional functions.

You can divide up your code into separate functions. How you divide up your code among different functions is up to you, but logically the division usually is so each function performs a specific task.

A function declaration tells the compiler about a function's name, return type, and parameters. A function definition provides the actual body of the function.

Basically in Objective-C, we call the function as method.

The Objective-C foundation framework provides numerous built-in methods that your program can call. For example, method appendString() to append string to another string.

A method is known with various names like a function or a sub-routine or a procedure, etc.

Defining a Method

---

The general form of a method definition in Objective-C programming language is as follows:

- (return_type) method_name:( argumentType1 )argumentName1 joiningArgument2:( argumentType2 )argumentName2 ... joiningArgumentn:( argumentTypen )argumentNamen { body of the function }

A method definition in Objective-C programming language consists of a method header and a method body. Here are all the parts of a method:

• Return Type: A method may return a value. The return_type is the data type of the value the function returns. Some methods perform the desired operations without returning a value. In this case, the return_type is the keyword void.
• Method Name: This is the actual name of the method. The method name and the parameter list together constitute the method signature.
• Arguments: A argument is like a placeholder. When a function is invoked, you pass a value to the argument. This value is referred to as actual parameter or argument. The parameter list refers to the type, order, and number of the arguments of a method. Arguments are optional; that is, a method may contain no argument.
• Joining Argument: A joining argument is to make it easier to read and to make it clear while calling it.
• Method Body: The method body contains a collection of statements that define what the method does.

Example:

---

Following is the source code for a method called max(). This method takes two parameters num1 and num2 and returns the maximum between the two:

/* function returning the max between two numbers */ - (int) max:(int) num1 secondNumber:(int) num2 { /* local variable declaration */ int result; if (num1 > num2) { result = num1; } else { result = num2; } return result; }

Method Declarations:

---

A method declaration tells the compiler about a function name and how to call the method. The actual body of the function can be defined separately.

A method declaration has the following parts:

- (return_type) function_name:( argumentType1 )argumentName1 joiningArgument2:( argumentType2 )argumentName2 ... joiningArgumentn:( argumentTypen )argumentNamen;

For the above-defined function max(), following is the method declaration:

-(int) max:(int)num1 andNum2:(int)num2;

Method declaration is required when you define a method in one source file and you call that method in another file. In such case you should declare the function at the top of the file calling the function.

Calling a method:

---

While creating a Objective-C method, you give a definition of what the function has to do. To use a method, you will have to call that function to perform the defined task.

When a program calls a function, program control is transferred to the called method. A called method performs defined task, and when its return statement is executed or when its function-ending closing brace is reached, it returns program control back to the main program.

To call a method, you simply need to pass the required parameters along with method name, and if method returns a value, then you can store returned value. For example:

#import <Foundation/Foundation.h> @interface SampleClass:NSObject /* method declaration */ - (int)max:(int)num1 andNum2:(int)num2; @end @implementation SampleClass /* method returning the max between two numbers */ - (int)max:(int)num1 andNum2:(int)num2{ /* local variable declaration */ int result; if (num1 > num2) { result = num1; } else { result = num2; } return result; } @end int main () { /* local variable definition */ int a = 100; int b = 200; int ret; SampleClass *sampleClass = [[SampleClass alloc]init]; /* calling a method to get max value */ ret = [sampleClass max:a andNum2:b]; NSLog(@"Max value is : %d\n", ret ); return 0; }

I kept max() function along with main() function and complied the source code. While running final executable, it would produce the following result:

2013-09-07 22:28:45.912 demo[26080] Max value is : 200

Function Arguments:

---

If a function is to use arguments, it must declare variables that accept the values of the arguments. These variables are called the formal parameters of the function.

The formal parameters behave like other local variables inside the function and are created upon entry into the function and destroyed upon exit.

While calling a function, there are two ways that arguments can be passed to a function:

Call Type	Description
Call by value	This method copies the actual value of an argument into the formal parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.
Call by reference	This method copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the argument.

12 - OBJ-C BLOCKS

An Objective-C class defines an object that combines data with related behavior. Sometimes, it makes sense just to represent a single task or unit of behavior, rather than a collection of methods.

Blocks are a language-level feature added to C, Objective-C and C++ which allow you to create distinct segments of code that can be passed around to methods or functions as if they were values. Blocks are Objective-C objects which means they can be added to collections like NSArray or NSDictionary. They also have the ability to capture values from the enclosing scope, making them similar to closures or lambdas in other programming languages

Simple Block declaration syntax

---

returntype (^blockName)(argumentType);

Simple block implementation

returntype (^blockName)(argumentType)= ^{ };

Here is a simple example

---

void (^simpleBlock)(void) = ^{ NSLog(@"This is a block"); };

We can invoke the block using

---

simpleBlock();

Blocks Take Arguments and Return Values

---

Blocks can also take arguments and return values just like methods and functions.

Here is a simple example to implement and invoke a block with arguments and return values.

double (^multiplyTwoValues)(double, double) = ^(double firstValue, double secondValue) { return firstValue * secondValue; }; double result = multiplyTwoValues(2,4); NSLog(@"The result is %f", result);

Blocks using type definitions

---

Here is a simple example using typedef in block. Please note this sample doesn't work on the online compiler for now. Use XCode to run the same.

#import <Foundation/Foundation.h> typedef void (^CompletionBlock)(); @interface SampleClass:NSObject - (void)performActionWithCompletion:(CompletionBlock)completionBlock; @end @implementation SampleClass - (void)performActionWithCompletion:(CompletionBlock)completionBlock{ NSLog(@"Action Performed"); completionBlock(); } @end int main() { /* my first program in Objective-C */ SampleClass *sampleClass = [[SampleClass alloc]init]; [sampleClass performActionWithCompletion:^{ NSLog(@"Completion is called to intimate action is performed."); }]; return 0; }

Let us compile and execute it, it will produce the following result:

2013-09-10 08:13:57.155 demo[284:303] Action Performed
2013-09-10 08:13:57.157 demo[284:303] Completion is called to intimate action is performed.

Blocks are used more in iOS applications and Mac OS X. So its more important to understand the usage of blocks.

13 - OBJ-C NUMBERS

In Objective-C programming language, in order to save the basic data types like int, float, bool in object form,

Objective-C provides a range of methods to work with NSNumber and important ones are listed in following table.

S.N.	Method and Description
1	+ (NSNumber *)numberWithBool:(BOOL)value Creates and returns an NSNumber object containing a given value, treating it as a BOOL.
2	+ (NSNumber *)numberWithChar:(char)value Creates and returns an NSNumber object containing a given value, treating it as a signed char.
3	+ (NSNumber *)numberWithDouble:(double)value Creates and returns an NSNumber object containing a given value, treating it as a double.
4	+ (NSNumber *)numberWithFloat:(float)value Creates and returns an NSNumber object containing a given value, treating it as a float.
5	+ (NSNumber *)numberWithInt:(int)value Creates and returns an NSNumber object containing a given value, treating it as a signed int.
6	+ (NSNumber *)numberWithInteger:(NSInteger)value Creates and returns an NSNumber object containing a given value, treating it as an NSInteger.
7	- (BOOL)boolValue Returns the receiver's value as a BOOL.
8	- (char)charValue Returns the receiver's value as a char.
9	- (double)doubleValue Returns the receiver's value as a double.
10	- (float)floatValue Returns the receiver's value as a float.
11	- (NSInteger)integerValue Returns the receiver's value as an NSInteger.
12	- (int)intValue Returns the receiver's value as an int.
13	- (NSString *)stringValue Returns the receiver's value as a human-readable string.

Here is a simple example for using NSNumber which multiplies two numbers and returns the product.

#import <Foundation/Foundation.h> @interface SampleClass:NSObject - (NSNumber *)multiplyA:(NSNumber *)a withB:(NSNumber *)b; @end @implementation SampleClass - (NSNumber *)multiplyA:(NSNumber *)a withB:(NSNumber *)b { float number1 = [a floatValue]; float number2 = [b floatValue]; float product = number1 * number2; NSNumber *result = [NSNumber numberWithFloat:product]; return result; } @end int main() { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; SampleClass *sampleClass = [[SampleClass alloc]init]; NSNumber *a = [NSNumber numberWithFloat:10.5]; NSNumber *b = [NSNumber numberWithFloat:10.0]; NSNumber *result = [sampleClass multiplyA:a withB:b]; NSString *resultString = [result stringValue]; NSLog(@"The product is %@",resultString); [pool drain]; return 0; }

Now when we compile and run the program, we will get the following result.

2013-09-14 18:53:40.575 demo[16787] The product is 105

14 - OBJ-C ARRAYS

Objective-C programming language provides a data structure called the array, which can store a fixed-size sequential collection of elements of the same type. An array is used to store a collection of data, but it is often more useful to think of an array as a collection of variables of the same type.

Instead of declaring individual variables, such as number0, number1, ..., and number99, you declare one array variable such as numbers and use numbers[0], numbers[1], and ..., numbers[99] to represent individual variables. A specific element in an array is accessed by an index.

All arrays consist of contiguous memory locations. The lowest address corresponds to the first element and the highest address to the last element.

Declaring Arrays

---

To declare an array in Objective-C, a programmer specifies the type of the elements and the number of elements required by an array as follows:

type arrayName [ arraySize ];

This is called a single-dimensional array. The arraySize must be an integer constant greater than zero and type can be any valid Objective-C data type. For example, to declare a 10-element array called balance of type double, use this statement:

double balance[10];

Now, balance is a variable array, which is sufficient to hold up to 10 double numbers.

Initializing Arrays

---

You can initialize an array in Objective-C either one by one or using a single statement as follows:

double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};

The number of values between braces { } can not be larger than the number of elements that we declare for the array between square brackets [ ]. Following is an example to assign a single element of the array:

If you omit the size of the array, an array just big enough to hold the initialization is created. Therefore, if you write:

double balance[] = {1000.0, 2.0, 3.4, 17.0, 50.0};

You will create exactly the same array as you did in the previous example.

balance[4] = 50.0;

The above statement assigns element number 5th in the array a value of 50.0. Array with 4th index will be 5th, i.e., last element because all arrays have 0 as the index of their first element which is also called base index. Following is the pictorial representation of the same array we discussed above:

Accessing Array Elements

---

An element is accessed by indexing the array name. This is done by placing the index of the element within square brackets after the name of the array. For example:

double salary = balance[9];

The above statement will take 10th element from the array and assign the value to salary variable. Following is an example, which will use all the above mentioned three concepts viz. declaration, assignment and accessing arrays:

#import <Foundation/Foundation.h> int main () { int n[ 10 ]; /* n is an array of 10 integers */ int i,j; /* initialize elements of array n to 0 */ for ( i = 0; i < 10; i++ ) { n[ i ] = i + 100; /* set element at location i to i + 100 */ } /* output each array element's value */ for (j = 0; j < 10; j++ ) { NSLog(@"Element[%d] = %d\n", j, n[j] ); } return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-14 01:24:06.669 demo[16508] Element[0] = 100
2013-09-14 01:24:06.669 demo[16508] Element[1] = 101
2013-09-14 01:24:06.669 demo[16508] Element[2] = 102
2013-09-14 01:24:06.669 demo[16508] Element[3] = 103
2013-09-14 01:24:06.669 demo[16508] Element[4] = 104
2013-09-14 01:24:06.669 demo[16508] Element[5] = 105
2013-09-14 01:24:06.669 demo[16508] Element[6] = 106
2013-09-14 01:24:06.669 demo[16508] Element[7] = 107
2013-09-14 01:24:06.669 demo[16508] Element[8] = 108
2013-09-14 01:24:06.669 demo[16508] Element[9] = 109

Objective-C Arrays in Detail

---

Arrays are important to Objective-C and need lots of more details. There are following few important concepts related to array which should be clear to a Objective-C programmer:

Concept	Description
Multi-dimensional arrays	Objective-C supports multidimensional arrays. The simplest form of the multidimensional array is the two-dimensional array.
Passing arrays to functions	You can pass to the function a pointer to an array by specifying the array's name without an index.
Return array from a function	Objective-C allows a function to return an array.
Pointer to an array	You can generate a pointer to the first element of an array by simply specifying the array name, without any index.

15 - OBJ-C POINTERS

Pointers in Objective-C are easy and fun to learn. Some Objective-C programming tasks are performed more easily with pointers, and other tasks, such as dynamic memory allocation, cannot be performed without using pointers. So it becomes necessary to learn pointers to become a perfect Objective-C programmer. Let's start learning them in simple and easy steps.

As you know, every variable is a memory location and every memory location has its address defined which can be accessed using ampersand (&) operator, which denotes an address in memory. Consider the following example, which will print the address of the variables defined:

#import <Foundation/Foundation.h> int main () { int var1; char var2[10]; NSLog(@"Address of var1 variable: %x\n", &var1 ); NSLog(@"Address of var2 variable: %x\n", &var2 ); return 0; }

When the above code is compiled and executed, it produces the result something as follows:

2013-09-13 03:18:45.727 demo[17552] Address of var1 variable: 1c0843fc
2013-09-13 03:18:45.728 demo[17552] Address of var2 variable: 1c0843f0

So, you understood what is memory address and how to access it, so base of the concept is over. Now let us see what is a pointer.

What Are Pointers?

---

A pointer is a variable whose value is the address of another variable, i.e., direct address of the memory location. Like any variable or constant, you must declare a pointer before you can use it to store any variable address. The general form of a pointer variable declaration is:

type *var-name;

Here, type is the pointer's base type; it must be a valid Objective-C data type and var-name is the name of the pointer variable. The asterisk * you used to declare a pointer is the same asterisk that you use for multiplication. However, in this statement the asterisk is being used to designate a variable as a pointer. Following are the valid pointer declaration:

int *ip; /* pointer to an integer */ double *dp; /* pointer to a double */ float *fp; /* pointer to a float */ char *ch /* pointer to a character */

The actual data type of the value of all pointers, whether integer, float, character, or otherwise, is the same, a long hexadecimal number that represents a memory address. The only difference between pointers of different data types is the data type of the variable or constant that the pointer points to.

How to use Pointers?

---

There are few important operations, which we will do with the help of pointers very frequently. (a) we define a pointer variable, (b) assign the address of a variable to a pointer, and (c) finally access the value at the address available in the pointer variable. This is done by using unary operator * that returns the value of the variable located at the address specified by its operand. Following example makes use of these operations:

#import <Foundation/Foundation.h> int main () { int var = 20; /* actual variable declaration */ int *ip; /* pointer variable declaration */ ip = &var; /* store address of var in pointer variable*/ NSLog(@"Address of var variable: %x\n", &var ); /* address stored in pointer variable */ NSLog(@"Address stored in ip variable: %x\n", ip ); /* access the value using the pointer */ NSLog(@"Value of *ip variable: %d\n", *ip ); return 0; }

When the above code is compiled and executed, it produces the result something as follows:

2013-09-13 03:20:21.873 demo[24179] Address of var variable: 337ed41c
2013-09-13 03:20:21.873 demo[24179] Address stored in ip variable: 337ed41c
2013-09-13 03:20:21.874 demo[24179] Value of *ip variable: 20

NULL Pointers in Objective-C

---

It is always a good practice to assign a NULL value to a pointer variable in case you do not have exact address to be assigned. This is done at the time of variable declaration. A pointer that is assigned NULL is called a null pointer.

The NULL pointer is a constant with a value of zero defined in several standard libraries. Consider the following program:

#import <Foundation/Foundation.h> int main () { int *ptr = NULL; NSLog(@"The value of ptr is : %x\n", ptr ); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-13 03:21:19.447 demo[28027] The value of ptr is : 0

On most of the operating systems, programs are not permitted to access memory at address 0 because that memory is reserved by the operating system. However, the memory address 0 has special significance; it signals that the pointer is not intended to point to an accessible memory location. But by convention, if a pointer contains the null (zero) value, it is assumed to point to nothing.

To check for a null pointer, you can use an if statement as follows:

if(ptr) /* succeeds if p is not null */ if(!ptr) /* succeeds if p is null */

Objective-C Pointers in Detail:

---

Pointers have many but easy concepts and they are very important to Objective-C programming. There are following few important pointer concepts, which should be clear to a Objective-C programmer:

Concept	Description
Objective-C - Pointer arithmetic	There are four arithmetic operators that can be used on pointers: ++, --, +, -
Objective-C - Array of pointers	You can define arrays to hold a number of pointers.
Objective-C - Pointer to pointer	Objective-C allows you to have pointer on a pointer and so on.
Passing pointers to functions in Objective-C	Passing an argument by reference or by address both enable the passed argument to be changed in the calling function by the called function.
Return pointer from functions in Objective-C	Objective-C allows a function to return a pointer to local variable, static variable and dynamically allocated memory as well.

16 - OBJ-C STRINGS

The string in Objective-C programming language is represented using NSString and its subclass NSMutableString provides several ways for creating string objects. The simplest way to create a string object is to use the Objective-C @"..." construct:

NSString *greeting = @"Hello";

A simple example for creating and printing a string is shown below.

#import <Foundation/Foundation.h> int main () { NSString *greeting = @"Hello"; NSLog(@"Greeting message: %@\n", greeting ); return 0; }

When the above code is compiled and executed, it produces result something as follows:

2013-09-11 01:21:39.922 demo[23926] Greeting message: Hello

Objective-C supports a wide range of methods for manipulate strings:

S.N.	Method & Purpose
1	- (NSString *)capitalizedString; Returns a capitalized representation of the receiver.
2	- (unichar)characterAtIndex:(NSUInteger)index; Returns the character at a given array position.
3	- (double)doubleValue; Returns the floating-point value of the receiver’s text as a double.
4	- (float)floatValue; Returns the floating-point value of the receiver’s text as a float.
5	- (BOOL)hasPrefix:(NSString *)aString; Returns a Boolean value that indicates whether a given string matches the beginning characters of the receiver.
6	- (BOOL)hasSuffix:(NSString *)aString; Returns a Boolean value that indicates whether a given string matches the ending characters of the receiver.
7	- (id)initWithFormat:(NSString *)format ...; Returns an NSString object initialized by using a given format string as a template into which the remaining argument values are substituted.
8	- (NSInteger)integerValue; Returns the NSInteger value of the receiver’s text.
9	- (BOOL)isEqualToString:(NSString *)aString; Returns a Boolean value that indicates whether a given string is equal to the receiver using a literal Unicode-based comparison.
10	- (NSUInteger)length; Returns the number of Unicode characters in the receiver.
11	- (NSString *)lowercaseString; Returns lowercased representation of the receiver.
12	- (NSRange)rangeOfString:(NSString *)aString; Finds and returns the range of the first occurrence of a given string within the receiver.
13	- (NSString *)stringByAppendingFormat:(NSString *)format ...; Returns a string made by appending to the receiver a string constructed from a given format string and the following arguments.
14	- (NSString *)stringByTrimmingCharactersInSet:(NSCharacterSet *)set; Returns a new string made by removing from both ends of the receiver characters contained in a given character set.
15	- (NSString *)substringFromIndex:(NSUInteger)anIndex; Returns a new string containing the characters of the receiver from the one at a given index to the end.

Following example makes use of few of the above-mentioned functions:

#import <Foundation/Foundation.h> int main () { NSString *str1 = @"Hello"; NSString *str2 = @"World"; NSString *str3; int len ; NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; /* uppercase string */ str3 = [str2 uppercaseString]; NSLog(@"Uppercase String : %@\n", str3 ); /* concatenates str1 and str2 */ str3 = [str1 stringByAppendingFormat:@"World"]; NSLog(@"Concatenated string: %@\n", str3 ); /* total length of str3 after concatenation */ len = [str3 length]; NSLog(@"Length of Str3 : %d\n", len ); /* InitWithFormat */ str3 = [[NSString alloc] initWithFormat:@"%@ %@",str1,str2]; NSLog(@"Using initWithFormat: %@\n", str3 ); [pool drain]; return 0; }

When the above code is compiled and executed, it produces result something as follows:

2013-09-11 01:15:45.069 demo[30378] Uppercase String : WORLD
2013-09-11 01:15:45.070 demo[30378] Concatenated string: HelloWorld
2013-09-11 01:15:45.070 demo[30378] Length of Str3 : 10
2013-09-11 01:15:45.070 demo[30378] Using initWithFormat: Hello World

You can find a complete list of Objective-C NSString related methods in NSString Class Reference.

17 - OBJ-C STRUCTURES

Objective-C arrays allow you to define type of variables that can hold several data items of the same kind but structure is another user-defined data type available in Objective-C programming which allows you to combine data items of different kinds.

Structures are used to represent a record, Suppose you want to keep track of your books in a library. You might want to track the following attributes about each book:

• Title
• Author
• Subject
• Book ID

Defining a Structure

---

To define a structure, you must use the struct statement. The struct statement defines a new data type, with more than one member for your program. The format of the struct statement is this:

struct [structure tag] { member definition; member definition; ... member definition; } [one or more structure variables];

The structure tag is optional and each member definition is a normal variable definition, such as int i; or float f; or any other valid variable definition. At the end of the structure's definition, before the final semicolon, you can specify one or more structure variables but it is optional. Here is the way you would declare the Book structure:

struct Books { NSString *title; NSString *author; NSString *subject; int book_id; } book;

Accessing Structure Members

---

To access any member of a structure, we use the member access operator (.). The member access operator is coded as a period between the structure variable name and the structure member that we wish to access. You would use struct keyword to define variables of structure type. Following is the example to explain usage of structure:

#import <Foundation/Foundation.h> struct Books { NSString *title; NSString *author; NSString *subject; int book_id; }; int main( ) { struct Books Book1; /* Declare Book1 of type Book */ struct Books Book2; /* Declare Book2 of type Book */ /* book 1 specification */ Book1.title = @"Objective-C Programming"; Book1.author = @"Nuha Ali"; Book1.subject = @"Objective-C Programming Tutorial"; Book1.book_id = 6495407; /* book 2 specification */ Book2.title = @"Telecom Billing"; Book2.author = @"Zara Ali"; Book2.subject = @"Telecom Billing Tutorial"; Book2.book_id = 6495700; /* print Book1 info */ NSLog(@"Book 1 title : %@\n", Book1.title); NSLog(@"Book 1 author : %@\n", Book1.author); NSLog(@"Book 1 subject : %@\n", Book1.subject); NSLog(@"Book 1 book_id : %d\n", Book1.book_id); /* print Book2 info */ NSLog(@"Book 2 title : %@\n", Book2.title); NSLog(@"Book 2 author : %@\n", Book2.author); NSLog(@"Book 2 subject : %@\n", Book2.subject); NSLog(@"Book 2 book_id : %d\n", Book2.book_id); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-14 04:20:07.947 demo[20591] Book 1 title : Objective-C Programming
2013-09-14 04:20:07.947 demo[20591] Book 1 author : Nuha Ali
2013-09-14 04:20:07.947 demo[20591] Book 1 subject : Objective-C Programming Tutorial
2013-09-14 04:20:07.947 demo[20591] Book 1 book_id : 6495407
2013-09-14 04:20:07.947 demo[20591] Book 2 title : Telecom Billing
2013-09-14 04:20:07.947 demo[20591] Book 2 author : Zara Ali
2013-09-14 04:20:07.947 demo[20591] Book 2 subject : Telecom Billing Tutorial
2013-09-14 04:20:07.947 demo[20591] Book 2 book_id : 6495700

Structures as Function Arguments

---

You can pass a structure as a function argument in very similar way as you pass any other variable or pointer. You would access structure variables in the similar way as you have accessed in the above example:

#import <Foundation/Foundation.h> struct Books { NSString *title; NSString *author; NSString *subject; int book_id; }; @interface SampleClass:NSObject /* function declaration */ - (void) printBook:( struct Books) book ; @end @implementation SampleClass - (void) printBook:( struct Books) book { NSLog(@"Book title : %@\n", book.title); NSLog(@"Book author : %@\n", book.author); NSLog(@"Book subject : %@\n", book.subject); NSLog(@"Book book_id : %d\n", book.book_id); } @end int main( ) { struct Books Book1; /* Declare Book1 of type Book */ struct Books Book2; /* Declare Book2 of type Book */ /* book 1 specification */ Book1.title = @"Objective-C Programming"; Book1.author = @"Nuha Ali"; Book1.subject = @"Objective-C Programming Tutorial"; Book1.book_id = 6495407; /* book 2 specification */ Book2.title = @"Telecom Billing"; Book2.author = @"Zara Ali"; Book2.subject = @"Telecom Billing Tutorial"; Book2.book_id = 6495700; SampleClass *sampleClass = [[SampleClass alloc]init]; /* print Book1 info */ [sampleClass printBook: Book1]; /* Print Book2 info */ [sampleClass printBook: Book2]; return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-14 04:34:45.725 demo[8060] Book title : Objective-C Programming
2013-09-14 04:34:45.725 demo[8060] Book author : Nuha Ali
2013-09-14 04:34:45.725 demo[8060] Book subject : Objective-C Programming Tutorial
2013-09-14 04:34:45.725 demo[8060] Book book_id : 6495407
2013-09-14 04:34:45.725 demo[8060] Book title : Telecom Billing
2013-09-14 04:34:45.725 demo[8060] Book author : Zara Ali
2013-09-14 04:34:45.725 demo[8060] Book subject : Telecom Billing Tutorial
2013-09-14 04:34:45.725 demo[8060] Book book_id : 6495700

Pointers to Structures

---

You can define pointers to structures in very similar way as you define pointer to any other variable as follows:

struct Books *struct_pointer;

Now, you can store the address of a structure variable in the above-defined pointer variable. To find the address of a structure variable, place the & operator before the structure's name as follows:

struct_pointer = &Book1;

To access the members of a structure using a pointer to that structure, you must use the -> operator as follows:

struct_pointer->title;

Let us re-write above example using structure pointer, hope this will be easy for you to understand the concept:

#import <Foundation/Foundation.h> struct Books { NSString *title; NSString *author; NSString *subject; int book_id; }; @interface SampleClass:NSObject /* function declaration */ - (void) printBook:( struct Books *) book ; @end @implementation SampleClass - (void) printBook:( struct Books *) book { NSLog(@"Book title : %@\n", book->title); NSLog(@"Book author : %@\n", book->author); NSLog(@"Book subject : %@\n", book->subject); NSLog(@"Book book_id : %d\n", book->book_id); } @end int main( ) { struct Books Book1; /* Declare Book1 of type Book */ struct Books Book2; /* Declare Book2 of type Book */ /* book 1 specification */ Book1.title = @"Objective-C Programming"; Book1.author = @"Nuha Ali"; Book1.subject = @"Objective-C Programming Tutorial"; Book1.book_id = 6495407; /* book 2 specification */ Book2.title = @"Telecom Billing"; Book2.author = @"Zara Ali"; Book2.subject = @"Telecom Billing Tutorial"; Book2.book_id = 6495700; SampleClass *sampleClass = [[SampleClass alloc]init]; /* print Book1 info by passing address of Book1 */ [sampleClass printBook:&Book1]; /* print Book2 info by passing address of Book2 */ [sampleClass printBook:&Book2]; return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-14 04:38:13.942 demo[20745] Book title : Objective-C Programming
2013-09-14 04:38:13.942 demo[20745] Book author : Nuha Ali
2013-09-14 04:38:13.942 demo[20745] Book subject : Objective-C Programming Tutorial
2013-09-14 04:38:13.942 demo[20745] Book book_id : 6495407
2013-09-14 04:38:13.942 demo[20745] Book title : Telecom Billing
2013-09-14 04:38:13.942 demo[20745] Book author : Zara Ali
2013-09-14 04:38:13.942 demo[20745] Book subject : Telecom Billing Tutorial
2013-09-14 04:38:13.942 demo[20745] Book book_id : 6495700

Bit Fields

---

Bit Fields allow the packing of data in a structure. This is especially useful when memory or data storage is at a premium. Typical examples:

• Packing several objects into a machine word. e.g. 1 bit flags can be compacted.
• Reading external file formats -- non-standard file formats could be read in. E.g. 9 bit integers.

Objective-C allows us do this in a structure definition by putting :bit length after the variable. For example:

struct packed_struct { unsigned int f1:1; unsigned int f2:1; unsigned int f3:1; unsigned int f4:1; unsigned int type:4; unsigned int my_int:9; } pack;

Here, the packed_struct contains 6 members: Four 1 bit flags f1..f3, a 4 bit type and a 9 bit my_int.

Objective-C automatically packs the above bit fields as compactly as possible, provided that the maximum length of the field is less than or equal to the integer word length of the computer. If this is not the case, then some compilers may allow memory overlap for the fields whilst other would store the next field in the next word.

18 - OBJ-C PREPROCESSORS

The Objective-C Preprocessor is not part of the compiler, but is a separate step in the compilation process. In simplistic terms, an Objective-C Preprocessor is just a text substitution tool and it instructs compiler to do required pre-processing before actual compilation. We'll refer to the Objective-C Preprocessor as the OCPP.

All preprocessor commands begin with a pound symbol (#). It must be the first nonblank character, and for readability, a preprocessor directive should begin in first column. Following section lists down all important preprocessor directives:

Directive	Description
#define	Substitutes a preprocessor macro
#include	Inserts a particular header from another file
#undef	Undefines a preprocessor macro
#ifdef	Returns true if this macro is defined
#ifndef	Returns true if this macro is not defined
#if	Tests if a compile time condition is true
#else	The alternative for #if
#elif	#else an #if in one statement
#endif	Ends preprocessor conditional
#error	Prints error message on stderr
#pragma	Issues special commands to the compiler using a standardized method

Preprocessors Examples

---

Analyze the following examples to understand various directives.

#define MAX_ARRAY_LENGTH 20

This directive tells the OCPP to replace instances of MAX_ARRAY_LENGTH with 20. Use #define for constants to increase readability.

#import <Foundation/Foundation.h> #include "myheader.h"

These directives tell the OCPP to get foundation.h from Foundation Framework and add the text to the current source file. The next line tells OCPP to get myheader.h from the local directory and add the content to the current source file.

#undef FILE_SIZE #define FILE_SIZE 42

This tells the OCPP to undefine existing FILE_SIZE and define it as 42.

#ifndef MESSAGE #define MESSAGE "You wish!" #endif

This tells the OCPP to define MESSAGE only if MESSAGE isn't already defined.

#ifdef DEBUG /* Your debugging statements here */ #endif

This tells the OCPP to do the process the statements enclosed if DEBUG is defined. This is useful if you pass the -DDEBUG flag to gcc compiler at the time of compilation. This will define DEBUG, so you can turn debugging on and off on the fly during compilation.

Predefined Macros

---

ANSI C defines a number of macros. Although each one is available for your use in programming, the predefined macros should not be directly modified.

Macro	Description
__DATE__	The current date as a character literal in "MMM DD YYYY" format
__TIME__	The current time as a character literal in "HH:MM:SS" format
__FILE__	This contains the current filename as a string literal.
__LINE__	This contains the current line number as a decimal constant.
__STDC__	Defined as 1 when the compiler complies with the ANSI standard.

Let's try the following example:

#import <Foundation/Foundation.h> int main() { NSLog(@"File :%s\n", __FILE__ ); NSLog(@"Date :%s\n", __DATE__ ); NSLog(@"Time :%s\n", __TIME__ ); NSLog(@"Line :%d\n", __LINE__ ); NSLog(@"ANSI :%d\n", __STDC__ ); return 0; }

When the above code in a file main.m is compiled and executed, it produces the following result:

2013-09-14 04:46:14.859 demo[20683] File :main.m
2013-09-14 04:46:14.859 demo[20683] Date :Sep 14 2013
2013-09-14 04:46:14.859 demo[20683] Time :04:46:14
2013-09-14 04:46:14.859 demo[20683] Line :8
2013-09-14 04:46:14.859 demo[20683] ANSI :1

Preprocessor Operators

---

The Objective-C preprocessor offers following operators to help you in creating macros:

Macro Continuation (\)

A macro usually must be contained on a single line. The macro continuation operator is used to continue a macro that is too long for a single line. For example:

#define message_for(a, b) \ NSLog(@#a " and " #b ": We love you!\n")

Stringize (#)

The stringize or number-sign operator ('#'), when used within a macro definition, converts a macro parameter into a string constant. This operator may be used only in a macro that has a specified argument or parameter list. For example:

#import <Foundation/Foundation.h> #define message_for(a, b) \ NSLog(@#a " and " #b ": We love you!\n") int main(void) { message_for(Carole, Debra); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-14 05:46:14.859 demo[20683] Carole and Debra: We love you!

Token Pasting (##)

The token-pasting operator (##) within a macro definition combines two arguments. It permits two separate tokens in the macro definition to be joined into a single token. For example:

#import <Foundation/Foundation.h> #define tokenpaster(n) NSLog (@"token" #n " = %d", token##n) int main(void) { int token34 = 40; tokenpaster(34); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-14 05:48:14.859 demo[20683] token34 = 40

How it happened, because this example results in the following actual output from the preprocessor:

NSLog (@"token34 = %d", token34);

This example shows the concatenation of token##n into token34 and here we have used both stringize and token-pasting.

The defined() Operator

The preprocessor defined operator is used in constant expressions to determine if an identifier is defined using #define. If the specified identifier is defined, the value is true (non-zero). If the symbol is not defined, the value is false (zero). The defined operator is specified as follows:

#import <Foundation/Foundation.h> #if !defined (MESSAGE) #define MESSAGE "You wish!" #endif int main(void) { NSLog(@"Here is the message: %s\n", MESSAGE); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-14 05:48:19.859 demo[20683] Here is the message: You wish!

Parameterized Macros

---

One of the powerful functions of the OCPP is the ability to simulate functions using parameterized macros. For example, we might have some code to square a number as follows:

int square(int x) { return x * x; }

We can rewrite above code using a macro as follows:

#define square(x) ((x) * (x))

Macros with arguments must be defined using the #define directive before they can be used. The argument list is enclosed in parentheses and must immediately follow the macro name. Spaces are not allowed between macro name and open parenthesis. For example:

#import <Foundation/Foundation.h> #define MAX(x,y) ((x) > (y) ? (x) : (y)) int main(void) { NSLog(@"Max between 20 and 10 is %d\n", MAX(10, 20)); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-14 05:52:15.859 demo[20683] Max between 20 and 10 is 20

19 - OBJ-C TYPEDEF

The Objective-C programming language provides a keyword called typedef, which you can use to give a type a new name. Following is an example to define a term BYTE for one-byte numbers:

typedef unsigned char BYTE;

After this type definition, the identifier BYTE can be used as an abbreviation for the type unsigned char, for example:.

BYTE b1, b2;

By convention, uppercase letters are used for these definitions to remind the user that the type name is really a symbolic abbreviation, but you can use lowercase, as follows:

typedef unsigned char byte;

You can use typedef to give a name to user-defined data type as well. For example, you can use typedef with structure to define a new data type and then use that data type to define structure variables directly as follows:

#import <Foundation/Foundation.h> typedef struct Books { NSString *title; NSString *author; NSString *subject; int book_id; } Book; int main( ) { Book book; book.title = @"Objective-C Programming"; book.author = @"TutorialsPoint"; book.subject = @"Programming tutorial"; book.book_id = 100; NSLog( @"Book title : %@\n", book.title); NSLog( @"Book author : %@\n", book.author); NSLog( @"Book subject : %@\n", book.subject); NSLog( @"Book Id : %d\n", book.book_id); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-12 12:21:53.745 demo[31183] Book title : Objective-C Programming 2013-09-12 12:21:53.745 demo[31183] Book author : TutorialsPoint 2013-09-12 12:21:53.745 demo[31183] Book subject : Programming tutorial 2013-09-12 12:21:53.745 demo[31183] Book Id : 100

typedef vs #define

---

The #define is a Objective-C directive, which is also used to define the aliases for various data types similar to typedef but with following differences:

The typedef is limited to giving symbolic names to types only whereas #define can be used to define alias for values as well, like you can define 1 as ONE, etc.

The typedef interpretation is performed by the compiler where as #define statements are processed by the pre-processor.

Following is a simplest usage of #define:

#import <Foundation/Foundation.h> #define TRUE 1 #define FALSE 0 int main( ) { NSLog( @"Value of TRUE : %d\n", TRUE); NSLog( @"Value of FALSE : %d\n", FALSE); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-12 12:23:37.993 demo[5160] Value of TRUE : 1
2013-09-12 12:23:37.994 demo[5160] Value of FALSE : 0

20 - OBJ-C TYPE CASTING

---

Type casting is a way to convert a variable from one data type to another data type. For example, if you want to store a long value into a simple integer then you can type cast long to int. You can convert values from one type to another explicitly using the cast operator as follows:

(type_name) expression

In Objective-C, we generally use CGFloat for doing floating point operation, which is derived from basic type of float in case of 32-bit and double in case of 64-bit. Consider the following example where the cast operator causes the division of one integer variable by another to be performed as a floating-point operation:

#import <Foundation/Foundation.h> int main() { int sum = 17, count = 5; CGFloat mean; mean = (CGFloat) sum / count; NSLog(@"Value of mean : %f\n", mean ); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-11 01:35:40.047 demo[20634] Value of mean : 3.400000

It should be noted here that the cast operator has precedence over division, so the value of sum is first converted to type double and finally it gets divided by count yielding a double value.

Type conversions can be implicit which is performed by the compiler automatically or it can be specified explicitly through the use of the cast operator. It is considered good programming practice to use the cast operator whenever type conversions are necessary.

Integer Promotion

---

Integer promotion is the process by which values of integer type "smaller" than int or unsigned int are converted either to int or unsigned int. Consider an example of adding a character in an int:

#import <Foundation/Foundation.h> int main() { int i = 17; char c = 'c'; /* ascii value is 99 */ int sum; sum = i + c; NSLog(@"Value of sum : %d\n", sum ); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-11 01:38:28.492 demo[980] Value of sum : 116

Here, value of sum is coming as 116 because compiler is doing integer promotion and converting the value of 'c' to ascii before performing actual addition operation.

Usual Arithmetic Conversion

---

The usual arithmetic conversions are implicitly performed to cast their values in a common type. Compiler first performs integer promotion, if operands still have different types then they are converted to the type that appears highest in the following hierarchy:

The usual arithmetic conversions are not performed for the assignment operators, nor for the logical operators && and ||. Let us take following example to understand the concept:

#import <Foundation/Foundation.h> int main() { int i = 17; char c = 'c'; /* ascii value is 99 */ CGFloat sum; sum = i + c; NSLog(@"Value of sum : %f\n", sum ); return 0; }

When the above code is compiled and executed, it produces the following result:

2013-09-11 01:41:39.192 demo[15351] Value of sum : 116.000000

Here, it is simple to understand that first c gets converted to integer but because final value is float, so usual arithmetic conversion applies and compiler converts i and c into float and add them yielding a float result.

21 - OBJ-C LOG HANDLINGC

NSLog method

---

In order to print logs, we use the NSLog method in Objective-C programming language which we have used right from the Hello World example.

Let us look at a simple code that would print the words "Hello World":

#import <Foundation/Foundation.h> int main() { NSLog(@"Hello, World! \n"); return 0; }

Now, when we compile and run the program, we will get the following result.

2013-09-16 00:32:50.888 demo[16669] Hello, World!

Disabling logs in Live apps

---

Since the NSLogs we use in our application, it will be printed in logs of device and it is not good to print logs in a live build. Hence, we use a type definition for printing logs and we can use them as shown below.

#import <Foundation/Foundation.h> #if DEBUG == 0 #define DebugLog(...) #elif DEBUG == 1 #define DebugLog(...) NSLog(__VA_ARGS__) #endif int main() { DebugLog(@"Debug log, our custom addition gets \ printed during debug only" ); NSLog(@"NSLog gets printed always" ); return 0; }

Now, when we compile and run the program in debug mode, we will get the following result.

2013-09-11 02:47:07.723 demo[618] Debug log, our custom addition gets printed during debug only 2013-09-11 02:47:07.723 demo[618] NSLog gets printed always

Now, when we compile and run the program in release mode, we will get the following result.

2013-09-11 02:47:45.248 demo[3158] NSLog gets printed always

22 - OBJ-C ERROR HANDLING

In Objective-C programming, error handling is provided with NSError class available in Foundation framework.

An NSError object encapsulates richer and more extensible error information than is possible using only an error code or error string. The core attributes of an NSError object are an error domain (represented by a string), a domain-specific error code and a user info dictionary containing application specific information.

NSError

---

Objective-C programs use NSError objects to convey information about runtime errors that users need to be informed about. In most cases, a program displays this error information in a dialog or sheet. But it may also interpret the information and either ask the user to attempt to recover from the error or attempt to correct the error on its own

NSError Object consists of:

Domain: The error domain can be one of the predefined NSError domains or an arbitrary string describing a custom domain and domain must not be nil.
Code: The error code for the error.
User Info: The userInfo dictionary for the error and userInfo may be nil.

The following example shows how to create a custom error

NSString *domain = @"com.MyCompany.MyApplication.ErrorDomain"; NSString *desc = NSLocalizedString(@"Unable to complete the process", @""); NSDictionary *userInfo = @{ NSLocalizedDescriptionKey : desc }; NSError *error = [NSError errorWithDomain:domain code:-101 userInfo:userInfo];

Here is complete code of the above error sample passed as reference to an pointer

#import <Foundation/Foundation.h> @interface SampleClass:NSObject -(NSString *) getEmployeeNameForID:(int) id withError:(NSError **)errorPtr; @end @implementation SampleClass -(NSString *) getEmployeeNameForID:(int) id withError:(NSError **)errorPtr{ if(id == 1) { return @"Employee Test Name"; } else { NSString *domain = @"com.MyCompany.MyApplication.ErrorDomain"; NSString *desc =@"Unable to complete the process"; NSDictionary *userInfo = [[NSDictionary alloc] initWithObjectsAndKeys:desc, @"NSLocalizedDescriptionKey",NULL]; *errorPtr = [NSError errorWithDomain:domain code:-101 userInfo:userInfo]; return @""; } } @end int main() { NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init]; SampleClass *sampleClass = [[SampleClass alloc]init]; NSError *error = nil; NSString *name1 = [sampleClass getEmployeeNameForID:1 withError:&error]; if(error) { NSLog(@"Error finding Name1: %@",error); } else { NSLog(@"Name1: %@",name1); } error = nil; NSString *name2 = [sampleClass getEmployeeNameForID:2 withError:&error]; if(error) { NSLog(@"Error finding Name2: %@",error); } else { NSLog(@"Name2: %@",name2); } [pool drain]; return 0; }

In the above example, we return a name if the id is 1, otherwise we set the user-defined error object.

When the above code is compiled and executed, it produces the following result:

2013-09-14 18:01:00.809 demo[27632] Name1: Employee Test Name
2013-09-14 18:01:00.809 demo[27632] Error finding Name2: Unable to complete the process

13 - OBJ-C COMMAND_LINE ARGUMENTS

t is possible to pass some values from the command line to your Objective-C programs when they are executed. These values are called command line arguments and many times they are important for your program, especially when you want to control your program from outside instead of hard coding those values inside the code.

The command line arguments are handled using main() function arguments where argc refers to the number of arguments passed, and argv[] is a pointer array, which points to each argument passed to the program. Following is a simple example, which checks if there is any argument supplied from the command line and take action accordingly:

#import <Foundation/Foundation.h> int main( int argc, char *argv[] ) { if( argc == 2 ) { NSLog(@"The argument supplied is %s\n", argv[1]); } else if( argc > 2 ) { NSLog(@"Too many arguments supplied.\n"); } else { NSLog(@"One argument expected.\n"); } }

When the above code is compiled and executed with a single argument, say "testing", it produces the following result.

2013-09-13 03:01:17.333 demo[7640] The argument supplied is testing

When the above code is compiled and executed with two arguments, say testing1 and testing2, it produces the following result.

2013-09-13 03:01:18.333 demo[7640] Too many arguments supplied.

When the above code is compiled and executed without passing any argument, it produces the following result.

2013-09-13 03:01:18.333 demo[7640] One argument expected

It should be noted that argv[0] holds the name of the program itself and argv[1] is a pointer to the first command-line argument supplied, and *argv[n] is the last argument. If no arguments are supplied, argc will be one, otherwise if you pass one argument, then argc is set at 2.

You pass all the command line arguments separated by a space, but if argument itself has a space, then you can pass such arguments by putting them inside double quotes "" or single quotes ''. Let us re-write above example once again where we will print program name and we also pass a command-line argument by putting inside double quotes:

#import <Foundation/Foundation.h> int main( int argc, char *argv[] ) { NSLog(@"Program name %s\n", argv[0]); if( argc == 2 ) { NSLog(@"The argument supplied is %s\n", argv[1]); } else if( argc > 2 ) { NSLog(@"Too many arguments supplied.\n"); } else { NSLog(@"One argument expected.\n"); } return 0; }

When the above code is compiled and executed with a single argument separated by space but inside double quotes say "Testing1 Testing2", it produces the following result.

2013-09-14 04:07:57.305 demo[8534] Program name demo
2013-09-14 04:07:57.305 demo[8534] The argument supplied is Testing1 Testing 2

1 - JAVA OVERVIEW

Conventions in These Notes

---

Code is listed in a monospace font, both for code examples and for Java keywords mentioned in the text.

The standard Java convention for names is used:

• Class names are listed with an initial uppercase letter.
• Variable and function names are listed with an initial lowercase letter.
• The first letters of inner words are capitalized (e.g., maxValue).

For syntax definitions:

• Terms you must use as is are listed in normal monospace type.
• Terms that you must substitute for, either one of a set of allowable values, or a name of your own, or code, listed in italics.
• The following generic terms are used - you must substitute an appropriate term.

access	An access word from: public, protected, private, or it can be omitted
modifiers	one or more terms that modify a declaration; these include the access terms as well as terms like: static, transient, or volatile
dataType	A data type word; this can be a primitive, such as int, or the name of a class, such as Object; variants of this include: returnType and paramType
variableName	The name of a variable; variants on this include paramName and functionName
ClassName	The name of a class; there will be variants of this used for different types of examples, such as: BaseClassName, DerivedClassName, InterfaceName, and ExceptionClassName
code	Executable code goes here
. . .	In an example, omitted code not related to the topic

The Java Environment - Overview

---

A Java program is run differently than a traditional executable program.

Traditional programs are invoked through the operating system.

• They occupy their own memory space.
• They are tracked as an individual process by the OS.

Traditional programs are compiled from source code into a machine and OS-specific binary executable file.

• To run the program in different environments, the source code would be compiled for that specific target environment.

When you run a Java program, the OS is actually running the Java Runtime Engine, or JRE, as an executable program; it processes your compiled code through the Java Virtual Machine (usually referred to as the JVM).

A Java source code file is compiled into a bytecode file.

• You can consider bytecode as a sort of generic machine language.
• The compiled bytecode is read by the JVM as a data file.
• The JVM interprets the bytecode at runtime, performing a final mapping of bytecode to machine language for whatever platform it is running on.
• Thus, Java programs are portable - they can be written in any environment, compiled in any environment, and run in any environment (as long as a JVM is available for that environment).
• The JVM manages its own memory area and allocates it to your program as necessary.
• Although this involves more steps at runtime, Java is still very efficient, much more so than completely interpreted languages like JavaScript, since the time-consuming parsing of the source code is done in advance.

The Java Environment - Overview

---

A Java program is run differently than a traditional executable program.

Traditional programs are invoked through the operating system.

• They occupy their own memory space.
• They are tracked as an individual process by the OS.

Traditional programs are compiled from source code into a machine and OS-specific binary executable file.

• To run the program in different environments, the source code would be compiled for that specific target environment.

When you run a Java program, the OS is actually running the Java Runtime Engine, or JRE, as an executable program; it processes your compiled code through the Java Virtual Machine (usually referred to as the JVM).

A Java source code file is compiled into a bytecode file.

• You can consider bytecode as a sort of generic machine language.
• The compiled bytecode is read by the JVM as a data file.
• The JVM interprets the bytecode at runtime, performing a final mapping of bytecode to machine language for whatever platform it is running on.
• Thus, Java programs are portable - they can be written in any environment, compiled in any environment, and run in any environment (as long as a JVM is available for that environment).
• The JVM manages its own memory area and allocates it to your program as necessary.
• Although this involves more steps at runtime, Java is still very efficient, much more so than completely interpreted languages like JavaScript, since the time-consuming parsing of the source code is done in advance.

Writing a Java Program

---

Java source code is written in plain text, using a text editor.

• his could range from a plain text editor like Notepad, to a programmers' editor such as TextPad, EditPlus, or Crimson Editor, to a complex integrated development environment (IDE) like NetBeans, Eclipse, or JDeveloper.
• The source code file should have a .java extension.

The javac compiler is then used to compile the source code into bytecode.

javac MyClass.java

• The bytecode is stored in a file with an extension .class
• Bytecode is universal - one bytecode file will run on any supported platform.

You then run the java runtime engine, which will then interpret the bytecode to execute the program.

java MyClass

• The executable program you are running is: java.
• The class name tells the JVM what class to load and run the main method for.
• You must have a JVM made specifically for your hardware/OS platform.

Obtaining the Java Environment

---

You can download the SDK (software development kit) including the compiler and runtime engine from Oracle at: . Look for the download of JavaSE 1.6.0.10 (or the latest release of that version).

You can also download the API documentation and even the source code. Note that:

• he documentation lists all the standard classes in the API, with their data fields and methods, as well as other information necessary to use the class. You will find this documentation helpful as you work through some of the exercises.
• You can view the docs online, but it is worth downloading it so that you don't have to be connected to the internet to use it.

Setting up Your Java Environment

---

Java programs are compiled and run from an operating system prompt, unless you have installed an IDE that will do this for you directly. If you create an applet, this would run inside a web page in a browser.

After you have installed the JDK, you will need to set at least one environment variable in order to be able to compile and run Java programs.

For more complex projects that pull together elements from different sources, you must set an additional environment variable or two. Note that:

• a PATH environment variable enables the operating system to find the JDK executables when your working directory is not the JDK's binary directory.
• CLASSPATH is Java's analog to PATH, the compiler and JVM use it to locate Java classes.
• Often you will not need to set this, since the default setting is to use the JDK's library jar file and the current working directory.
• But, if you have additional Java classes located in another directory (a third-party library, perhaps), you will need to create a classpath that includes not only that library, but the current working directory as well (the current directory is represented as a dot).
• Many IDE's and servers expect to find a JAVA_HOME environment variable.
• This would be the JDK directory (the one that contains bin and lib).
• The PATH is then set from JAVA_HOME plus \bin.
• This makes it easy to upgrade your JDK, since there is only one entry you will need to change

Best Practice: Setting PATH from JAVA_HOME

The procedure to permanently set the environment variables varies slightly from one version of Windows to another; the following will work in many, including Windows XP. The process for Vista is similar, but slightly different:

1. Right-click on My Computer.
2. Choose Properties.
3. Select the Advanced tab.
4. Click the Environment Variables button at the bottom.
5. Check both the User and System variable lists to see if JAVA_HOME or PATH already exist.
6. If JAVA_HOME exists, check to see that it matches your most recent JDK (or the one you wish to use).

• It is probably better to set this as a System variable.
• If it exists, click Edit, if not, click Add.
• For the variable name, enter JAVA_HOME.
• For the value, enter your JDK directory, such as C:\Program Files\Java\jdk1.5.0_14.

• Note that the space in the name can sometimes cause problems.
• One solution is to put quote marks around the entry, as in "C:\Program Files\Java\jdk1.5.0_14".
• An even better solution would be to use the 8-character form of the directory name, such as C:\Progra~1\Java\jdk1.5.0_14 (you can check if this works in your system by typing it into the address bar of a My Computer window).

7. for PATH, again select either Add or Edit.

• You could do this either as a User variable or a System variable.
• If there isn't already a JDK bin directory mentioned in the PATH, it will work as a User variable.
• If there is already a JDK mentioned, you would want to ensure that this new entry preceded the existing entry, so you would edit that variable.
• Note that if the existing entry was created using JAVA_HOME, then we are already set correctly .
• If you "prepend" an entry to PATH , it will be found first, and therefore supercede any other directory - if you append to path, your directory won't be found if an earlier entry JDK entry exists (the following image shows a prepend).
• Also note that System variables precede User variables, so they will be found first.

Setting Environment Variables from a Command Prompt

If you set the variables from a command prompt, they will only hold for that session, but you could create a batch file that you could run each time you open a command prompt window.

To set the PATH from a command prompt or batch file:

set PATH=C:\Progra~1\Java\jdk1.6.0_10\bin;%PATH%

If you need to set the CLASSPATH:

set CLASSPATH=.;%CLASSPATH%

• Early versions of the JDK required you to include the JDK's lib directory in the CLASSPATH; this is no longer necessary .
• Note that UNIX environments use $PATH and $CLASSPATH instead of %PATH% and %CLASSPATH%, and that the path element separator is a colon instead of a semicolon.

Creating a Class that Can Run as a Program

---

The main() Method

In order to run as a program, a class must contain a method named main, with a particular argument list. This is similar to the C and C++ languages.

The definition goes inside your class definition, and looks like:

public static void main(String[] args) { (code goes here) }

• It must be public, because it will be called from outside your class (by the JVM).
• The static keyword defines an element (could be data or functional) that will exist regardless of whether an object of a class has been instantiated. In other words, declaring main as static allows the JVM to call the method and therefore execute the program. That doesn't mean that an object of that class cannot be instantiated, it is just not required.
• The String[] args parameter list states that there will be an array of String objects given to the method - these are the command line arguments.
• To run the program, use the following from the command line if you are running it from the console:

java <em>ClassName</em>

For example, if we had an executable class called Hello, in a file called Hello.java that compiled to Hello.class, you could run it with:

java Hello

Useful Stuff Necessary to Go Further

---

System.out.println()

In order to see something happen, we need to be able to print to the screen.

There is a System class that is automatically available when your program runs (everything in it is static).

it contains, among other things, input and output streams that match stdin, stdout, and stderr (standard output, standard input, and standard error).

System.out is a static reference to the standard output stream.

As an object, System.out contains a println(String) method that accepts a String object, and prints that text to the screen, ending with a newline (linefeed).

There is also a print(String) method that does not place a newline at the end.

You can print a String directly, or you can build one from pieces.

• It is worth noting that a String will automatically be created from a quote-delimited series of characters.
• Values can be appended to a String by using the + sign; if one item is a String or quote-delimited series of characters, then the rest can be any other type of data.

Using an Integrated Development Environment

---

Duration: 30 to 40 minutes. Integrated Development Environments, or IDEs, can greatly facilitate the task of creating applications. Mid-level code editors, such as Crimson Editor, TextPad, or Edit-Plus, provide syntax highlighting, automatic indenting, parentheses and curly-brace matching, and may have tools to compile and execute programs.

High-end environments, such as Eclipse, NetBeans, or JDeveloper, offer many additional features, such as project management, automatic deployment for web applications, code refactoring, code assist, etc. But, these additional capabilities come with the price of additional complexity in the environment, particularly because they force you to create projects for even the simplest applications.

To use the class files in these environments, we must first have a workspace, which is a collection of projects. Workspaces have various configuration settings that will cut across all projects within all projects they contain, such as which version of Java is in use, any added libraries, etc. (a project is usually one application).

Both Eclipse and NetBeans use the workspace concept, but you can start with any empty directory - the IDE will add its own special files as you create projects.

In the Windows Explorer, navigate to your ClassFiles directory. If it does not contain a Workspace subdirectory, create it.

To use Eclipse with the class files, you can direct it to the workspace (ClassFiles/Workspace) when it opens (if it asks), or use File, Switch Workspace if Eclipse is already running. Each chapter's demo folder should be treated as a project, as should each Solution folder.

One limitation of these environments is that no project can contain the same Java class twice, so our progressive versions of the Payroll application solution require their own individual project. Also, due to the way Java's package structures work, each Demo folder must be a separate project, as with each subdirectory under Solutions.

To use the Exercises folder as an Eclipse project:

1. Select File > New > Java Project
2. Enter Exercises for the project name
3. Click Finished
4. In the Package Explorer pane, right-click on the src folder under the Exercises folder
5. Select Import from the context menu
6. Select File System from the tree in the Select dialog box
7. Click Next
8. Using the Browse button, navigate to and select c:/ClassFiles/Exercises. (Note: this path might be different depending on where you extracted the class zip file)
9. Make sure the Exercises check box is selected and click Finished
10. Expand the src folder in the Package Explorer and then expand the default package folder
11. Right-click on the file Welcome.java
12. From the context menu select Run As... > Java Application
13. Note the output is displayed in the Console at the bottom of the Eclipse workbench

As we encounter each chapter, we can create a project using the Demos directory for that chapter the same way we just created the Exercises project..

To create a Java class within a project, use File, New , and then Class if that is available, or Other... and then Class . Provide a name and then OK .

In general, with the several applications that we will build upon progressively (Game and Payroll), you can continue to work with the same files, and add to them as we cover additional topics. If you want to check the solutions, you can either open those files in a separate editor, like Notepad, or create a project for that Solutions subdirectory. If you wish to save a particular stage of the application for future reference, you can just make a copy of the Exercises directory.

The examples and instructions provided use a more basic text editor (Chrimson) and an OS console for clarity. You are free to choose which tool to use. If Eclipse becomes a problem, move to a simple editor. The focus of this course is on the Java Programming Language and not a particular tool.

First Java Program

---

Duration: 5 to 15 minutes.

1.Create a file called Hello.java.
2.Enter the following code:

public class Hello { public static void main(String[] args) { System.out.println("Hello World"); } }

3.Save the file.
4.In a command prompt window, change to the directory where Hello.java is stored and type the following:

javac Hello.java

A prompt on the next line without any error messages indicates success.

5.Type:

java Hello

6.Press Enter.

You should see the message Hello World print in the window.

public class Hello

• All Java code must be within a class definition.
• A class defines a type of object.
• A public class can be accessed by any other class.
• A public class must be in its own file, whose name is the name of the class, plus a dot and an file extension of java(e.g., Hello.java ).

{ . . . }

• Curly braces denote a block of code (the code inside the braces).
• Code within braces usually belongs to whatever immediately precedes them.

public static void main(String[] args) {

• Words followed by parentheses denote a function.
• To be executable by itself, a class must have a function defined in this fashion; the name main means that execution will start with the first step of this function, and will end when the last step is done.
• It is public because it needs to be executed by other Java objects (the JVM itself is a running Java program, and it launches your program and calls its main function).
• It is static because it needs to exist even before one of these objects has been created.
• It does not return an answer when it is done; the absence of data is called void.
• The String[] args represents the additional data that might have been entered on the command line.

System.out.println("Hello World!");

• System is an class within the JVM that represents system resources.
• It contains an object called out, which represents output to the screen (what many environments call standard out).
• Note that an object's ownership of an element is denoted by using the name of the object, a dot, and then the name of the element.
• out in turn contains a function, println, that prints a line onto the screen (and appends a newline at the end).
• A function call is denoted by the function name followed by parentheses; any information inside the parentheses is used as input to the function (called arguments or parameters to the function).
• The argument passed to println() is the string of text "Hello World!".
• Note that the statement ends in a semicolon (as all do Java statements).

Using the Java Documentation

Sun provides extensive documentation of the API (library of available classes). The documentation for version 6 is available at

If you view that page, you will see a list of classes on the left as hyperlinks. Clicking a class name will bring up the documentation for that class on the right.

For example, click on System. The page on the right contains documentation on the elements of the class, categorized by type of element (there are links at the top for fields, constructors, methods, etc.).

Try to locate the out field - note that the field types, parameter types and return types are hyperlinked, and that out is a PrintStream. Click that, and find the println methods in a table with short descriptions. Select one to see the detailed description. The multiple versions are an example of method overloading, which we will cover in an upcoming lesson. Another lesson will cover documenting your own classes with the same tool that created this documentation.

In this lesson, you have learned:

2 - JAVA SYNTAX

General Syntax Rules

---

ava is case-sensitive. main(), Main(), and MAIN() would all be different methods.

There are a limited number of reserved words that have a special meaning within Java. You cannot use these words for your own variables or methods.

Some examples of reserved words are:

• public
• void
• static
• do
• for
• while
• if

Most keyboard symbol characters (the set of characters other than alphabetic or numeric) have a special meaning.

Names may contain alphabetic characters, numeric characters, currency characters, and connecting characters such as the underscore ( _ ) character:

• Names may not begin with a numeric character.
• Note that the set of legal characters draws from the entire Unicode character set.
• Also note that it is probably impossible to write a succinct set of rules about what are valid characters, other than to say a character, that when passed to Character.isJavaIdentifierPart(char ch), results in a true value.

The compiler parses your code by separating it into individual entities called tokens or symbols in computer science jargon:

• Names (of classes, variables, and methods).
• Command keywords.
• Single or compound symbols (compound symbols are when an operation is signified by a two-symbol combination).

Tokens may be separated by spaces, tabs, carriage returns, or by use of an operator (such as +, -, etc.).

Since names may not contain spaces, tabs, carriage returns, or operator characters, these characters imply a separation of what came before them from what comes after them.

Extra whitespace is ignored. Once the compiler knows that two items are separate, it ignores any additional separating whitespace characters (spaces, tabs, or carriage returns).

Java Statements

---

A Java statement is one step of code, which may span across multiple lines.

Java statements end with a semicolon (the ; character).

It is OK to have multiple statements on a single line.

Program execution is done statement by statement, one statement at a time from top to bottom (if there is more than one statement on a line, execution goes from left to right).

Within a statement, execution of the individual pieces is not necessarily left to right. There are concepts called operator precedence and associativity that determine the order of operations within a statement.

Blocks of Code

---

A block of code:

• Is enclosed in curly braces - start with { and end with }.
• Consists of zero, one, or more statements.
• Behaves like a single statement to the outside world..
• May be nested (e.g., it may contain one or more other blocks of code inside).
• Generally belong to whatever comes before it. Although it is perfectly OK to create a block that does not, this is almost never done.

A complete method is a single block of code, most likely with nested blocks.

The diagram below illustrates how blocks of code can be nested:

If you want, go ahead and modify your Hello World program to match this example.

Comments

---

A comment:

• Is additional, non-executable text in a program used to document code.
• May also be used to temporarily disable a section of code (for debugging).

Block Comments

Block comments are preceded by /* and followed by */.

Some rules for block comments:

• May not be nested.
• May be one or more lines.

/* this is a block comment * asterisk on this line not necessary, but looks nice */

• May span part of a line, for example, to temporarily disable part of a statement:

x = 3 /* + y */ ; Single-line Comments

A single line can be commented by preceding the comment with two forward slashes: //. Note that:

• The comment ends at the end of that line.
• Single-line comments may be nested inside block comments.

y = 7; /* * temporarily disable this line * which has a comment to end of line x = 3 + y; // add 3 for some reason */

Java specifies a third type of comment, the javadoc comment:

• Java contains a self-documentation utility, javadoc, which builds documentation from comments within the code.
• javadoc comments begin with /** and end with */.
• Comments only work as javadoc comments when placed at specific locations in your code (immediately above anything documentable - the class itself and its members), otherwise they are treated as ordinary comments.

/** * Represents a person, with a first name and last name. */ public class Person { /** The person's first name */ public String firstName; /** The person's last name */ public String lastName; }

3 - JAVA VARIABLES

Variables store data that your code can use.

There are two fundamental categories of variables, primitive data and references:

• With primitive data, the compiler names a memory location and uses itto store the actual data - numeric values such as integers, floating point values, and the code values of single individual text characters are stored as primitives.
• With references, the data is accessed indirectly - the compiler selects a memory location, associates it with the variable name, and stores in it a value that is effectively the memory address of the actual data - in Java, all objects and arrays are stored using references.

In the diagram below, the boxes are areas in memory:

Declaring Variables

---

Variables must be declared before they are used.

A declaration informs the compiler that you wish to:

• Create an identifier that will be accepted by the compiler within a section of code (exactly what that section is depends on how and where the variable is declared; that is the concept of scope, which will be addressed later).
• Associate that identifier with a specified type of data, and enforce restrictions related to that in the remainder of your code.
• Create a memory location for the specified type of data.
• Associate the identifier with that memory location.

Java uses many specific data types; each has different properties in terms of size required and handling by the compiler:

• The declaration specifies the name and datatype.
• Generally the declaration also defines the variable, meaning that it causes the compiler to allocate storage space in memory of the requested type's size.
• A declaration may also assign an initial value (to initialize the variable).
• Multiple variables of the same type can be declared in a comma-separated list.

Code	Effect
int a;	declares the name a to exist, and allocates a memory location to hold a 32-bit integer
int a = 0;	same as above, and also assigns an initial value of 0
int a = 0, b, c = 3;	declares three integer variables and initializes two of them

Note that different languages have different rules regarding variables that have not been initialized:

• Some languages just let the value be whatever happened to be in that memory location already (from some previous operation).
• Some languages initialize automatically to 0.
• Some languages will produce a compiler or runtime error.
• Java uses both of the last two: local variables within methods must be initialized before attempting to use their value, while variables that are fields within objects are automatically set to zero.

Advanced Declarations

---

Local variables, fields, methods, and classes may be given additional modifiers; keywords that determine special characteristics.

Any modifiers must appear first in any declaration, but multiple modifiers may appear in any order.

Keyword	Usage	Comments
final	local variables, fields, methods, classes	The name refers to a fixed item that cannot be changed. For a variable, that means that the value cannot be changed. For a method, the method cannot be overridden when extending the class. A final field does not, however, have to be initialized immediately; the initial assignment may be done once during an object's construction.
static	fields, methods, inner classes	Only for fields and methods of objects. One copy of the element exists regardless of how many instances are created. The element is created when the class is loaded.
transient	fields	The value of this element will not be saved with this object when serialization is used (for example, to save a binary object to a file, or send one across a network connection).
volatile	fields	The value of this element may change due to outside influences (other threads), so the compiler should not perform any caching optimizations.
public, protected, private	fields, methods classes	Specifies the level of access from other classes to this element - covered in depth later.
abstract	methods, classes	Specifies that a method is required for a concrete extension of this class, but that the method will not be created at this level of inheritance - the class must be extended to realize the method. For a class, specifies that the class itself may not be instantiated; only an extending class that is not abstract may be instantiated (a class must be abstract if one or more of it's methods are abstract) - covered in depth later
native	methods	The method is realized in native code (as opposed to Java code) - there is an external tool in the JDK for mapping functions from a DLL to these methods.
strictfp	methods, classes	For a method, it should perform all calculations in strict floating point (some processors have the ability to perform floating point more accurately by storing intermediate results in a larger number of bits than the final result will have; while more accurate, this means that the results might differ across platforms). For a class, this means that all methods are strictfp.
synchronized	methods, code blocks	No synchronized code may be accessed from multiple threads for the same object instance at the same time.

4 - JAVA DATA

Primitive Data Types

---

• The primitive data types store single values at some memory location that the compiler selects and maps to the variable name you declared .
• Primitive values are not objects - they do not have fields or methods.
• A primitive value is stored at the named location, while an object is accessed using a reference.
• An object reference variable does not store the object's data directly - it stores a reference to the block of data, which is somewhere else in memory (technically, the reference stores the memory address of the object, but you never get to see or use the address).

Primitives Data Types

Primitives Data Types

Primitive Type	Storage Size	Comments
boolean	1 bit	not usable mathematically, but can be used with logical and bitwise operators
char	16 bits	unsigned, not usable for math without converting to int
byte	8 bits	signed
short	16 bits	signed
int	32 bits	signed
long	64 bits	signed
float	32 bits	signed
double	64 bits	signed
void	None	not really a primitive, but worth including here

Object Data Types

---

Objects can be data, which can be stored in variables, passed to methods, or returned from methods.

References

As we will see later, objects are stored differently than primitives. An object variable stores a reference to the object (the object is located at some other memory location, and the reference is something like a memory address).

Text Strings

A sequence of text, such as a name, an error message, etc., is known as a string.

n Java, the String class is used to hold a sequence of text characters.

A String object:

• Is accessed through a reference, since it is an object.
• Has a number of useful methods, for case-sensitive or case-insensitive comparisons, obtaining substrings, determining the number of characters, converting to upper or lower case, etc.
• Is immutable; that is, once created it cannot be changed (but you can make your variable reference a different String object at any time).

Literal Values

A value typed into your code is called a literal value.

The compiler makes certain assumptions about literals:

• true and false are literal boolean values.
• null is a literal reference to nothing (for objects).
• A numeric value with no decimal places becomes an int, unless it is immediately assigned into a variable of a smaller type and falls within the valid range for that type.
• A value with decimal places becomes a double.
• To store a text character, you can put apostrophes around the character.

Code	Effect
char e = 'X';	Creates a 16-bit variable to hold the Unicode value for the uppercase X character.

You can add modifiers to values to instruct the compiler what type of value to create (note that all the modifiers described below can use either uppercase or lowercase letters).

Modifying prefixes enable you to use a different number base:

Prefix	Effect
0X or 0x	A base 16 value; the extra digits can be either uppercase or lowercase, as in char c = 0x1b;
0	A base 8 value, as in int i = 0765;

• Note: using these prefixes will always result in number that is considered positive (so that 0x7F for a byte would be OK, but 0x80 would not, since the latter would have a value of 128, outside the range of byte).
• Also note that a long value would need the L modifier as discussed below.

Modifying suffixes create a value of a different type than the default:

L or l	a long value (uses 64 bits of storage), as in long l = 1234567890123456L;
	Note: An int value will always implicitly be promoted to a long when required, but the reverse is not true; the above notation is necessary because the literal value is larger than 32 bits
F or f	A float value, as in float f = 3.7F;

Escape Sequences for Character Values

There are a number of escape sequences that are used for special characters:

Escape Sequence	Resulting Character
\b	Backspace
\f	Form feed
\n	Linefeed character - note that it produces exactly one character, Unicode 10 (\u000A in hex)
\r	Carriage return
\t	Tab
\"	Quote mark
\'	Apostrophe
\\	Backslash
\uNNNN	Unicode value, where N is a base 16 digit from 0 through F; valid values are \u0000 through \uFFFF
\NNN	Value expressed in octal; ranging from \000 to \377

The escape sequences can either be used for single characters or within strings of text:

char c = '\u1234'; System.out.println("\t\tHello\n\t\tWorld");

5 - JAVA CONSTANTS AND THE FINAL KEYWORD

Java has a means for defining contants, which are like variables in that they have names, but are not changeable once set.

If a variable is declared as final, it cannot be changed:

Even though the variable's value is not changeable once a value has been established, you are allowed to set a unique value once.

Local variables within methods may be declared as final.

Constants' values may be set in an explicit initialization, in a separate line of code, or, as method parameters passed when the method is called.

Fields within a class may be declared as final.

Contants' values may be set in an explicit initialization, in a separate line of code within an initialization block, or in a constructor.

Fields of a class may be declared as public static final - that way they are available to other classes, but cannot be changed by those other classes. An example is Math.PI.

Classes and methods may also be marked as final. We will cover this later.

Code Sample:

---

Java-Basics/Demos/FinalValues.java

public class FinalValues { // a constant final int scale = 100; // value below is dynamically created, // but cannot change afterward final int answer = (int)(Math.random() * scale); public static void main(String[] args) { FinalValues fv = new FinalValues(); System.out.println(fv.answer); // line below would not compile: // fv.answer = 44; } }

The class has two final fields, scale and answer. The scale is fixed at 100, while the answer is initialized dynamically, but, once established, the value cannot be changed. Try removing the comment from the line that attempts to set it to 44, and you will see the compiler error message that results.

6 - JAVA MATHEMATICS

Looks and behaves like algebra, using variable names and math symbols:

int a, b, c, temp; a = b/c + temp; b = c * (a - b);

Basic Rules

---

• What goes on the left of the = sign is called an lvalue. Only things that can accept a value can be an lvalue (usually this means a variable name - you can't have a calculation like a + b in front of the equal sign).
• Math symbols are known as operators; they include:

Operator	Purpose (Operation Performed)
+	for addition
-	for subtraction
*	for multiplication
/	for division
%	for modulus (remainder after division)
( and )	for enclosing a calculation

Note that integer division results in an integer - any remainder is discarded.

Expressions

---

An expression is anything that can be evaluated to produce a value. Every expression yields a value.

Examples (note that the first few of these are not complete statements):

Two simple expressions:

a + 5 5/c

An expression that contains another expression inside, the (5/c) part:

b + (5/c)

A statement is an expression; this one that contains another expression inside - the b + (5/c) part, which itself contains an expression inside it (the 5/c part):

a = b + (5/c);

Since an assignment statement (using the = sign) is an expression, it also yields a value (the value stored is considered the result of the expression), which allows things like this:

d = a = b + (5/c);

The value stored in a is the value of the expression b + (5/c).

Since an assignment expression's value is the value that was assigned, the same value is then stored in d.

The order of processing is as follows:

1. Retrieve the value of b.
2. Retrieve the 5 stored somewhere in memory by the compiler.
3. Retrieve the value of c.
4. perform 5 / c
5. Add the held value of b to the result of the above step.
6. Store that value into the memory location for a.
7. Store that same value into the memory location for d.

Here is a moderately complicated expression; let's say that a, b, and c are all double variables, and that a is 5.0, b is 10.0, and c is 20.0:

d = a + b * Math.sqrt(c + 5);

1.Since the c + 5 is in parentheses, the compiler creates code to evaluate that first, but to perform the c + 5 operation, both elements must be the same type of data, so the thing the compiler creates is a conversion for the 5 to 5.0 as a double.

d = a + b * Math.sqrt(c + 5.0);

2.Then the compiler creates code to evaluate 20.0 + 5.0 (at runtime it would become 25.0), reducing the expression to:

d = a + b * Math.sqrt(25.0);

3.Next, the compiler adds code to call the Math.sqrt method to evaluate its result, which will be 5.0, so the expression reduces to:

d = a + b * 5.0;

4.Note that the evaluated result of a method is known as the return value, or value returned. 5.Multiplication gets done before addition, the compiler creates that code next, to reduce the expression to:

d = a + 50.0;

6.Then the code will perform the addition, yielding:

d = 55.0;

7.And finally, the assignment is performed so that 55.0 is stored in d.

As implied by the examples we have seen so far, the order of evaluation of a complex expression is not necessarily from left to right. There is a concept called operator precedence that defines the order of operations.

Operator Precedence

Operator precedence specifies the order of evaluation of an expression.

Every language has a "table of operator precedence" that is fairly long and complex, but most languages follow the same general rules:

• Anything in parentheses gets evaluated before what is outside the parentheses.
• Multiply or divide get done before add and subtract.

Example:

• In the expression a = b + 5/c, the 5/c gets calculated first, then the result is added to b, then the overall result is stored in a.
• The equal sign (=) is an operator; where on the table do you think it is located?

The basic rule programmers follow is: when in doubt about the order of precedence, use parentheses.

Try the following program:

Code Sample:

Java-Basics/Demos/ExpressionExample.java

public class ExpressionExample { public static void main(String[] args) { double a = 5.0, b = 10.0, c = 20.0; System.out.println("a+b is " + (a + b)); System.out.println("a+b/c is " + (a + b / c)); System.out.println("a*b+c is " + (a * b + c)); System.out.println("b/a+c/a is " + (b / a + c / a)); } }

Multiple Assignments

---

Every expression has a value. For an assignment expression, the value assigned is the expression's overall value. This enables chaining of assignments:

x = y = z + 1; is the same as y = z + 1; x = y;

i = (j = k + 1)/2; is the same as j = k + 1; i = j/2;

Quite often, you may need to calculate a value involved in a test, but also store the value for later use:

double x; if ( (x = Math.random()) < 0.5 ) { System.out.println(x); }

You might wonder why not just generate the random number when we declare x? In this case, that would make sense, but in a loop the approach shown above might be easier such that:

• generates the random number and stores it in x.
• as an expression, that results in the same value, which is then tested for less than 0.5, and the loop body executes if that is true.
• the value of x is then available within the block.
• after the loop body executes, another random number is generated as the process repeats.

It is usually not necessary to code this way, but you will see it often.

Order of Evaluation

The order of operand evaluation is always left to right, regardless of the precedence of the operators involved.

Code Sample:

Java-Basics/Demos/EvaluationOrder.java

public class EvaluationOrder { public static int getA() { System.out.println("getA is 2"); return 2; } public static int getB() { System.out.println("getB is 3"); return 3; } public static int getC() { System.out.println("getC is 4"); return 4; } public static void main(String[] args) { int x = getA() + getB() * getC(); System.out.println("x = " + x); } }

The operands are first evaluated in left to right order, so that the functions are called in the order getA(), then getB(), and, lastly, getC()

But, the returned values are combined together by multiplying the results of getB() and getC(), and then adding the result from getA()

Bitwise Operators

Java has a number of operators for working with the individual bits within a value.

&	Bitwise AND, combines individual bits with an AND operation, so that in the resulting value, a bit position is only 1 if that position had a 1 for both operands.
	int a = 2;	has the 2 bit set	0...00000010
	int b = 6;	has the 2 and 4 bits set	0...00000110
	int c = a & b;	results in 2	0...00000010
|	Bitwise OR, combines individual bits with an OR operation, so that in the resulting value, a bit position is 1 if that position had a 1 for either operand.
	int a = 2;	has the 2 bit set	0...00000010
	int b = 4;	has the 4 bit set	0...00000100
	int c = a | b;	results in 6	0...00000110
^	Bitwise exclusive OR (XOR), combines individual bits so that any position that is the same in both operands yields a 0, any bits that differ yield a 1 in that position; this is often used in encryption, since repeating the operation on the result yields the original value again
	int a = 3;	has the 1 and 2 bits set	0...00000011
	int b = 6;	has the 2 and 4 bits set	0...00000110
	int c = a ^ b;	results in 5	0...00000101
	int d = c ^ b;	results in 3 again	0...00000011
~	Bitwise complement. Reverses the state of all bits.
	int a = 0;	has no bits set	0...00000000
	int b = ~a;	has all bits set	1...11111111

Bitwise Shift Operators

These operators shift the bits left or right within a 32-bit int value (they do not work with any other type).

<<	left shift the bits by the second operand
	int a = 4;	has the 4 bit set	0...00000010
	int b = a << 2;	now has the 16 bit set	0...00001000
>>	right shift the bits by the second operand with sign-extension (if the first bit is a 1, new bits introduced to fill in on the left come in as 1 bits)
	int a = -126;	has all bits except the rightmost set to 1	10...0000010
	int b = a >> 1;	now has all bits set to 1 (the 0 rolled off the right end, and a 1 was added on the left to match the original leftmost bit; the resulting value is 63)	110...000001
>>>	right shift the bits by the second operand without sign-extension (bits added on the left always come in as 0)
	int a = -1;	has all bits set to 1	11...1111111
	int b = a >>> 31;	now has all bits set to 0 except the rightmost (all bits except the first rolled off the right end, and 0's were added on the left	0000000...01

Compound Operators

Combine multiple effects in one operation: calculation and storage into memory

Operator	Purpose (Operation Performed)
++	increment a variable
--	decrement a variable; note that ++ and -- can precede or follow a variable
	if preceding (called prefix), apply the operator and then use the resulting value
	if following (called postfix), retrieve the value of the variable first, use it as the result of the expression, and then apply the operator
+=	add an amount to a variable
-=	subtract an amount from a variable
*=	multiply a variable by an amount
/=	divide a variable by an amount
%=	set variable equal to remainder after division by an amount
&=	perform bitwise AND between left and right, store result into left operand
|=	perform bitwise OR between left and right, store result into left operand
^=	perform bitwise XOR between left and right, store result into left operand
>>=	shift the variable's bits to the right by an amount with sign-extension
>>>=	shift the variable's bits to the right by an amount without sign-extension
<<=	shift the variable's bits to the left by an amount

Compound Operator Examples

Statement	Result
i++;	increment i
i--;	decrement i
j = i++;	retrieve current value of i, hold it as the result of the expression, assign its value to j, then increment i
j = ++i;	increment i, then j = i;
x *= 3;	x = x * 3;
y -= z + 5;	y = y - (z + 5);

It is inevitable that a certification exam will ask a question that requires understanding the steps involved in a postfix increment or decrement: try the following program:

Code Sample:

Java-Basics/Demos/IncrementTest.java

public class IncrementTest { public static void main(String[] args) { int i = 0, j; i = i++; System.out.println("i = " + i); j = i++ + i; System.out.println("i = " + i + ", j = " + j); } }

• In the first statement, i = i++;, the original value of i (0) is retrieved and held. Then, i is incremented. But, after that, the held value of 0 is put back into i, overwriting the 1!
• In the second part, j = i++ + i;, the operands are evaluated from left to right, but each operand is fully evaluated before proceeding to the next. Which means that the increment part of i++ has taken effect before the second appearance of i in the equation, so that the expression reduces to 0 + 1 (recall that the previous operation resulted in i being 0).

Expressions that Mix Data Types: Typecasting

Expressions will often mix different types of data, for example:

double x = 15.6 / 4; double y = 12.2 + 15 / 4;

The compiler must choose a specific type of data (either integer or floating-point, and the specific size) for each individual expression it evaluates within a statement.

• In general, the processor will choose the larger or more complex unit to work with.
• In the first case the value 4 will be promoted to a double, which will then be used in the division.
• The conversion is done one expression at a time within a statement; so, in the second example, the division will be performed with integer math, resulting in a value of 3, which will then be promoted to a double to finish the statement.

The process of changing the data type of a value is known a typecasting (or casting):

• A wideningcast converts a smaller or less precise value into a larger or more precise type - this is done automatically (the compiler does an implicitcast, as above).
• A narrowing cast converts a larger or more precise value into a smaller or less precise type (such as from double to int) - this must be coded with an explicit cast.
• To code an explicit typecast, put the desired type in parentheses in front of the expression to be converted; for example:

int a = (int) (15.6 / 4);

• The division will be evaluated as before, meaning the 4 is promoted to a double, and the result is a double, but a double can't be stored in a, so the cast to int is necessary.
• Note that casting is an operation, therefore it has a precedence (which is fairly high on the operator precedence table).

The allowable sequence of implicit casts is shown below:

Small Integral Types and Expressions

One aspect of Java that is important to understand is the result of expressions involving the small integral types: byte, char, and short any expression involving these types, other than the compound assignment expressions, is done with int values, so that the result will always be an int.

Try the following (it is the same as the earlier postfix increment example, using byte instead of int):

byte i = 0, j = 6, k; i++; k = i + j; System.out.println("i = " + i + ", j = " + j);

Note that the increment expression is accepted by the compiler; it is the simple addition in the third line that causes an error.

The Java Language Specification states the promotion rules as follows (note that this concept does not apply to all operators; again, the operators that include assignment do not use it):

When an operator applies binary numeric promotion to a pair of operands, each of which must denote a value of a numeric type, the following rules apply, in order, using widening conversions to convert operands as necessary:

• If either operand is of type double, the other is converted to double.
• Otherwise, if either operand is of type float, the other is converted to float.
• Otherwise, if either operand is of type long, the other is converted to long.
• Otherwise, both operands are converted to type int.

7 - JAVA CREATING AND USING METHODS

The method is the basic complete unit of code to perform one task within an object:

• In procedural languages, these are called functions, but in OOP they are usually called methods.
• Almost all executable code is in some method.
• Technically, there is one other place an object-oriented program could have executable code, but that is an advanced topic.
• Examples: calculate a trigonometry function like cosine, print data on the screen, read from a file, open a window.
• Methods are defined by a name followed by parentheses.
• Inputs to the method go inside the parentheses; they are called parameters or arguments to the method.

Using a method in your code, causing it to run, is known as calling the method.

A method call is an expression, so it may result in a value (the method call is evaluated like any other expression).

• this value is called the return value, and the method is said to return a value.
• the following is an example of a method used as an expression within a larger expression:

z = Math.sin(Math.PI / Math.sqrt(x));

Methods must be called with arguments that matching their specified form, known as the function signature:

• the signature is the combination of the name of the method with the pattern of its parameters.
• the documentation for library-supplied methods will tell you the signature for those methods.
• when you call a method, the name of the method and the parameters you pass to it will determine which method will be called, based on the available signatures.
• for each argument, Java expects a value - which could be a literal value, a variable, or expression; it must be either the correct type or a value that can be implicitly typecast to the correct type.

All methods in Java must be defined within a class definition. They have complete access to all other elements of the class (fields and other methods, regardless of the access modifier used for that element).

Code Sample:

Java-Basics/Demos/UseMethodsExample.java

public class UseMethodsExample { public static void main(String[] args) { int x = 16; double y = Math.sqrt(x); System.out.println("Square root of " + x + " is " + y); double z = Math.sin(Math.PI / 2); System.out.println("Sine of pi/2 is " + z); } }

This class calls two methods from the Math class: sqrt and sin, both of which expect one parameter which is a double.

When we call sqrt and pass an integer, the compiler converts that to a double to provide the type of data that sqrt expects

Note that even if your program does not call any methods, it has one method that will be called: main(). Things to note:

• The definition of main() is that it provides a start point and end point for your program.
• Program execution starts with the first statement in main().
• If the last statement in main() is executed, the program ends.
• The main() does have arguments (any other words typed on the command line).

Creating Methods

---

There are three things you need to decide for any method:

1. what it does.
2. what inputs it needs.
3. what answer it gives back.

[modifiers] dataType methodName(parameterList) { methodBody return result; }

• modifiers include the accessibility of this method from outside the class (public, private, protected, or left blank) as well as other possibilities listed earlier in this section.
• dataType is a type of data, like int.
• methodName is the name of your method.
• parameterList is a comma-separated list of parameters; each parameter is listed with its data type first, then its name.
• methodBody is the set of statements that perform the task of the method.
• return is a keyword that says to use the result expression value as the result of calling the method, and send that value back to the code that called the method (as an expression, a call to a method evaluates to the returned value; i.e., calling Math.sqrt(4) evaluates to the value that sqrt returned).
• if a method declares that it returns a value of a certain type, then it must explicitly return a value of that type.

Method Examples

public void sayHello() { System.out.println("Hello"); }

• public methods are accessible to any other class.
• void is a keyword for a returned data type that means no data at all - this method does not calculate a result.
• The name of the method is sayHello.
• This method could be called as follows:

showNumber(5); from within the class
x.showNumber(5); from outside the class, for an instance x of this class >public int calculateSum(int num1, int num2) { int answer = num1 + num2; return answer; }

• This method does calculate a result; the data type it calculates is int.
• This method must be given two parameters, both of which are int data types.
• This method could be called as follows:

int value = calculateSum(4, 6); from within the class
int value = x.calculateSum(4, 6); from outside the class, for an instance x of this class

Return Values

Note that the listing of a data type word in front of a name is something we have seen before, in declaring variables. The purpose is the same - to state what type of data this element provides when used in an expression.

The first statement below states that the value of a is an int, so that the compiler knows what memory size to allocate and what type of processing to use with it when it evaluates the second statement.

int a; int b = a / 2;

The effect is no different using a method; recall the function signature (the first line) of our calculateSum method:

public int calculateSum(int num1, int num2)

It states that the result of evaluating calculateSum is an int, so that the compiler knows what memory size to allocate for the result, and what type of processing to use with it when it evaluates a statement like:

int b = calculateSum(4, 6) / 2;

When this statement gets processed, the calculateSum method will run and return its result (which will be the value 10 as an int).

Thus the statement in effect is reduced to:

int b = 10 / 2;

Method Parameters

---

Method parameters are also declarations. They declare a type of data received by the method, and also provide a name for each value so it can be used within the method.

Back to our method:

public int calculateSum(int num1, int num2) { int answer = num1 + num2; return answer; }

• The parameter list declares two variables that will exist in this method: num1 and num2.
• The order is important - num1 will be the first value given to the method, num2 will be the second.
• The difference between method parameter declarations and the variable declarations we saw before is that the method parameters receive their values when the method is called.

8 - JAVA VARIABLES SCOPE

The variable scope rules are similar to those in C++.

Variables can be declared at any point in your code, not just at the top of a block:

• Local variables (those within methods) are not visible to any code that precedes the declaration.
• Object elements are visible to any code within the object, regardless of the order of declaration.

Variables declared within a set of curly braces cease to exist after the closing brace has been reached (it is said that they go out of scope); therefore, local variables exist only within that method.

Variables can be declared in the control portion of a for loop, and will exist for the duration of the loop

Parameters to a method are local variables within that method

It is legal to use the same variable name in different scopes, as long as the two scopes have no irresolvable conflicts. Some explanation:

• Non-overlapping scopes. For example, two different methods could each have a local variable called firstName.
• Overlapping scopes. It is valid for a method to have a variable whose name conflicts with a property name for that class - in that case, the local variable hides the property, but there is a special syntax that allows the method to access the property; we will cover this later.
• It is legal for a method and a field of a class to have the same name, although it is not considered a good practice to do so.
• An example of an irresolvable conflict is declaring a local variable within a block when the same name is already in scope in that method as a local variable.

Code Sample:

---

Java-Basics/Demos/MethodExample.java

public class MethodExample { public static void sayHello() { System.out.println("Hello"); } public static void showNumber(int number) { System.out.println("The number is: " + number); } public static int calculateSum(int num1, int num2) { int answer = num1 + num2; return answer; } public static void main(String[] args) { sayHello(); showNumber(5); int b = calculateSum(4, 6); System.out.println("The sum of 4 and 6 is:" + b); b = calculateSum(4, 6) / 2; System.out.println("That divided by 2 is: " + b); } }

We will cover the concept of static elements later, but, for now, since main is static, the methods it calls must be static as well

9 - JAVA COMPARISONS AND CONTROL STRUCTURES

Boolean-valued Expressions

---

Java has a data type called boolean. Note the following:

• Possible values are true or false.
• boolean can be operated on with logical or bitwise operators, but cannot be treated as a 0 or 1 mathematically.
• boolean can be specified as a parameter type or return value for a method.
• A boolean value will print as true or false.

The result of a conditional expression (such as a comparison operation) is a boolean value. Note that:

• Simple comparisons, such as greater than, equal to, etc., are allowed.
• Values are returned from functions.
• Complex combinations of simpler conditions are allowed.

Conditional expressions are used for program control. That means they provide the ability for a program to branch based on the runtime condition or iterate through a block of code until the condition is false.

Comparison Operators

---

This chart shows the comparison operators and the types of data they can be applied to.

This chart shows the comparison operators and the types of data they can be applied to.

Operator	Purpose (Operation Performed)	Types of Data
		boolean	Numeric Primitives and char	Object References
==	is equal to (note the two equals signs!)	X	X	X
!=	is not equal to	X	X	X
>	is greater than		X
<	is less than		X
>=	is greater than or equal to		X
<=	is less than or equal to		X

Note that it is unwise to use == or != with floating-point data types, as they can be imprecise.

Comparing Objects

---

The operators == and != test if two references point to exactly the same object in memory – they test that the numeric values of the two references are the same. The equals(Object o) method compares the contents of two objects to see if they are the same (you can override this method for your classes to perform any test you want).

Conditional Expression Examples

---

The following are conditional expression examples.

• a = 3; b = 4;
• a == b will evaluate to false
• a != b will evaluate to true
• a > b will evaluate to false
• a < b will evaluate to true
• a >= b will evaluate to false
• a <= b will evaluate to true

String s = "Hello"; String r = "Hel"; String t = r + "lo";

s == t will evaluate to false

s != t will evaluate to true (they are not the same object - they are two different objects that have the same contents)

s.equals(t) will evaluate to true

String s = "Hello"; String t = s;

s == t will evaluate to true

s != t will evaluate to false (they are the same object)

s.equals(t) will evaluate to true

Note: Java will intern a literal String that is used more than once in your code; that is, it will use the same location for all occurrences of that String

String s = "Hello"; String t = "Hello";

s == t will evaluate to true, because the String object storing "Hello" is stored only once, and both s and t reference that location

s != t will evaluate to false (they are the same object)

s.equals(t) will evaluate to true

Complex boolean Expressions

---

Java has operators for combining boolean values with AND and OR logic, and for negating a value (a NOT operation). Note that:

• There are also bitwise operators for AND, OR, and bitwise inversion (changing all 1 bits to 0, and vice versa).
• Since a boolean is stored as one bit, the bitwise AND and OR operators will give the same logical result, but will be applied differently (see below).
• For some reason, the bitwise NOT cannot be applied to a boolean value.

Logical		Bitwise
&&	logical AND	&	bitwise AND
||	logical OR	|	bitwise OR
!	logical NOT	~	bitwise NOT (inversion)

Code	Effect
Testing if a value falls within a range
( ( a >= 0 ) && ( a <= 10 ) )	is true if a is falls between 0 and 10; it must satisfy both conditions
Testing if a value falls outside a range
( ( a < 0 ) || ( a > 10 ) )	is true if a falls outside the range 0 to 10; it may be either below or above that range
( !( ( a >= 0 ) && ( a <= 10) ) )	inverts the test for a between 0 and 10; so a must be outside the range instead of inside it

The && and || operations are called short-circuiting, because if the first condition determines the final outcome, the second condition is not evaluated.

To force both conditions to be evaluated, use & and | for AND and OR, respectively.

Example: to test if a reference is null before calling a boolean valued method on it.

String s = request.getParameter("shipovernite"); if (s != null && s.equalsIgnoreCase("YES")) { . . . }

equalsIgnoreCase will be called only if the reference is not null.

The if Statement

---

if (condition) statement;

or

if (condition) { zero to many statements; }

Causes "one thing" to occur when a specified condition is met.

The one thing may be a single statement or a block of statements in curly braces. The remainder of the code (following the if and the statement or block it owns) is then executed regardless of the result of the condition.

The conditional expression is placed within parentheses.

The following flowchart shows the path of execution:

if Statement Examples

---

Absolute Value

If we needed the absolute value of a number (a number that would always be positive):

Code Sample:

Java-Control/Demos/If1.java

public class If1 { public static void main(String[] args) { int a = 5; System.out.println("original number is: " + a); if ( a < 0 ) { a = -a; } System.out.println("absolute value is: " + a); a = -10; System.out.println("original number is: " + a); if ( a < 0 ) { a = -a; } System.out.println("absolute value is: " + a); } }

Random Selection

Task: write a brief program which generates a random number between 0 and 1. Print out that the value is in the low, middle, or high third of that range (Math.random() will produce a double value from 0.0 up to but not including 1.0).

• Although it is a bit inefficient, just do three separate tests: (note that Math.random() will produce a number greater than or equal to 0.0 and less than 1.0).

Code Sample:

Java-Control/Demos/If2.java

public class If2 { public static void main(String[] args) { double d = Math.random(); System.out.print("The number " + d); if (d < 1.0/3.0) System.out.println(" is low"); if (d >= 1.0/3.0 && d < 2.0/3.0) System.out.println(" is middle"); if (d >= 2.0/3.0) System.out.println(" is high"); } }

Game01: A Guessing Game

---

Duration: 15 to 20 minutes. Write a program called Game that will ask the user to guess a number and compare their guess to a stored integer value between 1 and 100.

1. Use a field called answer to store the expected answer.
2. For now, just hard-code the stored value; we will create a random value later (your code will be easier to debug if you know the correct answer).
3. Create a method called play() that holds the logic for the guessing. Use the KeyboardReader class to ask for a number between 1 and 100, read the result, and tell the user if they are too low, correct, or too high.
4. Create a main method, have it create a new instance of Game and call play().

Solution:

Solutions/Game01/Game.java

import util.*; public class Game { private int answer = 67; public void play() { int guess; guess = KeyboardReader.getPromptedInt("Enter a number 1 -100: "); if (guess < answer) System.out.println("Too low"); if (guess > answer) System.out.println("Too high"); if (guess == answer) System.out.println("Correct!"); } public static void main(String[] args) { new Game().play(); } }

Each of the the three possible cases is tested individually as shown below. All three tests will always be performed. In the next version, we will make the tests mutually exclusive, so that processing stops when one is true. we will use a more efficient approach.

if (guess < answer) System.out.println("Too low"); if (guess > answer) System.out.println("Too high"); if (guess == answer) System.out.println("Correct!");

Payroll-Control01: Modified Payroll

---

Duration: 10 to 15 minutes. We will modify our payroll program to check the pay rate and department values.

1. The Employee class should protect itself from bad data, so modify setPayRate and setDept to check the incoming data (and ignore it if it is less than 0).
2. Test your program to see what happens with negative input values.
3. The code using Employee should avoiding sending it bad data, so also change main in Payroll.java to check for acceptable pay rate and department values (print an error message for any negative entry, then just set that variable to 0 (for lack of anything better that we can do right now. Later we will find a way to ask the user for a new value instead)

Solution:

Solutions/Payroll-Control01/employees/Employee.java

package employees; public class Employee { ---- C O D E O M I T T E D ---- public int getDept() { return dept; } public void setDept(int dept) { if (dept > 0) this.dept = dept; } public double getPayRate() { return payRate; } public void setPayRate(double payRate) { if (payRate >= 0) this.payRate = payRate; } ---- C O D E O M I T T E D ---- }

The Employee class should protect itself from bad incoming data, so the setPayRate method simply ignores a value less than 0. A better practice, which we will add later, would be to throw an exception when an illegal value is passed in. Note the benefit of coding the constructors to use the setPayRate method; we do not have to go back and revise their code as well. (setDept has similar changes.)

Solution:

Solutions/Payroll-Control01/Payroll.java

import employees.*; import util.*; public class Payroll { public static void main(String[] args) { Employee e1 = null, e2 = null, e3 = null; String fName = null; String lName = null; int dept = 0; double payRate = 0.0; fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); dept = KeyboardReader.getPromptedInt("Enter department: "); if (dept <= 0) { System.out.println("Department must be > 0"); dept = 0; } payRate = KeyboardReader.getPromptedDouble("Enter payRate: "); if (payRate < 0.0) { System.out.println("Pay rate must be >= 0"); payRate = 0.0; } e1 = new Employee(fName, lName, dept, payRate); System.out.println(e1.getPayInfo()); ---- C O D E O M I T T E D ---- } }

Even though Employee now protects itself from illegal incoming values, it should really be the responsibility of the progmmers for the classes using Employee to avoid sending it bad values. So, the payRate value is tested here as well. While this may seem to decrease efficiency (since, presumably, a non-object-oriented program might be able to avoid testing the value twice in a row), the maintainability aspects of OOP are still considered to outweigh the loss in efficiency.

Two Mutually Exclusive Branches

---

The if ... else Statement

if (condition) statement; else if { block } statement; else { block }

The if ... else Statement does "one thing" if a condition is true, and a different thing if it is false.

It is never the case that both things are done. The "one thing" may be a single statement or a block of statements in curly braces.

A statement executed in a branch may be any statement, including another if or if ... else statement.

This program tells you that you are a winner on average once out of every four tries.

Code Sample:

Java-Control/Demos/IfElse1.java

public class IfElse1 { public static void main(String[] args) { double d = Math.random(); if (d & .25) System.out.println("You are a winner!"); else System.out.println("Sorry, try again!"); } }

Nested if ... else Statements - Comparing a Number of Mutually Exclusive Options

You can nestif ... else statements, so that an if or else clause contains another test. Both the if and the else clause can contain any type of statement, including another if or if ... else.

You can test individual values or ranges of values. Once an if condition is true, the rest of the branches will be skipped. You could also use a sequence of if statements without the else clauses (but this doesn't by itself force the branches to be mutually exclusive).

Here is the low/middle/high example rewritten using if ... else

Code Sample:

Java-Control/Demos/IfElse2.java

public class IfElse2 { public static void main(String[] args) { double d = Math.random(); System.out.print("The number " + d); if (d < 1.0/3.0) System.out.println(" is low"); else if (d < 2.0/3.0) System.out.println(" is middle"); else System.out.println(" is high"); } }

Similarly, we do not test the high third at all. The original version worked because there was no chance that more than one message would print; that approach is slightly less efficient because all three tests will always be made. In the if ... else version, comparing stops once a match has been made.

Game02: A Revised Guessing Game

---

Duration: 10 to 15 minutes.

1. Revise your number guessing program to use if . . . else logic (you can test for too low and too high, and put the message for correct in the final else branch).
2. Once you have done that, here is a way to generate a random answer between 1 and 100:

1.At the top:

import java.util.*;

2.Add a private field for a random number generator:

private Random r = new Random();

1.Then, you can initialize the answer field:

answer = r.nextInt(100) + 1;

the nextInt(int n) method generates a number greater than or equal to 0 and less than n, so r.nextInt(100) would range from 0 through 99; we need to add 1 to raise both ends of the range.

4.You might want to print the expected correct answer to aid debugging.

Note that until we cover looping, there will be no way to truly "play" the game, since we have no way to preserve the value between runs.

Solution:

Solutions/Game02/Game.java

import util.*; import java.util.*; public class Game { private Random r = new Random(); private int answer = r.nextInt(100) + 1; public void play() { System.out.println(answer); int guess; guess = KeyboardReader.getPromptedInt("Enter a number 1 -100: "); if (guess < answer) System.out.println("Too low"); else if (guess > answer) System.out.println("Too high"); else System.out.println("Correct!"); } public static void main(String[] args) { new Game().play(); } }

Comparing a Number of Mutually Exclusive options - The switch Statement

---

The switch Statement

A switch expression (usually a variable) is compared against a number of possible values. It is used when the options are each a single, constant value that is exactly comparable (called a case).

The switch expression must be a byte, char, short, or int. Cases may only be byte, char, short, or int values; in addition, their magnitude must be within the range of the switch expression data type and cannot be used with floating-point datatypes or long and cannot compare an option that is a range of values, unless it can be stated as a list of possible values, each treated as a separate case.

Cases are listed under the switch control statement, within curly braces, using the case keyword. Once a match is found, all executable statements below that point are executed, including those belonging to later cases; this allows stacking of multiple cases that use the same code.

The break; statement is used to jump out of the switch block, thus skipping executable steps that are not desired. The default case keyword catches all cases not matched above - note that the default case does not need to be the last thing in the switch. Note that technically speaking, the cases are labeled lines; the switch jumps to the first label whose value matches the switch expression.

Usage

switch ( expression ) { case constant1: statements; break; case constant2: statements; break; . . . case constant3: case constant4: MeansTheSameAs3: statements; break; . . . [default: statements;] }

switch Statement Examples

Code Sample:

Java-Control/Demos/Switch1.java

import util.KeyboardReader; public class Switch1 { public static void main(String[] args) { char c = 'X'; c = KeyboardReader.getPromptedChar("Enter a letter a - d: "); switch (c) { case 'a': case 'A': System.out.println("A is for Aardvark"); break; case 'b': case 'B': System.out.println("B is for Baboon"); break; case 'c': case 'C': System.out.println("C is for Cat"); break; case 'd': case 'D': System.out.println("D is for Dog"); break; default: System.out.println("Not a valid choice"); } } }

Three points to note:

• Stacking of cases for uppercase and lowercase letters allows both possibilities.
• break; statements used to separate code for different cases.
• default: clause used to catch all other cases not explicitly handled.

Here is a revised version that moves the default to the top, so that a bad entry is flagged with an error message, but then treated as an 'A' - note that there is no break below the default case.

Code Sample:

Java-Control/Demos/Switch2.java

import util.KeyboardReader; public class Switch2 { public static void main(String[] args) { char c = 'X'; c = KeyboardReader.getPromptedChar("Enter a letter a - d: "); switch (c) { default: System.out.println("Not a valid choice - assuming 'A'"); case 'a': case 'A': System.out.println("A is for Aardvark"); break; case 'b': case 'B': System.out.println("B is for Baboon"); break; case 'c': case 'C': System.out.println("C is for Cat"); break; case 'd': case 'D': System.out.println("D is for Dog"); break; } } }

Another example is taking advantage of the "fall-though" behavior without a break statement.

Code Sample:

Java-Control/Demos/Christmas.java

import util.KeyboardReader; public class Christmas { public static void main(String[] args) { int day = KeyboardReader.getPromptedInt("What day of Christmas? "); System.out.println( "On the " + day + " day of Christmas, my true love gave to me:"); switch (day) { case 12: System.out.println("Twelve drummers drumming,"); case 11: System.out.println("Eleven pipers piping,"); case 10: System.out.println("Ten lords a-leaping,"); case 9: System.out.println("Nine ladies dancing,"); case 8: System.out.println("Eight maids a-milking,"); case 7: System.out.println("Seven swans a-swimming,"); case 6: System.out.println("Six geese a-laying,"); case 5: System.out.println("Five golden rings,"); case 4: System.out.println("Four calling birds,"); case 3: System.out.println("Three French hens,"); case 2: System.out.println("Two turtle doves, and a "); case 1: System.out.println("Partridge in a pear tree!"); } } }

Game03: Multiple Levels

---

Duration: 15 to 30 minutes. What if we want to offer gamers multiple levels of difficulty in our game? We could make the random number multiplier a property of the Game class, and set a value into it with a constructor, after asking the user what level they'd like to play.

1. Add a range field to the Game class (an int).
2. Add a constuctor that accepts a level parameter; use a char.
3. Within that constructor, use a switch to process the incoming level:
• Uppercase or lowercase B means Beginner, set the range to 10.
• I means Intermediate; set the range to 100.
• A means Advanced; set the range to 1000.
• Any other value results a Beginner game; after all, if they can't answer a simple question correctly, how could we expect them to handle something more advanced.
• You could put the default option stacked above the "B" cases, so that you can print an error message and then fall through to the 'B' logic
4. object's nextInt method (move the logic that creates the Random object and generates the answer to this constructor).
5. Add a default constructor that calls this new constructor, passing 'I' for intermediate.
6. The prompt given by the play method should now take the range into account.
7. In the main method, ask the user for the level and call the new constructor with their response.

Solution:

Solutions/Game03/Game.java

import util.*; import java.util.*; public class Game { private Random r = new Random(); private int answer; private int range = 10; public Game() { this('I'); } public Game(char level) { switch (level) { default: System.out.println("Invalid option: " + level + ", using Beginner"); case 'b': case 'B': range = 10; break; case 'i': case 'I': range = 100; break; case 'a': case 'A': range = 1000; break; } Random r = new Random(); answer = r.nextInt(range) + 1; //System.out.println(answer); } public void play() { int guess; guess = KeyboardReader.getPromptedInt("Enter a number 1 - " + range + ": "); if (guess < answer) System.out.println("Too low"); else if (guess > answer) System.out.println("Too high"); else System.out.println("Correct!"); } public static void main(String[] args) { char level = KeyboardReader.getPromptedChar("What level (B, I, A)? "); new Game(level).play(); } }

The switch tests for the three letters, stacking cases for uppercase and lowercase values. The default catches all other responses and falls through to the Beginner logic.

Comparing Objects

---

The operators == and != test if two references point to exactly the same object in memory; they test that the numeric values of the two references are the same.

The equals(Object o) method compares the contents of two objects to see if they are the same (you can override this method for your classes to perform any test you want).

When comparing two objects, the == operator compares the references and not the values of the objects. Similarly, != tests to see if the references point to two different objects (even if they happen to have the same internal values).

The Object class defines an equals(Object) method intended to compare the contents of the objects. The code written in the Object class simply compares the references using ==. This method is overridden for most API classes to do an appropriate comparison. For example, with String objects, the method compares the actual characters up to the end of the string. For classes you create, you would override this method to do whatever comparisons you deem appropriate.

Code Sample:

Java-Control/Demos/Rectangle.java

public class Rectangle { private int height; private int width; public Rectangle(int height, int width) { this.height = height; this.width = width; } public int getArea() { return height * width; } public boolean equals(Object other) { if (other instanceof Rectangle) { Rectangle otherRect = (Rectangle) other; return this.height == otherRect.height && this.width == otherRect.width; } else return false; } }

The equals method compares another object to this object.

This example is necessarily somewhat complicated. It involves a few concepts we haven't covered yet, including inheritance. Because the equals method inherited from Object, it takes a parameter which is an Object, we need to keep that that type for the parameter (technically, we don't need to do it by the rules of Java inheritance, but because other tools in the API are coded to pass an Object to this method). But, that means that someone could call this method and pass in something else, like a String.

So, the first thing we need to do is test that the parameter was actually a Rectangle. If so, we can work with it; if not, there is no way it could be equal, so we return false.

We will cover instanceof later, but, for now, we can assume it does what it implies: test that the object we received was an instance of Rectangle. Even after that test, in order to treat it as a Rectangle, we need to do a typecast to explicitly store it into a Rectangle variable (and again, we will cover object typecasting later). Once we have it in a Rectangle variable, we can check its height and width fields.

In yet another complication, if we write an equals method, we should really write a public int hashcode() method as well, since their meanings are interrelated; two elements that compare as equal should produce the same hashcode.

As an aside, note that private data in one instance of a class is visible to other instances of the same class; it is only otherclasses that cannot see the private elements.

Code Sample:

Java-Control/Demos/ObjectEquivalenceIdentity.java

class ObjectEquivalenceIdentity { public static void main(String[] args) { Rectangle r1 = new Rectangle(10, 20); Rectangle r2 = new Rectangle(10, 20); if (r1 == r2) System.out.println("Same object"); else System.out.println("Different objects"); if (r1.equals(r2)) System.out.println("Equal"); else System.out.println("Not equal"); } }

Since all the important work is done in Rectangle, all we need to do here is instantiate two and compare them using both == and the equals method to see the differing results.

The output should be:

Different objects Equal

Testing Strings for Equivalence

Example - write a brief program which has a word stored as a string of text. Print a message asking for a word, read it, then test if they are the same or not.

• you can preset the message assuming that they are incorrect, then change it if they are correct

Code Sample:

Java-Control/Demos/StringEquals.java

import util.KeyboardReader; public class StringEquals { public static void main(String[] args) { String s = "Hello"; String t = KeyboardReader.getPromptedString("Enter a string: "); String message = "That is incorrect"; if (s.equals(t)) message = "That is correct"; System.out.println(message); } }

• try this, then change equals(t) to equalsIgnoreCase(t)

Conditional Expression

---

Java uses the same conditional expression as C and C++

condition ? expressionIfTrue : expressionIfFalse

This performs a conditional test in an expression, resulting in the first value if the condition is true,or the second if the condition is false

Note: due to operator precedence issues, it is often best to enclose the entire expression in parentheses

Example

Code Sample:

Java-Control/Demos/Conditional.java

public class Conditional { public static void main(String[] args) { int i = -6; String s; s = "i is " + ((i >= 0) ? "positive" : "negative"); System.out.println(s); } }

Note that the parentheses around the test are not necessary by the operator precedence rules, but may help make the code clearer

The parentheses around the entire conditional expression are necessary; without them, precedence rules would concatenate the boolean result onto the initial string, and then the ? operator would be flagged as an error, since the value to its left would not be a boolean.

while and do . . . while Loops

Again, the loops in Java are pretty much the same as in C - with the exception that the conditional expressions must evaluate to only boolean values

while loops

while (condition) statement;

or

while (condition){ block of statements }

• continues as long as the expression evaluates to true
• the condition is evaluated before the start of each pass
• it is possible that the body of the loop never executes at all (if the condition is false the first time)

do ... while loops do statemen; while (condition);

or

do { block of statements } while (condition;

• evaluated after the end of each pass
• the body of the loop will always execute at least once, even if the condition is false the first time

for Loops

A for loop uses a counter to progress through a series of values

• a value is initialized, tested each time through, and then modified (usually incremented) at the end of each pass, before it is tested again
• the for loop does not do anything that cannot be done with a while loop, but it puts everything that controls the looping at the top of the block

---

for (initialize; condition; change) statement

or

for (initialize; condition<; change) { block of statements }

for loops can use a variable declared out side of the control portion of the loop or in the control portion. The latter gives the variable block-level scope (existing only for the duration of the loop)

int j; for (j = 0; j < 12; j++ ) System.out.print("j = " + j); for (int j = 0; j < 12; j++ ) System.out.print("j = " + j);

A for loop may use multiple control variables by using the sequence operator, the comma ( , )

for (int j = 0, k = 12; j <= 12; j++, k-- ) System.out.println(j + " " + k);

Note: if you use a block-scope variable (such as above) for the first counter, the additional ones will be block scope as well, and also will be the same type of data - i.e., the variable k above also exists only for the duration of the block. There is no way to declare two counters of different types at block-level scope.

Note that neither while nor do . . . while loops allow declaring a looping variable with this type of scope. The looping variable must be declared in advance.

ForEach Loops

Java 5 introduced a new type of loop, the for-each loop. When you have an array or collection class instance, you can loop through it using a simplified syntax

for (type variable : arrayOrCollection) { body of loop }

The looping variable is not a counter - it will contain each element of the array or collection in turn (the actual value and not an index to it, so its type should be the same as the type of items in the array or collection). You can read the : character as if it is the word "from". We will cover this type of loop in more depth in the Arrays section.

For some reason, the looping variable must be declared within the parentheses controlling the loop - you cannot use a preexisting variable.

Since the looping variable is a local variable, it gets a copy of each value from the array or collection. Therefore you cannot use the ForEach loop to write values back to the array/collection - assigning a new value to the variable in the body of the loop is only overwriting the local copy.

Code Sample:

Java-Control/Demos/Loops1.java

public class Loops1 { public static void main(String[] args) { int i = 1; System.out.println("While loop:"); while (i <= 512) { System.out.println("i is " + i); i *= 2; } System.out.println("i is now " + i); System.out.println("Do while loop:"); do { i = i - 300; System.out.println("i is now " + i); } while (i > 0); System.out.println("For loop:"); for (i = 0; i < 12; i++) System.out.print(" " + i); System.out.println(); System.out.println("For loop that declares a counter:"); for (int j = 0; j < 12; j++) System.out.print(" " + j); System.out.println(); System.out.println("ForEach loop:"); String[] names = { "Jane", "John", "Bill" }; for (String oneName : names) System.out.println(oneName.toUpperCase()); } }

Additional Loop Control: break and continue

---

Breaking Out of a Loop

The break statement will end a loop early and execution jumps to the first statement following the loop. The following example prints random digits until a random value is less than 0.1.

Code Sample:

Java-Control/Demos/Break.java

public class Break { public static void main(String[] args) { for ( ; ; ) { // creates an infinite loop // no initialization, no test, no increment double x = Math.random(); if (x < 0.1) break; System.out.print((int) (x * 10) + " "); } System.out.println("Done!"); } }

This code loops, generating and printing a random number for each iteration. If the number is less than 0.1, we break out before printing it.

Code Sample:

Java-Control/Demos/BreakNot.java

public class BreakNot { public static void main(String[] args) { double x = 0.0; for ( x = Math.random(); x >= 0.1; x = Math.random() ) { System.out.print((int) (x * 10) + " "); } System.out.println("Done!"); } }

This code avoids the break, by creating and testing the random number in the control part of the loop. As part of the iteration condition, if the number is less than 0.1, the loop simply ends "normally".

Continuing a Loop

---

If you need to stop the current iteration of the loop, but continue the looping process, you can use the continue statement. Note that:

• It is normally based on a condition of some sort.
• Execution skips to the end of this pass, but continues looping.
• It is usually a better practice to reverse the logic of the condition, and place the remainder of the loop under control of the if statement.

Example - a program to enter 10 non-negative numbers

Code Sample:

Java-Control/Demos/Continuer.java

import util.*; public class Continuer { public static void main(String[] args) { int count = 0; do { int num = KeyboardReader.getPromptedInt("Enter an integer: "); if (num < 0) continue; count++; System.out.println("Number " + count + " is " + num); } while (count < 10); System.out.println("Thank you"); } /* // a better way public static void main(String[] args) { int count = 0; do { int num = KeyboardReader.getPromptedInt("Enter an integer: "); if (num >= 0) { count++; System.out.println("Number " + count + " is " + num); } } while (count < 10); System.out.println("Thank you"); } */ }

A better way to handle the loop is shown in the commented out version of main - try removing the comment and comment out the original method.

But,continue is easier to use in nested loops, because you can label the level that will be continued

break and continue in Nested Loops

In normal usage, break and continue only affect the current loop; a break in a nested loop would break out of the inner loop, not the outer one

But, you can label a loop, and break or continue at that level. A label is a unique identifier followed by a colon character.

Try the following example as is, then reverse the commenting on the break lines

Code Sample:

Java-Control/Demos/BreakOuter.java

public class BreakOuter { public static void main(String[] args) { outer: for (int r = 0; r < 10; r++) { for (int c = 0; c < 20; c++) { double x = Math.random(); //if (x < 0.02) break; if (x < 0.02) break outer; System.out.print((int) (x * 10) + " "); } System.out.println(); } System.out.println("Done!"); } }

Game04: Guessing Game with a Loop

---

Duration: 10 to 20 minutes.
(Optional)

1. Revise the number guessing program to force the user to guess until they are correct (loop-wise, to keep guessing as long as they are incorrect).
2. Then add more logic to ask if they want to play again, read a Y or N as their answer, and loop as long as they enter a Y.

Solution:

Solutions/Game04/Game.java

import util.*; import java.util.*; public class Game { ---- C O D E O M I T T E D ---- public void play() { int guess; do { guess = KeyboardReader.getPromptedInt("Enter a number 1 -100: "); if (guess < answer) System.out.println("Too low"); else if (guess > answer) System.out.println("Too high"); } while (guess != answer); System.out.println("Correct!"); } public static void main(String[] args) { char playAgain = 'Y'; do { char level = KeyboardReader.getPromptedChar("What level (B, I, A)? "); new Game(level).play(); playAgain = KeyboardReader.getPromptedChar("Play again (y/n)?: "); } while (playAgain == 'Y' || playAgain == 'y'); } }

Payroll-Control02: Payroll With a Loop

---

Duration: 20 to 40 minutes.

1. Revise your payroll program to use only one Employee variable.
2. Use a loop to repeatedly create a new instance to store in it, populate it from the keyboard, and display it on the screen (you can ask after each one if the user wants to enter another, or just use a loop that has a fixed number of iterations).
3. Also, change the logic for reading the pay rate and department values from the keyboard to use do . . . while loops that will continue to loop as long as the user enters invalid values (note that you will need to separate declaring the variables from populating them - declare each of them before their loop starts, in order for the variable to be available to the test at the end of the loop).

Solution:

Solutions/Payroll-Control02/Payroll.java

import employees.*; import util.*; public class Payroll { public static void main(String[] args) { Employee e = null; String fName, lName; int dept; double salary; for (int i = 0; i < 3; i++) { fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); >do { dept = KeyboardReader.getPromptedInt("Enter department: "); if (dept <= 0) System.out.println("Department must be >= 0"); } while (dept <= 0); do { salary = KeyboardReader.getPromptedDouble("Enter pay rate: "); if (salary < 0.0) System.out.println("Pay rate must be >= 0"); } while (salary < 0.0); e = new Employee(fName, lName, dept, salary); System.out.println(e.getPayInfo()); } } }

Classpath, Code Libraries, and Jar Files

---

By now, you may have noticed that every demo and solution folder contains its own copy of util and KeyboardReader. Not only is it inefficient, but it means that we would have to locate and update each copy if we wanted to change KeyboardReader.

A better solution would be to have one master copy somewhere that all of our exercises could access.

Using CLASSPATH
Java has a CLASSPATH concept that enables you to specify multiple locations for .class files, at both compile-time and runtime.

By default, Java uses rt.jar in the current Java installation's jre/lib directory, and assumes that the classpath is the current directory (the working directory in an IDE).
If you create a classpath, the default one disappears, so any classpath that you create must include the current directory using a period (.) character.

To use an external library, you would need to create a classpath in one of two ways:

1. you can create a system or user environment variable, with multiple directories and/or .jar files, separated by the same delimiter used by your PATH (a semicolon in Windows).
2. You could use the -classpath option in java and javac (-cp is a shorthand version of that).

Here is an example of a pair of commands to compile and run using an external library stored in a jar file. Note that we need the jar file at both compile-time and runtime. The -cp option in both commands replaces the system classpath with one specifically for that command.

javac -cp c:\Java102\ClassFiles\utilities.jar;. *.java java -cp c:\Java102\ClassFiles\utilities.jar;. Payroll

Many Integrated Development Environments (IDEs) have a means to specify project properties; usually an item like "Build Path" will have options to specify external jar files (as well as choose from various libraries supplied with the environment).

Creating a jar File (a Library)
If you wish to create your own library of useful classes, you can bundle one or more classes and/or directories of classes in a jar file. Yyou can also add other resources such as image files.

A jar file contains files in a zipped directory structure. The root level of the file structure should match the root of the package structure; for example, to put KeyboardReader in a jar file, we would want to start at the directory where util is visible, and jar that

The following command will create a jar file called utilities.jar for all files in the util package (just KeyboardReader, in this case).

jar -cvf utilities.jar util\*.class

The options are create, verbose, and use a list of files supplied at the end of the command.

Creating and Using an External Library

---

Duration: 5 to 10 minutes.
1. Run the command shown above to create utilities.jar.
2. Move utilities.jar to the ClassFiles directory in your filesystem.
3. If you remove the util directory from Payroll-Control02, you will not be able to compile or run Payroll as we have been doing.
4. But, you should be able to compile and run by specifiying a classpath option as shown in the commands above.
5. You can also temporarily modify the classpath for the duration of your command prompt window as follows (note that you may need to modify the line below to match your setup):

set <h3>Compiling to a Different Directory</h3> <hr style="border: solid 1px"> <p>You can supply a destination directory to the Java compiler, in order to keep your source and compiled files separate:</p> <textarea>javac -d destination FileList

The destination directory can be a relative path from the current directory, or an absolute path. It must already exist, but any subdirectories necessary for package structures will be created.

Also, if you have existing compiled files in the source directories (like employees/Employee.class), then the compiler won't recompile those classes (and therefore they won't end up in the destination path) unless they are older than the associated .java file. You would need to "clean" the directories by deleting the .class files first.

CLASSPATH=%CLASSPATH%;c:\Java102\ClassFiles\utilities.jar

10 - JAVA ARRAYS

Defining and Declaring Arrays

---

An array stores a group of data items all of the same type.

An array is an object.

• An array variable does not actually store the array - it is a reference variable that points to an array object.
• Declaring the array variable does not create an array object instance; it merely creates the reference variable - the array object must be instantiated separately.
• Once instantiated, the array object contains a block of memory locations for the individual elements.
• If the individual elements are not explicitly initialized, they will be set to zero.
• Arrays can be created with a size that is determined dynamically (but once created, the size is fixed).
Declare an array variable by specifying the type of data to be stored, followed by square brackets [].

dataType[] variableName;

You can read the [] as the word "array".

To declare a variable for an array of integers:

int[] nums;

..which you can read as "int array nums".

To declare a variable for an array of String objects:

String[] names;

...which you can read as "String array names" - the array holds String references.

You may also put the brackets after the variable name (as in C/C++), but that is less clearly related to how Java actually works.

int nums[]; // not recommended, but legal

But, that syntax does allow the following, which is legal, but seems like a bad practice.

int nums[], i, j; // declares one array and two single int values

Instantiating Arrays

---

Instantiate an array object using new, the data type, and an array size in square brackets

int[] nums; nums = new int[10];

The second line constructs a new array object with 10 integer elements, all initialized to 0, and stores the reference into nums.

int[] moreNums; int size = 7; moreNums = new int[size];

You can declare and instantiate all at once:

String[] names = new String[3];

The elements of the array, String references, are initialized to null.

As objects, arrays also have a useful property: length:
• In the above example, names.length would be 3.
• The property is fixed (i.e., it is read-only).
You can reassign a new array to an existing variable:

int[] nums; nums = new int[10]; nums = new int[20];

The original ten-element array is no longer referenced by nums, since it now points to the new, larger array.

Initializing Arrays

---

An array can be initialized when it is created

The notation looks like this:

String[] names = { "Joe", "Jane", "Herkimer" };

or

String[] names = new String[] {"Joe", "Jane", "Herkimer" };

This automatically creates an array of length 3, because there were 3 items supplied.

int[] nums = new int[] { 2, 4, 6, 8, 10, 12 };

This array will have a length of 6.

If a new array is being assigned to an existing variable, you cannot use the shorter variant, you must use the new keyword and the data type:

String[] names; names = new String[] {"Joe", "Jane", "Herkimer" };

For arrays of other types of objects:

Book[] titles; titles = new Book[] { new Book(5011,"Fishing Explained"), new Book(1234, "Help is on the Way") };

Working With Arrays

---

Array elements are accessed through the array reference, by their array index:
• The index is the element number, placed within brackets.
• Elements are numbered from 0 to one less than the specified size.

String[] names = new String[3];

The valid elements are 0, 1, and 2, as in:

names[0] = "Sam"; names[1] = "Sue"; names[2] = "Mary";

You could access array elements in a for loop with:

for (int i = 0; i < 3; i++) System.out.println(names[i]);

Or, better programming practice would be to use the length property:

for (int i = 0; i < names.length; i++) System.out.println(names[i]);

The compiler does not check to ensure that you stay within the bounds of the array, but the JVM does check at runtime - if you try to exceed the bounds of the array, an exception will occur.

Note that a zero-length array is valid:

Book[] titles = new Book[] { }; Book[] moreTitles = new Book[0];

You might create a zero-length array as the return value from a method typed as returning an array, when there are no items to return (as opposed to returning null).

Code Sample:

Java-Arrays/Demos/Arrays1.java

import java.util.*; public class Arrays1 { public static void main(String[] args) { Random r = new Random(); int[] nums = new int[10]; for (int i = 0; i < nums.length; i++) { nums[i] = r.nextInt(100); } System.out.println("Element 7 is: " + nums[7]); String[] names = new String[3]; names[0] = "Joe"; names[1] = "Jane"; names[2] = "Herkimer"; for (int i = 0; i < names.length; i++) { System.out.println(names[i]); } //this line should throw an exception System.out.println(names[6]); } }

Array Variables

---

The array as a whole can be referenced by the array name without the brackets, for example, as a parameter to or return value from a function

Code Sample:

Java-Arrays/Demos/Arrays2.java

public class Arrays2 { public static void main(String[] args) { String[] names = new String[3]; names[0] = "Joe"; names[1] = "Jane"; names[2] = "Herkimer"; printArray(names); } public static void printArray(String[] data) { for (int i = 0; i < data.length; i++) { System.out.println(data[i].toUpperCase()); } } }

The array names is passed to printArray, where it is received as data.

Note also the syntax to access a method directly for an array element: data[i].toUpperCase()

Since an array reference is a variable, it can be made to refer to a different array at some point in time

String[] names = new String[3]; names[0] = "Joe"; names[1] = "Jane"; names[2] = "Herkimer"; printArray(names); names = new String[2]; names[0] = "Rudolf"; names[1] = "Ingrid"; printArray(names);

Copying Arrays

---

You can use System.arraycopy to copy an array into another.

You might do this to expand an array by creating a larger one and copying the contents of the smaller one into it (but any references to the original array will need to be changed to point to the new array).

The declaration is:

public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)

Code Sample:

Java-Arrays/Demos/CopyArray.java

// puts two copies of a small array into a larger one public class CopyArray { public static void main(String[] args) { int nums[] = { 6, 2, 4, 9, 1 }; int biggerNums[] = new int[10]; System.arraycopy(nums, 0, biggerNums, 0, nums.length); System.arraycopy(nums, 0, biggerNums, nums.length, nums.length); for (int i = 0; i < biggerNums.length; i++) System.out.println(biggerNums[i]); } }

• The first arraycopy line copys from nums into the first half of biggerNums. The number of items copied is determined by nums.length
System.arraycopy(nums, 0, biggerNums, 0, nums.length);
• The second arraycopy line again copys from nums, but now into the second half of biggerNums. The starting location for the "paste" is nums.length, since that is where we left off the first time. And the number of items copied is again determined by nums.length
System.arraycopy(nums, 5, biggerNums, nums.length, nums.length);

Using the args Array

---

Duration: 5 to 10 minutes.
1. Note that there has been an array declaration in all of our examples thus far; the array of strings passed to main: args
• These are the additional words on the command line.
2. Copy Hello.java to HelloArgs.java, and modify that to loop through args to print each element (remember to rename the class in the declaration line).
3. Then run the program with something like java HelloArgs From Me and see what happens.

Solution:

Solutions/Arrays/HelloArgs.java

public class HelloArgs { public static void main(String[] args) { // using indexed loop for (int i = 0; i < args.length; i++) System.out.println(args[i]); // using foreach loop for (String a : args) System.out.println(a); } }

The for loop iterates through the array; each separate word on the command line becomes one element in the array (note that java HelloArgs is not part of the array).

Game-Arrays01: A Guessing Game with Random Messages

---

15 20 (Optional - if time permits)
• Modify your guessing game program to hold an array of several different String messages, all of which have some form of message for "Correct".
• Generate a random number in the range from 0 to the size of the array.
• Use this value to select one message to print when they guess correctly.
• Continue this approach for "Too Low" and "Too High".

import util.*; import java.util.*; public class Game { private int answer = 67; private static String [] correctMessages = { "Correct", "Right on!", "Most Excellent!" }; private static String [] lowMessages = { "Too low", "Try higher next time" }; private static String [] highMessages = { "Too high", "Try lower next time" }; public Game() { Random r = new Random(); answer = r.nextInt(100) + 1; System.out.println(answer); } public void play() { int guess; Random r = new Random(); do { guess = KeyboardReader.getPromptedInt("Enter a number 1 -100: "); if (guess < answer) System.out.println(lowMessages[r.nextInt(lowMessages.length); else if (guess > answer) System.out.println(highMessages[r.nextInt(highMessages.length); } while (guess != answer); System.out.println(correctMessages[r.nextInt(correctMessages.length); } public static void main(String[] args) { char playAgain = 'Y'; do { new Game().play(); playAgain = KeyboardReader.getPromptedChar("Play again (y/n)?: "); } while (playAgain == 'Y' || playAgain == 'y'); } }

There are three arrays of messages; note that they are not all the same size. The code to handle too high, too low, and correct generates a random number between 0 and the appropriate array's length, by using the Random object's nextInt method, and passing the length of the array.

Arrays of Objects

---

If an array contains objects, those objects' properties and methods may be accessed.

The notation uses the array variable name, the index in brackets, a dot, and the property or method.

Java-Arrays/Demos/Arrays2.java

Code Sample:

public class Arrays2 { public static void main(String[] args) { String[] names = new String[3]; names[0] = "Joe"; names[1] = "Jane"; names[2] = "Herkimer"; printArray(names); } public static void printArray(String[] data) { for (int i = 0; i < data.length; i++) { System.out.println(data[i].toUpperCase()); } } }

Payroll-Arrays01: An Array of employees

---

Duration: 20 to 30 minutes.
1. Modify the payroll program to use an array of Employee objects with a size of 3 or more (later we will come up with a more flexible solution that allows for the number of employees to change dynamically).
2. Use a for loop to populate and display the data.
3. After the loop is complete, ask the user to enter a last name.
4. Loop through the array to find the element with the matching last name and display it.

Solution:

Solutions/Payroll-Arrays01/Payroll.java

import employees.*; import util.*; public class Payroll { public static void main(String[] args) { Employee[] e = new Employee[5]; String fName = null; String lName = null; int dept = 0; double payRate = 0.0; for (int i = 0; i < e.length; i++) { fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); do { dept = KeyboardReader.getPromptedInt("Enter department: "); if (dept <= 0) System.out.println("Department must be >= 0"); } while (dept <= 0); do { payRate = KeyboardReader.getPromptedDouble("Enter pay rate: "); if (payRate < 0.0) System.out.println("Salary must be >= 0"); } while (payRate < 0.0); e[i] = new Employee(fName, lName, dept, payRate); System.out.println(e[i].getPayInfo()); } lName = KeyboardReader.getPromptedString("Enter last name to find: "); boolean notFound = true; for (int i = 0; i < e.length; i++) { if (lName.equalsIgnoreCase(e[i].getLastName())) { System.out.println("Found: " + e[i].getPayInfo()); notFound = false; break; } } if (notFound) System.out.println("Not found"); } }

The code uses e[i].getPayInfo() to print the pay information for employee i. Element i of the array is one employee reference. It uses the same approach to call e[i].getLastName() for each employee to compare with the requested name.

Enhanced for Loops - the For-Each Loop

---

Java 5 introduced the for-each loop, which loops through a collection of values without using an index. Instead, the loop variable repesents each individual value.

The syntax uses a loop variable and a collection of values, separated by a colon character (which can be read as the word "from"). Some things to note:


• The collection of values can be any array or an instance of one of the Java Collections classes (to be discussed later)
• The looping variable must be declared in the parentheses that create the loop - you cannot use a preexisting variable as the loop variable
• The looping variable will represent each item from the collection or array in turn.

for (dataType loopVariable : collectionOfSameType) code using loopVariable;

You cannot write into the array using a for-each loop. The looping variable you declare receives a copy of the data in the array, so, if you change its value, you are only changing the local copy.

Multi-Dimensional Arrays

---

Arrays may have more than one dimension, for such things as:
• A graphic image that is x pixels across and y pixels vertically.
• Weather information modeled in a 3-dimensional space, with measurements for these axes: North/South, East/West, and altitude.
Declare a multidimensional array as:

datatype[][] ... [] arrayName;

Arrays are objects, and, like other objects, declaring a variable does not instantiate the array - that must be done separately. To instantiate a multidimensional array:

arrayName = new datatype[size1][size2] ... [sizeN];

The most significant dimension is listed first; the least significant dimension listed last.

The code below could be used to declare an array to store an image that is 640 pixels across and 480 pixels down - in a graphic the image data is stored sequentially across each row; each row is a 640 pixel block; there are 480 of these blocks in our image:

int[][] picture = new int[480][640];

This code might be used for an image where the data is stored in three layers, each of which is an entire 480 by 640 array:

int[][][] picture = new int[3][480][640];

Multidimensional Arrays in Memory

---

Recall that a matched pair of brackets after a data type means:
• The array contains elements of that type.
• The array itself is a type of data.
• So a two-dimensional array written as this:

int[][] nums; ...could be thought of as an array of integer arrays, as if it were written as (note that this is not legal syntax): (int[])[] nums; In Java, a two-dimensional array is actually a single array of array reference variables, each of which points to a single dimensional array. To extend the example above: int[][] nums = new int[3][6]; This is an array of 3 elements, each of which is an array of 6 int elements as shown in the diagram below:

Note that it is possible to replace any of the one-dimensional elements with a different one, or that the second-dimension arrays each have a different length - the following line would replace one of the arrays with another of a different length

nums[1] = new int[4];

Example - Printing a Picture

---

This example uses a two-dimensional array preloaded with text characters that make up a picture
• There is a loop that processes each row (the first, or most significant, dimension of the array, each element of which is an array of characters).
• Within that loop, another loop prints each character without ending the line.
• Then, when the inner loop is done, a newline is printed.

Code Sample:

Java-Arrays/Demos/ArrayPicture.java

public class ArrayPicture { public static void main(String[] args) { char[][] imgData = new char[][] { { ' ',' ',' ',' ',' ',' ',' ' }, { ' ',' ',' ','0',' ',' ',' ' }, { ' ',' ',' ','|',' ',' ',' ' }, { ' ','0','-','+','-','0',' ' }, { ' ',' ',' ','|',' ',' ',' ' }, { ' ',' ',' ','0',' ',' ',' ' }, { ' ',' ',' ',' ',' ',' ',' ' } }; for (int row = 0; row < imgData.length ; row++ ) { for (int col = 0; col < imgData[row].length; col++ ) { System.out.print(imgData[row][col]); } System.out.println(); } } }

Because multi-dimensional arrays are implemented as arrays of array references, it is possible to partially instantiate an array:

int[][] nums = new int[3][];

This creates nums as a two-dimensional array (better viewed in this case as an array of array references), and creates an array holding three null references to integer arrays

Typecasting with Arrays of Primitives

---

It is not possible to typecast an array of one type of primitive to an array of another type of primitive. For example, the following will cause compiler errors if the comment marks are removed:

Code Sample:

Java-Arrays/Demos/ArrayTypecast.java

// typecasts with arrays public class ArrayTypecast { public static void main(String[] args) { int i = 5; double d; d = i; i = (int) d; int inums[] = { 1, 2, 3, 4, 5 }; double[] dnums; // line below fails //dnums = inums; dnums = new double[] { 1.1, 2.2, 3.3, 4.4 }; // line below fails //inums = (int[]) dnums; } }

Neither an implicit or explicit typecast can be performed. With a single int i, the copy of it that is given to d can be expanded to a double. But, with the int[] inums, the value that would be given to dnums is just a copy of the reference to inums, so there is no way that each of the individual elements can be expanded to double.

The next chapter will discuss typecasting from arrays of one type of object to another.

11 - JAVA INHERITANCE

Inheritance creates a new class definition by building upon an existing definition (you extend the original class).

The new class can, in turn, can serve as the basis for another class definition.


• All Java objects use inheritance.
• Every Java object can trace back up the inheritance tree to the generic class Object.
The keyword extends is used to base a new class upon an existing class

Several pairs of terms are used to discuss class relationships (these are not keywords).
• Note that traditionally the arrows point from the inheriting class to the base class, and the base class is drawn at the top - in the Unified Modeling Language (UML) the arrows point from a class to another class that it depends upon (and the derived class depends upon the base class for its inherited code).
• The parent class/child class terms are not recommended, since parent and child is more commonly used for ownership relationships (like a GUI window is a parent to the components placed in it).
A derived class instance may be used in any place a base class instance would work - as a variable, a return value, or parameter to a method. Inheritance is used for a number of reasons (some of the following overlap):
• To model real-world hierarchies.
• To have a set of pluggable items with the same "look and feel," but different internal workings.
• To allow customization of a basic set of features.
• When a class has been distributed and enhancements would change the way existing methods work (breaking existing code using the class).
• To provide a "common point of maintenance."
When extending a class, you can add new fields and methods and you can change the behavior of existing methods (which is called overriding the methods).
• You can declare a method with the same signature and write new code for it.
• You can declare a field again, but this does not replace the original field; it shadows it (the original field exists, but any use of that name in this class and its descendants refers to the memory location of the newly declared element).

Inheritance Examples

---

Say you were creating an arcade game, with a number of different types of beings that might appear - wizards, trolls, ogres, princesses (or princes), frogs, etc. All of these entities would have some things in common, such as a name, movement, ability to add/subtract from the player's energy - this could be coded in a base class Entity.

For entities that can be chosen and controlled by a player (as opposed to those that merely appear during the course of the game but can't be chosen as a character) a new class Playable could extend Entity by adding the control features.

Then, each individual type of entity would have its own special characteristics; those that can be played would extend Playable, the rest would simply extend Entity.

you could then create an array that stored Entity objects, and fill it with randomly created objects of the specific classes. For example, your code could generate a random number between 0 and 1; if it is between 0.0 and 0.2, create a Wizard, 0.2 - 0.4 a Prince, etc.

The Java API is a set of classes that make extensive use of inheritance. One of the classes used in the GUI is Window; its family tree looks like this:

Payroll with Inheritance

---

Our payroll program could make use of inheritance if we had different classes of employees: exempt employees, nonexempt employees, and contract employees

They all share basic characteristics such as getting paid (albeit via different algorithms), withholding, having to accumulate year-to-date numbers for numerous categories.

But they have different handling regarding payment calculations, benefits, dependents, etc.

Exempt employees get a monthly salary, while nonexempt get a wage * hours, contract employees are handled similarly to nonexempt, but cannot have benefits or dependents.

This would leave us with an inheritance scheme as follows:

Note that a scheme with ContractEmployee extending NonexemptEmployee might also be a reasonable approach

Derived Class Objects

---

You can view a derived class object as having a complete base class object inside it. Let's assume that the Entity class defines the fields name, energy, and position, and methods moveTo() and changeEnergy().

The Playable class adds a field playerID, and the Wizard class adds a spells field (an array of spells they can cast) and a castSpell() method.

Any Wizard object contains all the elements inside its box, include those of the base classes. So, for example, the complete set of properties in a Wizard object is:

• name
• energy
• position
• playerID
• spells

A Wizard reference to a Wizard object has access to any public elements from any class in the inheritance chain from Object to Wizard. Code inside the Wizard class has access to all elements of the base classes (except those defined as private in the base class - those are present, but not directly accessible).

A more complete description of access levels is coming up.

Note: although it appears that a base class object is physically located inside the derived class instance, it is not actually implemented that way.

Polymorphism

---

Inheritance and References

If a derived class extends a base class, it is not only considered an instance of the derived class, but an instance of the base class as well. The compiler knows that all the features of the base class were inherited, so they are still there to work in the derived class (keeping in mind that they may have been changed).

This demonstrates what is known as an Is A relationship - a derived class object is A base class instance as well.

It is an example of polymorphism; that one reference can store several different types of objects. For example, in the arcade game example, for any character that is used in the game, an Entity reference variable could be used, so that at runtime, any subclass can be instantiated to store in that variable.

Entity shrek = new Ogre(); Entity merlin = new Wizard();

For the player's character, a Playable variable could be used.

Playable charles = new Prince();

When this is done, however, the only elements immediately available through the reference are those know to exist; that is, those elements defined in the reference type object. Note that:

• The compiler decides what to allow you to do with the variable based upon the type declared for the variable.
• merlin.moveTo() would be legal, since that element is guaranteed to be there.
• merlin.castSpell() would not be legal, since the definition of Entity does not include it, even though the actual object does have that capability.
• The following example gives a hint as to why this is the case:

Entity x; if (Math.random() < 0.5) x = new Wizard(); else x = new Troll();

There is no way the compiler could determine what type of object would actually be created.
The variables names above, shrek, merlin, and charles, are probably not good choices: presumably we know shrek is an ogre, and always will be, so the type might as well be Ogre (unless, of course, he could transmogrify into something else during the game ...).

Dynamic Method Invocation

When a method is called through a reference, the JVM looks to the actual class of the instance to find the method. If it doesn't find it there, it backs up to the ancestor class (the class this class extended) and looks there (and if it doesn't find it there, it backs up again, potentially all the way to Object).

Sooner or later, it will find the method, since if it wasn't defined somewhere in the chain of inheritance, the compiler would not have allowed the class to compile.

In this manner, what you could consider the most advanced (or most derived) version of the method will run, even if you had a base class reference.

So, for our arcade game, an Entity reference could hold a Wizard, and when the moveTo method is called, the Wizard version of moveTo will run.

An interesting aspect of dynamic method invocation is that it occurs even if the method is called from base class code. If, for example:

• The Entity class moveTo method called its own toString method.
• The Ogre class didn't override moveTo, but did override toString.
• For an Ogre stored in an Entity variable, the moveTo method was called.

The Entity version of moveTo would run, but its call to toString would invoke the toString method from Ogre!

Creating a Derived Class

---

The syntax for extending a base class to create a new class is:

[modifiers] class DerivedClassName extends BaseClassName { (new or revised field and method definitions go here) }

If you do not extend any class, Java assumes you are extending Object by default

Your new class can use the fields and methods contained in the original class (subject to the note coming up in a few pages about access keywords), add new data fields and methods, or replace fields or methods.

A derived class object may be stored in a base class reference variable without any special treatment. If you then want to store that object in a derived class reference again, you can force that with a typecast.

Java doesn't allow multiple inheritance, where one class inherits from two or more classes. Note that:

• It does have a concept called an interface, which defines a set of method names.
• A class may implement an interface, defining those methods in addition to whatever other methods are in the class.
• This allows for several otherwise unrelated classes to have the same set of method names available, and to be treated as the same type of object for that limited set of methods.

Inheritance Example - A Derived Class

---

When a derived class is created, an object of the new class will in effect contain all the members of the base and derived classes. In some cases, the accessibility modifiers can limit base class members availability in the derived class, but we will cover that issue later.

The following maps out the relation between the derived class and the base class (note that the diagrams show the apparent memory allocation, in a real implementation the base class memory block is not inside the derived class block).

Class Code	Apparent Memory Allocation
public class MyBase { public int x; public void show() { System.out.println("x =" + x); }
class MyDerived extends MyBase { public int y; public void show() { System.out.println("x = " + x); System.out.println("y = " + y); } }

Since everything in MyBase is public, code in the MyDerived class has free access to the x value from the MyBase object inside it, as well as y and show() from itself.

The show() method from MyBase is also available, but only within MyDerived class code (but some work is required to get it, since it is hidden by the show() method added with MyDerived) - code in other classes cannot invoke the MyBase version of show() at all.

Inheritance and Access

---

When inheritance is used to create a new (derived) class from an existing (base) class, everything in the base class is also in the derived class. It may not be accessible; however, the access in the derived class depends on the access in the base class:

Base class access	Accessibility in derived class
public	public
protected	protected
private	Inaccessible
Unspecified (package access)	Unspecified (package access)

Note that private elements become inaccessible to the derived class - this does not mean that they disappear, or that that there is no way to affect their values, just that they can't be referenced by name in code within the derived class

Also note that a class can extend a class from a different package

Inheritance and Constructors - the super Keyword

---

Since a derived class object contains the elements of a base class object, it is reasonable to want to use the base class constructor as part of the process of constructing a derived class object.

Constructors are "not inherited". In a sense, this is a moot point, since they would have a different name in the new class, and can't be called by name under any circumstances, so, for example, when one calls new Integer(int i) they shouldn't expect a constructor named Object(int i) to run.

Within a derived class constructor, however, you can use super( parameterList ) to call a base class constructor. Note that:

I
• t must be done as the first line of a constructor.
• Therefore, you can't use both this() and super() in the same constructor function.
• If you do not explicitly invoke a form of super-constructor, then super() (the form that takes no parameters) will run.
• For the superclass, its constructor will either explicitly or implicitly run a constructor for its superclass.
• So, when an instance is created, one constructor will run at every level of the inheritance chain, all the way from Object up to the current class.

Code Sample:

Java-Inheritance/Demos/Inheritance1.java

class MyBase { private int x; public MyBase(int x) { this.x = x; } public int getX() { return x; } public void show() { System.out.println("x=" + x); } } class MyDerived extends MyBase { private int y; public MyDerived(int x) { super(x); } public MyDerived(int x, int y) { super(x); this.y = y; } public int getY() { return y; } public void show() { System.out.println("x = " + getX()); System.out.println("y = " + y); } } public class Inheritance1 { public static void main(String[] args) { MyBase b = new MyBase(2); b.show(); MyDerived d = new MyDerived(3, 4); d.show(); } }

The diagram below shows the structure of our improved classes:

• A MyDerived object has two constructors available, as well as both the getX and getY methods and the show method.
• Both MyDerived constructors call the super constructor to handle storage of x.
• The show method in the derived class overrides the base class version.
• Note that you can tell which class's version of show() is running by the different spacing around the = sign.
• x from the base class is not available in the derived class, since it is private in MyBase, so the show method in MyDerived must call getX() to obtain the value.

Derived Class Methods that Override Base Class Methods

---

As we saw before, you can create a method in the derived class with the same name as a base class method. Note that:

• The new method overrides (and hides) the original method.
• You can still call the base class method from within the derived class if necessary, by adding the super keyword and a dot in front of the method name.
• The base class version of the method is not available to outside code.
• You can view the super term as providing a reference to the base class object buried inside the derived class.
• You cannot do super.super. to back up two levels.
• You cannot change the return type when overriding a method, since this would make polymorphism impossible.
• Example: a revised MyDerived using super.show()

class MyDerived extends MyBase { int y; public MyDerived(int x) { super(x); } public MyDerived(int x, int y) { super(x); this.y = y; } public int getY() { return y; } public void show() { super.show(); System.out.println("y = " + y); } }

Inheritance and Default Base Class Constructors

---

One base class constructor will always run when instantiating a new derived class object.

• If you do not explicitly call a base class constructor, the no-arguments base constructor will be automatically run, without the need to call it as super().
• But if you do explicitly call a base class constructor, the no-arguments base constructor will not be automatically run.
• The no-arguments (or no-args for short) constructor is often called the default constructor, since it is the one that will run by default (and also because you are given it by default if you write no constructors).

Code Sample:

Java-Inheritance/Demos/Inheritance2.java

class Purple { protected int i = 0; public Purple() { System.out.println("Purple() running and i = " + this.i); } public Purple(int i) { this.i = i; System.out.println("Purple(i) running and i = " + this.i); } } class Violet extends Purple { Violet() { System.out.println("Violet() running and i = " + this.i); } Violet(int i) { System.out.println("Violet(i) running and i = " + this.i); } } public class Inheritance2 { public static void main(String[] args) { System.out.println("new Violet():"); new Violet(); System.out.println(); System.out.println("new Violet(4):"); new Violet(4); } }

Each constructor prints a message so that we can follow the flow of execution. Note that using new Violet() causes Purple() to run, and that new Violet(4) also causes Purple() to run.

For the sake of simplicity, the i field has been made protected, but this is not considered a good practice.

If your base class has constructors, but no no-arguments constructor, then the derived class must call one of the existing constructors with super(args), since there will be no default constructor in the base class.

If the base class has a no-arguments constructor that is private, it will be there, but not be available, since private elements are hidden from the derived class. So, again, you must explicitly call an available form of base class constructor, rather than relying on the default.

Try the above code with the Purple() constructor commented out or marked as private.

The Instantiation Process at Runtime

---

In general, when an object is instantiated, an object is created for each level of the inheritance hierarchy. Each level is completed before the next level is started, and the following takes place at each level:

1. The memory block for that level is allocated (for derived classes, this means it is sized for the added elements, since the inherited elements were in the base class memory block.
2. The entire block is zeroed out.
3. Explicit initializers for that level run, which may involve executable code, for example: private double d = Math.random();
4. The constructor for that level runs. Note:
• Since the class code has already been loaded, and any more basic code has been completed, any methods in this class or inherited from superclasses are available to be called from the constructor.
• Note that if this level's constructor calls a superconstructor, all you are really doing is selecting which form of superconstructor will run at the appropriate time. Timing wise, that superconstructor was run before we got to this point.

When the process has completed, the expression that created the instance evaluates to the address of the block for the last unit in the chain.

Inheritance and static Elements

static methods in a class may not be overridden in a derived class. This is because the static method linkages are not resolved with the same dynamic mechanism that non-static methods use. The linkage is established at compile time.

Example - Factoring Person Out of Employee

---

Since personnel and probably other people in our overall corporate software suite (contact management, perhaps) would have some basic personal attributes in common, we will pull the first and last name fields into a base class representing a person.

1. Create a new class, Person, in the employees package (that may not be the best place for it, but for convenience we will put it there).
2. Cut the first and last name fields and the associated get and set methods out of Employee and paste them here (including getFullName).
3. Create a constructor for Person that sets the first and last names; it would probably b e a good idea to create a default constructor as well.
4. Declare Employee to extend Person; change the constructor that accepts the first and last name fields to call a super-constructor to accomplish that task.
5. Note that if getPayInfo() uses firstName and lastname directly, you will need to revise it to call the get methods for those values - why?
6. We can test the code using a simplified version of Payroll.

Code Sample:

Java-Inheritance/Demos/employees/Person.java

package employees; public class Person { private String firstName; private String lastName; public Person() { } public Person(String firstName, String lastName) { setFirstName(firstName); setLastName(lastName); } public String getFirstName() { return firstName; } public void setFirstName(String firstName) { this.firstName = firstName; } public String getLastName() { return lastName; } public void setLastName(String lastName) { this.lastName = lastName; } public String getFullName() { return firstName + " " + lastName; } }

This class includes the name fields and related set and get methods.

Code Sample:

Java-Inheritance/Demos/employees/Employee.java

package employees; public class Employee extends Person { ---- C O D E O M I T T E D ---- public Employee() { } public Employee(String firstName, String lastName) { super(firstName, lastName); } public Employee(String firstName,String lastName, int dept) { super(firstName, lastName); setDept(dept); } public Employee(String firstName, String lastName, double payRate) { super(firstName, lastName); setPayRate(payRate); } public Employee( String firstName, String lastName, int dept, double payRate) { this(firstName, lastName, dept); setPayRate(payRate); } ---- C O D E O M I T T E D ---- public String getPayInfo() { return "Employee " + id + " dept " + dept + " " + getFullName() + " paid " + payRate; } }

Since this class now extends Person, the name-related elements are already present, so we remove them from this code. We took advantage of the Person constructor that accepst first and last names in the corresponding Employee constructor.

Note that since getPayInfo calls getFullName, which is now inherited and publicly accessible, that code did not need to change.

Code Sample:

Java-Inheritance/Demos/Payroll.java

import employees.*; import util.*; public class Payroll { public static void main(String[] args) { String fName = null; String lName = null; int dept = 0; double payRate = 0.0; double hours = 0.0; Employee e = null; fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); dept = KeyboardReader.getPromptedInt("Enter department: "); do { payRate = KeyboardReader.getPromptedFloat("Enter pay rate: "); if (payRate &li; 0.0) System.out.println("Pay rate must be >= 0"); } while (payRate &li; 0.0); e = new Employee(fName, lName, dept, payRate); System.out.println(e.getPayInfo()); } }

No changes need to be made to Payroll to take advantage of the addition of the inheritance hierarchy that we added. The only changes we made were for the sake of brevity.

To revisit the sequence of events when instantiating an Employee using the constructor that accepts the first and last names, department, and pay rate:

1. Memory for an Object is allocated.
2. Any Object initializers would run.
3. The Object() constructor would run.
4. Memory for a Person is allocated.
5. If there were any Person initializers, they would run.
6. The Person constructor would run, because that was the version selected by the Employee constructor we called.
7. Memory for an Employee is allocated.
8. If there were any Employee initializers, they would run.
9. Any additional steps in the Employee constructor we called would run.

Payroll-Inheritance01: Adding Types of Employees

---

Duration: 30 to 45 minutes. We wish to improve our payroll system to take account of the three different types of employees we actually have: exempt, nonexempt, and contract employees. Rather than use some sort of identifying code as a property, OOP makes use of inheritance to handle this need, since at runtime a type can be programmatically identified. So we will create three new classes that extend Employee:

1. ExemptEmployee
2. NonexemptEmployee
3. ContractEmployee

In our company, exempt employees get a monthly salary, nonexempt an hourly rate that is multiplied by their hours, as do contract employees. There won't be any real difference between nonexempt and contract employees within their code. Realistically, in a real application, there would be, but, even if there weren't, it would still be a good idea to have separate classes, since the class type itself becomes a bit of information about the object. In the exception class hierarchy, there are many classes that have no internal differences; The multiple classes serve merely to identify the type of problem that occured.

We can inherit much of the logic from Employee, such as the pay rate fields and methods, as well as the name-related elements indirectly gained from Person. But, ContractEmployee and NonexemptEmployee will both add logic related to hours, and all three classes will override the getPayInfo method.

Also, the solution code builds upon the Person base class from the preceding example. You can either copy the Person.java file into your working directory and edit Employee.java to match, or just copy the set of files from the Java-Inheritance/Demos directory into your working directory and use those.

1. Create three new classes, ExemptEmployee, NonexemptEmployee, and ContractEmployee that extend Employee
• One possible approach is to copy the Employee.java file into a new file, ExemptEmployee.java, and modify as appropriate.
• Then copy that into NonexemptEmployee.java and edit.
• Then copy NonexemptEmployee.java into ContractEmployee.java and make the required changes.
changes.
2. Add an hours field for non-exempt and contract employees, along with the associated get and set methods (note that the payRate field will hold a monthly amount for exempt and an hourly amount for nonexempt and contractors).
3. Revise the getPayInfo method for each new class.
• For all three, it should identify which type of employee it is.
• For nonexempt and contract employees, calculate payRate * hours as the numeric value for their pay.
4. Add constructors as you see fit, making use of calls to the appropriate super-constructors.
5. There is a special main program already in the Exercises folder, Payroll4Inheritance01.java, that you can use to test your classes.

Solution:

Solutions/Payroll-Inheritance01/employees/ExemptEmployee.java

package employees; public class ExemptEmployee extends Employee { public ExemptEmployee() { } public ExemptEmployee(String firstName, String lastName) { super(firstName, lastName); } public ExemptEmployee(String firstName,String lastName, int dept) { super(firstName, lastName, dept); } public ExemptEmployee(String firstName, String lastName, double payRate) { super(firstName, lastName, payRate); } public ExemptEmployee(String firstName, String lastName, int dept, double payRate) { super(firstName, lastName, dept, payRate); } public String getPayInfo() { return "Exempt Employee " + getId() + " dept " + getDept() + " " + getFirstName() + " " + getLastName() + " paid " + getPayRate(); } }

The primary thing to notice about this file is that it rewrites each constructor with one line to call the equivalent form of super.

Solution:

Solutions/Payroll-Inheritance01/employees/NonexemptEmployee.java

package employees; public class NonexemptEmployee extends Employee { private double hours; public NonexemptEmployee() { } public NonexemptEmployee(String firstName, String lastName) { super(firstName, lastName); } public NonexemptEmployee(String firstName, String lastName, int dept) { super(firstName, lastName, dept); } public NonexemptEmployee(String firstName, String lastName, double payRate, double hours) { super(firstName, lastName, payRate); setHours(hours); } public NonexemptEmployee(String firstName, String lastName, int dept, double payRate, double hours) { super(firstName, lastName, dept, payRate); setHours(hours); } public double getHours() { return hours; } public void setHours(double hours) { this.hours = hours; } public String getPayInfo() { return "Non-Exempt Employee " + getId() + " dept " + getDept() + " " + getFirstName() + " " + getLastName() + " paid " + getPayRate() * hours; } }

In addition to rewriting the existing constructors, this class adds another that accepts hours, as well as appropriate methods to get and set that value.

Solution:

Solutions/Payroll-Inheritance01/employees/ContractEmployee.java

package employees; public class ContractEmployee extends Employee { private double hours; public ContractEmployee() { } public ContractEmployee(String firstName, String lastName) { super(firstName, lastName); } public ContractEmployee(String firstName, String lastName, int dept) { super(firstName, lastName, dept); } public ContractEmployee(String firstName, String lastName, double payRate, double hours) { super(firstName, lastName, payRate); setHours(hours); } public ContractEmployee(String firstName, String lastName, int dept, double payRate, double hours) { super(firstName, lastName, dept, payRate); setHours(hours); } public double getHours() { return hours; } public void setHours(double hours) { this.hours = hours; } public String getPayInfo() { return "Contract Employee " + getId() + " dept " + getDept() + " " + getFirstName() + " " + getLastName() + " paid " + getPayRate() * hours; } }

This class is virtually identical to NonexemptEmployee. Realistically, there would be differences due to benefits, dependents, etc.

Given the similarity between ContractEmployee and NonexemptEmployee, it might be worth refactoring to have a common base class for hourly employees, especially if there were situations where we would want to work with all hourly employees, regardless of type.

Solution:

Exercises/Payroll4Inheritance01.java

import employees.*; import util.*; public class Payroll4Inheritance01 { public static void main(String[] args) { ---- C O D E O M I T T E D ---- ExemptEmployee ee = null; NonexemptEmployee ne = null; ContractEmployee ce = null; fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); dept = KeyboardReader.getPromptedInt("Enter department: "); do { payRate = KeyboardReader.getPromptedDouble("Enter pay rate: "); if (payRate < 0.0) System.out.println("Pay rate must be >= 0"); } while (payRate < 0.0); ee = new ExemptEmployee(fName, lName, dept, payRate); System.out.println(ee.getPayInfo()); fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); dept = KeyboardReader.getPromptedInt("Enter department: "); do { payRate = KeyboardReader.getPromptedDouble("Enter pay rate: "); if (payRate < 0.0) System.out.println("Pay rate must be >= 0"); } while (payRate < 0.0); do { hours = KeyboardReader.getPromptedDouble("Enter hours: "); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); ne = new NonexemptEmployee(fName, lName, dept, payRate, hours); System.out.println(ne.getPayInfo()); fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); dept = KeyboardReader.getPromptedInt("Enter department: "); do { payRate = KeyboardReader.getPromptedDouble("Enter pay rate: "); if (payRate < 0.0) System.out.println("Pay rate must be >= 0"); } while (payRate < 0.0); do { hours = KeyboardReader.getPromptedDouble("Enter hours: "); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); ce = new ContractEmployee(fName, lName, dept, payRate, hours); System.out.println(ce.getPayInfo()); } }

Typecasting with Object References

---

Object references can be typecast only along a chain of inheritance. If class MyDerived is derived from MyBase, then a reference to one can be typecast to the other. An upcast converts from a derived type to a base type, and will be done implicitly, because it is guaranteed that everything that could be used in the base is also in the derived class.

String s = new String("Hello"); o = s;

A downcast converts from a parent type to a derived type, and must be done explicitly.

Object o = new String("Hello"); String t; t = (String) o;

even though o came from a String, the compiler only recognizes it as an Object, since that is the type of data the variable is declared to hold.

As a memory aid, if you draw your inheritance diagrams with the parent class on top, then an upcast moves up the page, while a downcast moves down the page.

More on Object Typecasts

The compiler will not check your downcasts, other than to confirm that the cast is at least feasible. For instance, there is no possibility of a typecase between String and Integer, since neither is a base class to the other.

But, the JVM will check at runtime to make sure that the cast will succeed. A downcast could fail at runtime because you might call a method that is not there, so the JVM checks when performing the cast in order to fail as soon as possible, rather than possibly having some additional steps execute between casting and using a method.

Object o = new Integer(7); String t, u; // compiler will allow the following line, but it will fail at runtime t = (String) o; // we will never reach this line u = t.toUpperCase();

Since t was not actually a String, this would fail with a runtime exception during the cast operation. At that point, the runtime engine sees that it cannot make the conversion and fails.

You can use a typecast in the flow of an operation, such as:

MyBase rv = new MyDerived(2, 3); System.out.println( "x=" + rv.getX() + " y=" + ((MyDerived) rv).getY() );

((MyBase) rv) casts rv to a MyDerived, for which the getY() method is run.

Note the parentheses enclosing the inline typecast operation; this is because the dot operator is higher precedence than the typecast; without them we would be trying to run rv.getY() and typecast the result (technically, Java does not consider the dot an operator, but a separator , like curly braces, parentheses, and square brackets - the net effect is the same, since separators get applied before operators).

Typecasting, Polymorphism, and Dynamic Method Invocation

The concept of polymorphism means "one thing - many forms."

In this case, the one thing is a base class variable; the many forms are the different types derived from that base class that can be stored in the variable.

Storing a reference in a variable of a base type does not change the contents of the object, just the compiler's identification of its type - it still has its original methods and fields.

You must explicitly downcast the references back to their original class in order to access their unique properties and methods. If you have upcast, to store a derived class object with a base class reference, the compiler will not recognize the existence of derived class methods that were not in the base class.

The collection classes, such as Vector, are defined to store Objects, so that anything you store in them loses its identity. You must downcast the reference back to the derived type in order to access those methods. The introduction of generics in Java 1.5 provides a solution to this annoyance (more on this in the Collections lesson).

During execution, using a base class reference to call to a method that has been overridden in the derived class will result in the derived class version being used. This is called dynamic method invocation.

The following example prints the same way twice, even though two different types of variable are used to reference the object:

Code Sample:

Java-Inheritance/Demos/Inheritance3.java

public class Inheritance3 { public static void main(String[] args) { MyDerived mD = new MyDerived(2, 3); MyBase mB = mD; mB.show(); mD.show(); } }

Situations where you would often see a base class reference:

• Parameters to methods that only need to work with base class elements of the incoming object.
• As fields of a class where the class code will only work with the base class elements of the object.
• Return values from methods where the actual class returned is not important to the user, and you want to hide the actual class from the user - for example, a java.net.Socket object has a public OutputStream getOutputStream () method that returns an instance of a specialized class that will send data across the network connection that the Socket holds; to use this class you only need to know that it is an OutputStream, since there is no way you could use this class without the Socket it is attached to.

More on Overriding

---

Changing Access Levels on Overridden Methods

You can change the access level of a method when you override it, but only to make it more accessible.

• You can't restrict access any more than it was in the base class.
• So, for example, you could take a method that was protected in the base class and make it public.
• For example, if a method was public in the base class, the derived class may not override it with a method that has protected, private or package access.

This avoids a logical inconsistency:

• Since a base class variable can reference a derived class object, the compiler will allow it to access something that was public in the base class.
• If the derived class object actually referenced had changed the access level to private, then the element ought to be unavailable.
• This logic could be applied to any restriction in access level, not just public to private.

As a more specific example of why this is the case, imagine that ExemptEmployee overrode public String getPayInfo() with private String getPayInfo().

The compiler would allow

Employee e = new ExemptEmployee(); // getPayInfo was public in Employee, so compiler should allow this e.getPayInfo();

• Because Employee, the type on the variable e, says that getPayInfo is public.
• But, now at runtime, it shouldn't be accessible, since it is supposed to be private in ExemptEmployee.

Redefining Fields

• A new field is created that hides the existence of the original field.
• Since it actually a new field being created, the access level and even data type may be whatever you want - they do not have to be the same as the original field.
• I don't know of any good reason to do this deliberately, but it is possible.
• A strange thing happens when you use a base class reference to such a class where the field was accessible (for example, public).
• The base class reference sees the base class version of the field!

But, if you were to extend a class from the Java API or other library, you wouldn't necessarily know what fields it had - this facility allows you to use whatever field names you want, and, as long as the base class versions were private, you would not get any adverse effects.

Object Typecasting Example

---

Say our game program needed to store references to Entity objects.

The exact type of Entity would be unknown at compile time.

But during execution we would like to instantiate different types of Entity at random.

Perhaps our code for Entity includes a method moveTo() that moves it to a new location. Many of the entities move the same way, but perhaps some can fly, etc. We could write a generally useful form of moveTo in the Entity class, but then override it as necessary in some of the classes derived from Entity.

Code Sample:

Java-Inheritance/Demos/EntityTest.java

class Entity { private String name; public Entity(String name) { this.name = name; } public String getName() { return name; } public void move() { System.out.println("I am " + name + ". Here I go!"); } } class Playable extends Entity { public Playable(String name) { super(name); } public void move() { System.out.println("I am Playable " + getName() + ". Here we go!"); } } class Ogre extends Entity { public Ogre(String name) { super(name); } } class Troll extends Entity { public Troll(String name) { super(name); } } class Prince extends Playable { public Prince(String name) { super(name); } // does not override public void move() } class Princess extends Playable { public Princess(String name) { super(name); } public void move() { System.out.println("I am Princess " + getName() + ". Watch as I and my court move!"); } } class Wizard extends Playable { public Wizard(String name) { super(name); } public void move() { System.out.println("I am the Wizard " + getName() + ". Watch me translocate!"); } } public class EntityTest { public static void main(String[] args) { String[] names = { "Glogg", "Blort", "Gruff", "Gwendolyne", "Snow White", "Diana", "Merlin", "Houdini", "Charles", "George" }; for (int i = 0; i < 10; i++) { int r = (int) (Math.random() * 5); Entity e = null; switch (r) { case 0: e = new Ogre(names[i]); break; case 1: e = new Troll(names[i]); break; case 2: e = new Wizard(names[i]); break; case 3: e = new Prince(names[i]); break; case 4: e = new Princess(names[i]); break; } e.move(); } } }

The compiler allows the calls to the moveTo method because it is guaranteed to be present in any of the subclasses - since it was created in the base class.

If not overridden in the derived class, then the base class version will be used.

If the method is overridden by the derived class, then the derived class version will be used.

At runtime, the JVM searches for the method implementation, starting at the actual class of the instance, and moving up the inheritance hierarchy until it finds where the method was implemented, so the most derived version will run.

Checking an Object's Type: Using instanceof

---

Given that you can have base class references to several different derived class types, you will eventually come to a situation where you need to determine exactly which derived class is referenced - you may not know it at the time the program is compiled.

In the above example, perhaps wizards, ogres, trolls, etc. have their own special methods.

How would you know which method to call if you had an Entity reference that could hold any subclass at any time?

The instanceof operator is used in comparisons - it gives a boolean answer when used to compare an object reference with a class name.

referenceExpression instanceof ObjectType

It will yield true if the reference points to an instance of that class.

It will also give true if the object is a derived class of the one tested.

If the test yields true, then you can safely typecast to call a derived class method (you still need to typecast to call the method - the compiler doesn't care that you performed the test).

For example:

if (e[i] instanceof Wizard) ((Wizard) e[i]).castSpell();

There is another method of testing:

• Every object has a getClass() method that returns a Class object that uniquely identifies each class.
• Every class has a class pseudo-property that provides the same Class object as above; this object is the class as loaded into the JVM (technically, class isn't a field, but syntax-wise it is treated somewhat like a static field).
• With this method, a derived class object's class will compare as not equal to the base class.

if (e[i].getClass().equals(Wizard.class)) ((Wizard) e[i]).castSpell();

It is rare that you would need this type of test.

Payroll-Inheritance02: Using the Employee Subclasses

---

Duration: 45 to 60 minutes.

1. n the main method of Payroll, reinstate the array of Employee objects.
2. Create instances of the non-exempt employees, exempt employees, and contract employees to fill the array. You can ask which type of employee using getPromptedChar, then break up the existing sections of code that enter one specific type as in: boolean badType; do { badType = false; char empType = KeyboardReader.getPromptedChar("Enter employee type (E, N, C): "); switch (emptype) { case 'E': case 'e': (existing code to enter one ExemptEmployee, modified to use current array element as the variable) break; case 'N': case 'n': (existing code to enter one NonexemptEmployee, modified to use current array element as the variable) break; case 'C': case 'c': (existing code to enter one ContractEmployee, modified to use current array element as the variable) break; default: badType = true; (Print error message) } } while (badType); You will see a slightly different approach in the solution code, which avoids duplicating the code to read the name and department data.
3. Create a report that lists all employees, grouped by type, by looping through the array three times.
   • The first time, show all exempt employees and their pay information .
   • The second time. print only the non-exempt employees and their pay information.
   • The third time. print contract employees and their pay information.
   • Since you'll be writing the same loop multiple times, you could try both indexed loops and for-each loops (the solution uses for-each loops).

Solution:

Solutions/Payroll-Inheritance02/Payroll.java

import employees.*; import util.*; public class Payroll { public static void main(String[] args) { ---- C O D E O M I T T E D ---- for (int i = 0; i < e.length; i++) { char type = KeyboardReader.getPromptedChar("Enter type: E, N, or C: "); if (type != 'e' amp;&& type != 'E' && type != 'n' amp;&& type != 'N' && type != 'c' amp;&& type != 'C') { System.out.println("Please enter a valid type"); i--; continue; } fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); do { dept = KeyboardReader.getPromptedInt("Enter department: "); if (dept <= 0) System.out.println("Department must be >= 0"); } while (dept <= 0); do { payRate = KeyboardReader.getPromptedDouble("Enter pay rate: "); if (payRate < 0.0) System.out.println("Pay rate must be >= 0"); } while (payRate < 0.0); switch (type) { case 'e': case 'E': e[i] = new ExemptEmployee(fName, lName, dept, payRate); break; case 'n': case 'N': do { hours = KeyboardReader.getPromptedDouble("Enter hours: "); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); e[i] = new NonexemptEmployee(fName, lName, dept, payRate, hours); break; case 'c': case 'C': do { hours = KeyboardReader.getPromptedDouble("Enter hours: "); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); e[i] = new ContractEmployee(fName, lName, dept, payRate, hours); } } System.out.println(); System.out.println("Exempt Employees"); System.out.println("====== ========="); for (Employee emp : e) { if (emp instanceof ExemptEmployee) { System.out.println(emp.getPayInfo()); } } System.out.println(); System.out.println("Nonexempt Employees"); System.out.println("======== ========="); for (Employee emp : e) { if (emp instanceof NonexemptEmployee) { System.out.println(emp.getPayInfo()); } } System.out.println(); System.out.println("Contract Employees"); System.out.println("======== ========="); for (Employee emp : e) { if (emp instanceof ContractEmployee) { System.out.println(emp.getPayInfo()); } } } }

We reduced the amount of code by recognizing that some of the data entry logic is common to all three types - asking for first and last names and department before the switch. This required some additional shuffling of declarations, plus some restructuring to avoid asking for the name information all over again if the employee type is not valid (we used continue to avoid processing an employee if the type wasn't valid, and backed up the loop counter to go over the same array location on the next iteration).

For the report, the same logic is essentially repeated three times:

System.out.println(); System.out.println("Exempt Employees"); System.out.println("====== ========="); for (Employee emp : e) { if (e instanceof ExemptEmployee) { System.out.println(e[i].getPayInfo()); } }

The instanceof test enables us to isolate just one type of employee to print; the others will be skipped over.

Payroll-Inheritance03: Making our base classes abstract

---

Duration: 5 to 5 minutes.

1. Mark the Person and Employee classes as abstract
2. Make the getPayInfo() method abstract in Employee

Solution:

Solutions/Payroll-Inheritance03/employees/Person.java

package employees; public abstract class Person { ---- C O D E O M I T T E D ---- }

Solution:

Solutions/Payroll-Inheritance03/employees/Employee.java

package employees; public abstract class Employee extends Person { ---- C O D E O M I T T E D ---- public abstract String getPayInfo(); }

Methods Inherited from Object

---

There are a number of useful methods defined for Object.

Some are useful as is, such as:

Class getClass() - returns a Class object (a representation of the class that can be used for comparisons or for retrieving information about the class).

Others are useful when overridden with code specific to the new class:

Object clone() - creates a new object that is a copy of the original object. This method must be overridden, otherwise an exception will occur (the Object version of clone throws a CloneNotSupportedException).

The issue is whether to perform a shallow copy or a deep copy - a shallow copy merely copies the same reference addresses, so that both the original object and the new object point to the same internal objects; a deep copy makes copies of all the internal objects (and then what if the internal objects contained references to objects ...? ).

boolean equals(Object) - does a comparison between this object and another. If you don't override this method, you get the same result as if you used == (that is, the two references must point to the same object to compare as equal - two different objects with the same field values would compare as unequal) - that is how the method is written in the Object class. You would override this method with whatever you need to perform a comparison.

int hashCode() - returns an integer value used by collection objects that store elements using a hashtable. Elements that compare as the same using the equals(Object) method should have the same hashcode.

String toString() - converts this object to a string representation.

This method is called by a some elements in the Java API when the object is used in a situation that requires a String, for example, when you concatenate the object with an existing String, or send the object to System.out.println().

Note that the call to toString is not made automatically as a typecast to a String - the only behavior built into the syntax of Java is string concatenation with the + sign (so one of the operands must already be a String); the code in println is explicitly written to call toString.

If you don't override this method, you will get a strange string including the full class name and the hashcode for the object void finalize() - called by the JVM when the object is garbage-collected. This method might never be called (the program may end without the object being collected).

There are also a several methods (wait, notify, and notifyAll) related to locking and unlocking an object in multithreaded situations.

Code Sample:

Java-Inheritance/Demos/ObjectMethods.java

public class ObjectMethods { int id; String name; int age; ObjectMethods(int id, String name, int age) { this.id = id; this.name = name; this.age = age; } public boolean equals(Object x) { if (x == this) return true; else if (x instanceof ObjectMethods) { ObjectMethods omx = (ObjectMethods) x; return id == omx.id amp;amp;&amp;&amp; name.equals(omx.name) amp;amp;&amp;&amp; age == omx.age; } else return false; } public int hashCode() { return id + age * 1000; } public String toString() { return id + " " + name + " is " + age + " years old"; } public Object clone() { return new ObjectMethods(id, name, age); } public static void main(String[] args) { ObjectMethods om1 = new ObjectMethods (1, "John", 6); ObjectMethods om2 = new ObjectMethods (1, "John", 6); ObjectMethods om3 = new ObjectMethods (2, "Jane", 5); ObjectMethods om4 = (ObjectMethods)om3.clone(); System.out.println("Printing an object: " + om1); if (om1.equals(om2)) System.out.println("om1 equals(om2)"); if (om1.equals(om3)) System.out.println("om1 equals(om3)"); if (om1.equals("John")) System.out.println("om1 equals(\"John\")"); if (om3.equals(om4)) System.out.println("om3 equals(om4) which was cloned from om3"); System.out.println("object class is: " + om1.getClass()); } }

The clone method returns Object rather than ObjectMethods, since that is how it was declared in the Object class, and you can't change the return type when overriding - thus the typecast on the returned value.

Similarly, the parameter to equals is Object, rather than ObjectMethods. This is not required by Java's syntax rules, but rather a convention that enables other classes to work with this class. For example, the Collections API classes use the equals method to determine if an object is already in a set. If we wrote the method as equals(ObjectMethods om) instead of equals(Object o), the collections classes would call equals(Object o) as inherited from Object, which would test for identity using an == test.

The hashCode method was written out of a sense of duty - Sun specifies that the behavior of hashCode "should be consistent with equals", meaning that if two items compare as equal, then they should have the same hash code - this will be revisited in the section on Collections.

Other Inheritance-related Keywords

---

abstract

abstract states that the item cannot be realized in the current class, but can be if the class is extended. Note:
• For a class, it states that the class can't be instantiated (it serves merely as a base for inheritance).
• For a method, it states that the method is not implemented at this level.
• The abstract keyword cannot be used in conjunction with final.
abstract Classes abstract Classes are used when a class is used as a common point of maintenance for subsequent classes, but either structurally doesn't contain enough to be instantiated, or conceptually doesn't exist as a real physical entity. public abstract class XYZ { ... }
• We will make the Employee class abstract in the next exercise: while the concept of an employee exists, nobody in our payroll system would ever be just an employee , they would be exempt, nonexempt, or contract employees.
• While you cannot instantiate an object from an abstract class, you can still create a reference variable whose type is that class.
abstract Methods The method cannot be used in the current class, but only in a inheriting class that overrides the method with code. public abstract String getPayInfo();
• The method is not given a body, just a semicolon after the parentheses.
• If a class has an abstract method, then the class must also be abstract.
• You can extend a class with an abstract method without overriding the method with a concrete implementation, but then the class must be marked as abstract.
final final is used to mark something that cannot be changed. final Classes The class cannot be extended. public final class XYZ { ... } final Methods The method cannot be overridden when the class is extended. public final void display() { ... } final Properties final Properties marks the field as a constant. public static final int MAX = 100;
• A final value can be initialized in a constructor or initializer:
public final double randConstant = Math.random(); or public final double randConstant; Then, in a constructor: randConstant = Math.random(); Note: String and the wrapper classes use this in two ways:
• The class is final, so it cannot be extended.
The internal field storing the data is final as well, but set by the constructor (this makes the instance immutable - the contents cannot be changed once set)
• in some cases, a declaration of final enables the compiler to optimize methods, since it doesn't have to leave any "hooks" in for potential future inheritance.
Note that final and abstract cannot be used for the same element, since they have opposite effects.

12 - JAVA INTERFACES

nterfaces define a standardized set of commands that a class will obey.

The commands are a set of methods that a class implements.

The interface definition states the names of the methods and their return types and argument signatures. There is no executable body for any method that is left to each class that implements the interface.

Once a class implements an interface, the Java compiler knows that an instance of the class will contain the specified set of methods. Therefore, it will allow you to call those methods for an object referenced by a variable whose type is the interface.

Implementing an interface enables a class to be "plugged in" to any situation that requires a specific behavior (manifested through the set of methods).
An analogy: a serial interface on a computer defines a set of pin
/wire assignments and the control signals that will be used. Note that:

• The actual devices that can be used may do entirely different tasks: mouse, modem, etc.

• But they are all controlled through the same digital instruction mechanism; the individual wires are specified to carry specific signals.

Using an interface rather than inheritance to specify a certain set of methods allows a class to inherit from some other class.

• In other words, if a class needs two different sets of methods, so it can behave like two different types of things, it could inherit one set from class A, and use an interface B to specify the other.

• You could then reference one of these objects with either an A reference or a B reference.

Interfaces can also specify constants that are public, static, and final.

Creating an Interface Definition

---

To create an interface definition:

• Define it like a Java class, in its own file that matches the interface name.
• Use the keyword interface instead of class.
• Declare methods using the same approach as abstract methods.
• Note the semicolon after each method declaration - and that no executable code is supplied (and no curly braces).
• The elements will automatically be public and abstract, and cannot have any other state; it is OK to specify those terms, but not necessary (usually public is specified and abstract is not - that makes it easy to copy the list of methods, paste them into a class, and modify them).
• The access level for the entire interface is usually public.
• It may be omitted, in which case the interface is only available to other classes in the same package (i.e., in the same directory).
• Note, for the sake of completeness, there are situations where the interface definition could be protected or private; these involve what are called inner classes.

[modifiers] interface InterfaceName { // declaring methods [public abstract] returnType methodName1(arguments); // defining constants [public static final] type fieldName = value; }

Code Sample:

Java-Interfaces/Demos/Printable.java

public interface Printable { void printAll(); }

This interface requires only one method. Any class implementing Printable must contain a public void printall() method in order to compile.

Because the above interface is defined as public, its definition must be in its own file, even though that file will be tiny.

An interface definition may also define fields that are automatically public static final - these are used as constants.

Implementing Interfaces

---

A class definition may, in addition to whatever else it does, implement one or more interfaces.

Once a class states that it implements an interface, it must supply all the methods defined for that interface, complete with executable code.

Note: it actually does not have to implement all of them, but in that case the class cannot be instantiated - it must be declared as an abstract class that can only be used as a base class (where some derived class would then fully implement the interface).

To implement an interface:

Add that the class implements the interface to the class declaration.

Add the methods specified by the interface to the body of the class. Note that you do need to specify the access terms on methods in a class that implements an interface.

[modifiers] class ClassName implements InterfaceName { any desired fields // implement required methods [modifiers] returnType methodName1(arguments) { executable code } any other desired methods }

It is important to note that a class may implement an interface in addition to whatever else it might do, so it could have additional fields and methods not associated with the interface.

A class may implement more than one interface - that merely adds to the list of required methods. Use a comma-separated list for the interface names.

[modifiers] class ClassName implements Interface1Name, Interface2Name { // must implement all methods from all implemented interfacse }

Implementing Interfaces - Example

---

The complete example will use three separate files (the third file will be shown shortly):

Code Sample:

Java-Interfaces/Demos/Printable.java

public interface Printable { void printAll(); }

Code Sample:

Java-Interfaces/Demos/PrintableThings.java

class Person implements Printable { private String name = new String("Bill"); private int age = 22; public void printAll() { System.out.println("Name is " + name + ", age is " + age); } } class Stock implements Printable { private String tickerSymbol = new String("XYZ"); private int shares = 100; private int currentPrice = 4000; // in pennies public void printAll() { System.out.println(tickerSymbol + " " + shares + " shares at " + currentPrice); System.out.println("Value: " + currentPrice * shares); } public void sell() { System.out.println(tickerSymbol + " sold"); } }

This file contains two classes with package access. Since the classes are not public, they can both be in the same file, and the file name does not need to match either class name. This is done purely as a convenience; it is not a good programming practice in general, but is sometimes useful if one class is highly coupled (interrelated) with the other, which is not the case here. Both classes implement the Printable interface, but are otherwise not related. Stock has another method not related to Printable.

Reference Variables and Interfaces

---

An interface is like a class where the internal structure and some of the behavior is hidden.

Interfaces are listed like classes in the API documentation.
They compile to a .class file, and get loaded by the same process that loads true classes.
Since a class that implements an interface is a class in all other respects, you can create a reference variable for that class, as usual.
You can also create a reference variable whose type is the interface name.

Only the methods defined in the interface are visible through a variable whose type is the interface.
For a Printable variable containing a Stock instance, the sell method is not visible, since it is not declared in Printable.
Any constants defined by the interface can be accessed without a prefix from code within the class, since implementing the interface makes them part of this class.
To access an interface-implementing class with an interface class reference:

[modifiers] InterfaceName variableName;

Example:

• Both Person and Stock implement Printable.
• Therefore, we can create a reference variable to a Printable, and assign either a Person or a Stock object to it.
We can then call the printAll() method from the Printable reference variable,
• since the compiler knows that method will exist, no matter which type of object is actually stored in the variable.

Person p = new Person(); Stock s = new Stock(); Printable pr; pr = p;

or

pr = s;

or

pr = new Person();

Calling an Interface Method

If you have a variable that is declared as a reference to the interface type, you can use it to call an interface method.

Note :that you cannot call any of the additional methods that are not defined by the interface.

Code Sample:

Java-Interfaces/Demos/PrintableTest.java

public class PrintableTest { public static void main(String[] args) { Person p = new Person(); Stock s = new Stock(); p.printAll(); s.printAll(); Printable pr; pr = p; pr.printAll(); pr = s; pr.printAll(); } }

Once pr has been assigned a Printable instance, we can call pr.printAll();

We cannot directly call the sell() method when pr refers to a Stock, since the compiler would not associate it with a variable whose type was Printable. Note: to compile this, use *.java; since the name of the file containing Stock and Person is PrintableThings.java, the compiler won't be able to find those classes, since it would be looking for Person.java and Stock.java.

Note: you can test the type of object actually contained in an interface reference, and typecast it back to that type.

for instance, to use the sell() method for a Stock:

if (pr instanceof Stock) ((Stock) pr).sell();

Interfaces and Inheritance

---

If a class implements an interface, then all subclasses of it will also automatically implement the interface.

They are guaranteed to have the necessary methods available.

It is a good practice to specify that the derived class implements the interface, just for self-documentation of the code (also for purposes of javadoc, if the base class is not in the same group of files).

An interface definition can inherit from another interface.

The new interface then adds fields and methods to the existing (base) definition.

A class that implements the new interface must implement all methods from the base interface as well as all the additional methods from the new interface definition.

An interface can actually extend multiple base interfaces, in which case the combination of all the methods will be required for any implementing class.

The following interface extends the Printable interface and adds another required method (the new method overloads printAll to print to a specified destination instead of to System.out):

Code Sample:

Java-Interfaces/Demos/Printable2.java

import java.io.PrintStream; public interface Printable2 extends Printable { public void printAll(PrintStream p); }

A class implementing Printable2 must define both versions of printAll.

Code Sample:

Java-Interfaces/Demos/Printable2Test.java

import java.io.PrintStream; class Cat implements Printable2 { public void printAll() { printAll(System.out); } public void printAll(PrintStream out) { out.println("Meow"); } } public class Printable2Test { public static void main(String[] args) { Printable2 c = new Cat(); c.printAll(System.err); c.printAll(); } }

Solution:

Solutions/Payroll-Interfaces01/Payroll.java

import employees.*; import vendors.Invoice; import finance.*; import util.*; public class Payroll { public static void main(String[] args) { ---- C O D E O M I T T E D ---- for (int i = 0; i < e.length; i++) { ---- C O D E O M I T T E D ---- } ---- C O D E O M I T T E D ---- Invoice[] inv = new Invoice[4]; inv[0] = new Invoice("ABC Co.", 456.78); inv[1] = new Invoice("XYZ Co.", 1234.56); inv[2] = new Invoice("Hello, Inc.", 999.99); inv[3] = new Invoice("World, Ltd.", 0.43); CheckPrinter.printChecks(e); CheckPrinter.printChecks(inv); } }

The last several lines of code create an array of invoices, then use the CheckPrinter to print employees and invoices separately. It would also be possible to create an array of Payable objects, and add in the elements from both the employees and invoices arrays, but that seems like an unneccessary complication for this application.

Exercise: Payroll-Interfaces01

---

Duration: 30 to 40 minutes. It turns out that our hypothetical system is to be used for all payments our company makes, not just payroll checks, and things like invoices will be paid through the system as well.

Create a finance package, and within it create an interface called Payable.

----it should define the public String getPayInfo() method that our employee classes already implement.

Specify that all the employee classes implement Payable.

The Solutions/Payroll-Interfaces01 directory contains a package called vendors with a class named Invoice - copy this directory to your working directory.

Modify the payroll program by adding an array inv of several invoices (you can just hard-code them).

The Solutions/finance folder also contains a file named CheckPrinter.java - copy that into your finance package. The class has a printChecks(Payable[]) method that you can call twice, once for employees and again for invoices.

Solution:

Solutions/Payroll-Interfaces01/finance/Payable.java

package finance; public interface Payable { public String getPayInfo(); }

This interface declares the public String getPayInfo() method that our employee classes already implement.

Solution:

Solutions/Payroll-Interfaces01/employees/Employee.java

package employees; import finance.Payable; public class Employee extends Person implements Payable { ---- C O D E O M I T T E D ---- }

The class has been marked as implementing Payable. Although it would not be required, we should mark the derived classes the same way, to have more self-documenting code.

Some Uses for Interfaces

---

Interfaces and Event-Handling

A real-world use of interfaces is for event-handling

• An object that can generate an event maintains a list of objects that would like to listen for that event (they will be notified when the event occurs by having one of their methods called).
• The object that generates the event fires it by going through its list of objects that want to handle the event, and calling a specified interface method for each object.
• A class may handle an event if it implements the interface that is expected for that event - therefore it will have the specified method.
• You register an object to handle an event by passing a reference to it to the event-generating object's method that adds a handler.

Assuming that there is an event type called XXXEvent:

• The handler interface would probably be named XXXListener.
• The method to register a listener would usually be called addXXXListener.
• The method generating the event probably has a protected utility method called fireXXXEvent that it uses to trigger the event notifications (and it is available for you to call if you extend the class).

The ActionListener interface is used for GUI events like button clicks.

• The event is fired by the GUI object calling the actionPerformed method for any registered listeners (the code to do this is already built into the GUI classes, and the Java API defines the interface shown below).

public interface ActionListener { public void actionPerformed(ActionEvent e); }

A class can listen for events if it implements ActionListener.

• It can either register itself with the event-generating object, or code outside the class can register it - the example below shows how it would register itself using this:

public class MyClass implements ActionListener { ... public void actionPerformed(ActionEvent e) { System.out.println("Event occurred"); } someOtherMethod() { guiComponent.addActionListener(this); } }

For the class that fires the event, registering is done with the addActionListener(ActionListener) method, which receives a reference to an ActionListener object:

• It adds that reference to a list (maybe a java.util.Vector) of listeners.
• When the time comes to fire the event, it walks through the list, calling actionPerformed() for each element on the list (and passing a reference to an event object that it creates).

For the sake of completeness, when the listener interface has multiple methods, there are often abstract classes that implement most or all of the methods as do-nothing methods - so that all you need to do is extend the class and implement the methods that you choose

Interfaces and "Pluggable Components"

The TableModel interface

The Swing classes contain a component called JTable, which displays a spreadsheet-like grid. Note that:

• It uses a Model-View-Controller approach to separate these sections of logic into individual classes.
• The TableModel interface defines a set of methods that allow a JTable (the controller) to query a data model to find out information in order to display it.
• The interface forms a framework for a discussion that will take place between the controller and the model (like, "How many rows do you have?" and, "How many columns?", followed by "What's the value at column 0, row 0?", etc.).

Below are some of the methods from TableModel:

public interface TableModel
int getColumnCount()
Returns the number of columns in the model.
int getRowCount()
Returns the number of rows in the model.
String getColumnName(int columnIndex)
Returns the name of the column at columnIndex.
Class<?> getColumnClass(int columnIndex)
Returns the most specific superclass for all the cell values in the column.
Object getValueAt(int rowIndex, int columnIndex)
Returns the value for the cell at columnIndex and rowIndex.
boolean isCellEditable(int rowIndex, int columnIndex)
Returns true if the cell at rowIndex and columnIndex is editable.
void setValueAt(Object aValue, int rowIndex, int columnIndex)
Sets the value in the cell at columnIndex and rowIndex to aValue.
You can see the conversation that will take place between the controller and the model. Note that:

• The controller will ask the model for the number of rows and columns, and, with that information, ask for the value at each location.
• It will ask for the type of data with getColumnClass, so it can determine from its settings how to display the values (instances of Number, which Integer, Double, etc., extend, get right-aligned, Boolean columns use a check box, all others get left-aligned - these settings are configurable).
• It will get a heading for each column with getColumnName.
• If a cell is double-clicked, it can ask if the cell is editable with isCellEditable.
• If it is, when the user is done editing, it can put the new data into the model using setValueAt.

Code Sample:

Java-Interfaces/Demos/TableModelExample.java

import java.util.*; import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.table.*; public class TableModelExample { public static void main(String[] args) { DemoTableModel model = new DemoTableModel(); new TableGUI("Table Model Example", model).setVisible(true); new TableConsole(model); new TableHTML(model); } } class DemoTableModel extends AbstractTableModel { String[] titles = { "Name", "Active", "Grade" }; String[] names = { "Mary", "Joe", "Sue" }; Boolean[] actives = { new Boolean(true), new Boolean(false), new Boolean(true) }; Integer[] grades = { new Integer(99), new Integer(87), new Integer(89) }; public int getRowCount() { return names.length; } public int getColumnCount() { return 3; } public String getColumnName(int col) { return titles[col]; } public Object getValueAt(int row, int column) { if (column == 0) return names[row]; else if (column == 1) return actives[row]; else return grades[row]; } public void setValueAt(Object v, int row, int column) {} public Class getColumnClass(int column) { if (column == 0) return String.class; else if (column == 1) return Boolean.class; else return Integer.class; } public boolean isCellEditable(int row, int column) { return false; } } class TableGUI extends JFrame { public TableGUI(String title, DemoTableModel model) { super(title); JTable jt; this.setDefaultCloseOperation(EXIT_ON_CLOSE); jt = new JTable(model); setSize(600,170); getContentPane().add(jt); } } class TableConsole { TableModel model; public TableConsole(TableModel model) { int rows = model.getRowCount(); int cols = model.getColumnCount(); for (int c = 0; c < cols; c++) { System.out.print(fixedStringLength(model.getColumnName(c), 15)); } System.out.println(); System.out.println("-------------- -------------- -------------- "); for (int r = 0; r < rows; r++) { for (int c = 0; c < cols; c++) { System.out.print( fixedStringLength(model.getValueAt(r, c).toString(), 15)); } System.out.println(); } } private String fixedStringLength(String in, int size) { if (in.length() > size) in = in.substring(0, 15); char[] blankArray = new char[size - in.length()]; for (int i = 0; i < blankArray.length; i++) blankArray[i] = ' '; return in + String.valueOf(blankArray); } } class TableHTML { TableModel model; public TableHTML(TableModel model) { java.io.PrintStream out = System.out; int rows = model.getRowCount(); int cols = model.getColumnCount(); out.println("<html><Head><title>My Table</title></head>"); out.println( "<body><table border='1' cellpadding='8' cellspacing='0'><tr>"); for (int c = 0; c < cols; c++) { out.print("<th>" + model.getColumnName(c) + "</th>"); } out.println("</tr>"); for (int r = 0; r < rows; r++) { out.println("<tr>"); for (int c = 0; c < cols; c++) { System.out.print("<td>" + model.getValueAt(r, c) + "</td>"); } out.println("</tr>"); } out.println("</table></body></html>"); } }

For convenience, all the classes are in one file.

The DemoTableModel class implements TableModel by extending AbstractTableModel, thus gaining implementations of several methods (like those relating to model change event listener lists), then adding the remaining methods.

The model is based on parallel arrays of student data: name, grade, and active or not- each array represents one column of data, and element 0 in each array is the same student.

The titles array holds column names.

getColumnCount returns 3, because we know that in advance.

getRowCount returns the length of one of the data arrays.

For getColumnName, we return an appropriate string from the titles array.

For getValueAt, we pick an array based on the column number, and return the element at the row index.

getColumnClass returns a class object that matches the type of data for each array.

isCellEditable returns false, and setValueAt does nothing, because our model is not editable.

We then have three possible views of the data: a Swing GUI view that uses a JTable, a console view that prints column-aligned data, and an HTML view that produces HTML code to the console (you can copy that and paste it into a file to view in a browser, like in tablemodel.html).

Since the JTable is the whole reason TableModel exists, it knows what to do with the model. The TableConsole and TableHTML view objects have to explicitly call the appropriate methods in order to display the data.

Marker Interfaces

It is actually possible to have an interface that requires no methods at all! This creates what is called a marker interface.

A declaration that a class implements the interface makes it an instance of that interface, so that it can be passed as a parameter to a method expecting an instance of the interface, or as a return value from a method that declares it returns an instance of the interface.

An example from the API is Serializable

• An object that implements Serializable may be turned into a serial data stream, perhaps to save in a file or send across a network connection.
• The writeObject method of ObjectOutputStream accepts a parameter whose type is Object, but throws an exception if it doesn't implement Serializable.
• The serialization mechanism is recursive, so not only must the object be an instance of Serializable, but any of its object fields must also reference objects that are Serializable (or marked as transient), and any of their fields ... .

Annotations

---

Java 5 added a new syntax element: the annotation. An annotation is a piece of descriptive data (metadata) about a class, field, or method. It is somewhat like a comment, except that individual annotations are predefined, reusable, and can have effects on either the compilation process or the use of the class once compiled. If you have used an IDE like Eclipse or NetBeans, you may have seen the @Override annotation on editor-supplied template code. This particular annotation tells the compiler that the method that immediately follows is meant to override a base class method (or a method required by an interface). If it does not (because perhaps you spelled the name incorrectly, or got the parameter list wrong), then a compiler error is issued.

Annotations provide Java with a means to achieve, at least to some extent, Aspect-Oriented Programming, or AOP. AOP recognizes cross-cutting concerns, that is, aspects of an element that cut across classes that might not be related by inheritance or implementation of an interface.

An example is a Java web service. While servlets usually extend a Java EE base class (and will always implement the Servlet interface), there is no specified base class or interface for a web service. Instead, configuration information informs the web server that a specific class is intended to be used as a web service, and the server takes steps to make that happen. Prior to annotations, that information was supplied solely by XML configuration files. With Java EE 5, annotations were provided with which a class could be internally marked as a web service.

Annotation Details

---

• Annotations are defined as a sort of interface, but an @ symbol precedes the interface keyword in the declaration (as in @interface). When used, an @ symbol is prepended to the name.
• They can be parameterized with optional elements.
• A parameter element named value is special - if it is the only element, then it does not need to be named when used (a single value passed to the annotation will be assumed to be the value).
• For annotations accepting only one parameter, that parameter should be named value.
• An annotation with no parameters serves as a marker, much like implementing the Serializable interface.
• They are used as modifiers preceding any target code entities that are declared: class, field, method, constructor, method parameters, return values, package, or local variables.
• Based on their specified retention policy, they can be discarded after compilation (the SOURCE policy), or preserved into the compiled class (CLASS persists, but the JVM isn't required to keep the information after the class is loaded, and RUNTIME annotations do remain with the class in the JVM).
• @Override is an example of the source type, since it is only needed by the compiler
• A runtime type that you might encounter the effect of is @Deprecated, which states that an element is deprecated - you will receive a compiler warning if your code uses an element marked with this annotation (and, since you might be accessing the element in an already-compiled class, this annotation must persist into the compiled class file).
• @SuppressWarnings is another source annotation, with an optional element to specify what types of warnings are to be suppressed.
• The annotation definitions are themselves annotated: -@Target and @Retention are used before the annotation definition to specify which type of element receives the annotation, and what the retention is.

Using Annotations

---

To apply an annotation to a class or element, precede the item with the name of the annotation, prefixed with the @ symbol.

If the annotation takes parameters, supply them in parentheses, as a comma separated list of parameterName=parameterValue. If the only parameter is called value, then you can just supply the parameterValue, without specifying it by name.

@AnnotationName(value=parameterValue, parameter2Name=parameter2Value, ...)

Code Sample:

Java-Interfaces/Demos/AnnotatedWebService.java

import javax.jws.WebService; import javax.jws.WebMethod; import javax.jws.WebParam; import java.util.Date; @WebService(serviceName="DateTimeService") public class AnnotatedWebService { @WebMethod public Date getDate() { return new Date(); } @WebMethod public Date getFutureDate(@WebParam(name="days") int daysOffset) { Date d = new Date(); d.setDate(d.getDate() + daysOffset); return d; } }

The @WebService annotation persists into compiled code. Tools that work with enterprise-level web servers (like Glassfish, JBoss, etc.), can read the annotation via reflection, and install the class as a web service, performing all the necessary tasks, such as creating a WSDL file, establishing a URL for the service, and installation it under that URL. The annotation can be parameterized with the name for the service (which defaults to the class name followed by "Service"), as well as several other items affecting the setup as a web service.

• The serviceName parameter to the @WebService annotation tells the server to set up the service under that name, as opposed to the default, which would have been AnnotatedWebServiceService (the default behavior appends "Service" to the class name, which, in this case, would be redundant).
• The @WebMethod annotations tell the server that these methods should be set up as RPC methods which can be remotely invoked (by default, the methods are exposed, the annotation is actually only needed when renaming the method, or to exclude the method from the service, but common practice is to include the unparameterized annotation for methods to be exposed as is).
• The @WebParam annotation is used to rename the daysOffset parameter, which would be used from ordinary Java code, to days when the RPC is remotely invoked. Due to the limitations of reflection, where parameter names are not preserved into compiled classes, this annotation is necessary to avoid having the parameters be called arg0, arg1, etc.

13 - JAVA EXEPTIONS

xceptions are generated when a recognized condition, usually an error condition, occurs during the execution of a method. There are a number of standard error conditions defined in Java, and you may define your own error conditions as well.

When an exception is generated, it is said to be thrown.

Java syntax includes a system for managing exceptions, by tracking the potential for each method to throw specific exceptions. Note that:

• For each method that could throw an exception, your code must inform the Java compiler that it could throw that specific exception.
• The compiler marks that method as potentially throwing that exception, and then requires any code calling the method to handle the possible exception.

There are two ways to handle an exception:

• You can try the "risky" code, catch the exception, and do something about it, after which the propagation of the exception ceases.
• You can mark the method with the risky statement indcating that it throws an exception. Any statement that calls a method capable of throwing an exception must deal with it.
So, if you use a method in your code that is marked as throwing a particular exception, the compiler will not allow that code unless you handle the exception Once an exception is thrown, it propagates backward up the chain of methods, from callees to callers, until it is caught. Note that:
• If the exception occurs in a try block, the JVM looks to the catch block(s) that follow to see if any of them match the exception type.
• The first one that matches will be executed.
• If none match, then this method ends, and execution jumps to the method that called this one, at the point where the call was made.
If an exception is not caught in your code (which would happen if main was marked as throwing the exception) then the JVM will catch the exception, end that thread of execution, and print a stack trace. There are cases where the compiler does not enforce these rules. Exceptions that fit this category are called unchecked exceptions.

Handling Exceptions

---

Let's say we are writing a method called getThatInt(ResultSet rs) and we want to use the method getInt(int column) from the ResultSet passed in as a parameter:

public int getThatInt(ResultSet rs) { int i = 0; return rs.getInt(3); }

A look at the API listing for ResultSet tells us that the getInt() method throws SQLException, so we must handle that in our code

1.Use try and catch

public int getThatInt(ResultSet rs) { int i = 0; try { i = rs.getInt(3); } catch (SQLException e) { System.out.println("Exception occurred!"); System.out.println(e.getMessage()); e.printStackTrace(); } return i; }

2.Declare that the method will throw the exception and let our caller handle it

public int getThatInt(ResultSet rs) throws SQLException { int i = 0; i = rs.getInt(3); return i; }

Note that although you are required to "handle" the exception, you aren't necessarily required to do anything useful about it!

Your decision as to which approach to use should be based on where you think responsibility for handling the exception lies. In the example above, the second approach is probably better, so that the code that works more closely with the SQL handles the exception.

Exception Objects

---

When an exception is thrown, an exception object is created and passed to the catch block much like a parameter to a method. Note that:

Occurrence of an exception generates an object (an instance of a class in the exception hierarchy) containing information about the exception.

The exception object is passed to the code designated to catch the exception, which may then use methods of the exception object to help handle the situation.

There is an API class called Exception. Note that:

All exception classes inherit from Exception, which inherits from Throwable.

Another class, Error, also inherits from Throwable.

Your code must handle most exceptions, but generally should not attempt to handle Error subtypes (like OutOfMemoryError or StackOverflowError).

RuntimeException is a subclass of Exception that is a base class for all the exception classes that you are not obligated to handle, but still might want to anyway (examples are ArithmeticException, from dividing by zero, NullPointerException, and ArrayIndexOutOfBoundsException).

So, there are several classes of exceptions you are not required to handle (shaded in the image below). Note that:

These extend either Error or RuntimeException.

The ones you are required to handle are called checked exceptions.

Generally, runtime exceptions can be prevented by good coding practices:

• Avoid null pointer exceptions by checking the reference first.
• Check array indexes before using them to avoid ArrayIndexOutOfBoundsException.
• Looking at the documentation for allowable parameter values and testing them before passing them to a method will prevent IllegalArgumentException.

Attempting Risky Code - try and catch

---

If a method is going to resolve a potential exception internally, the line of code that could generate the exception is placed inside a try block.

There may be other code inside the try block, before and/or after the risky line(s). Any code that depends upon the risky code's success should be in the try block, since it will automatically be skipped if the exception occurs.

try { risky code code that depends on the risky code succeeding }

There is usually at least one catch block immediately after the try block. A catch block must specify what type of exception it will catch.

catch (xceptionClassName exceptionObjectName) { code using methods from exceptionObjectName }

There can be more than one catch block, each one marked for a specific exception class.

The exception class that is caught can be any class in the exception hierarchy, either a general (base) class, or a very specific (derived) class.

The catch block(s) must handle all checked exceptions that the try block is known to throw unless you want to throw that exception back to the method that called this one.

It is possible to have a try block without any catch blocks if you have a finally block, but any checked exceptions still need to be caught, or the method needs to declare that it throws them. We will cover finally later in this section.

If an exception occurs within a try block, execution jumps to the first catch block whose exception class matches the exception that occurred (using an instanceof test). Any steps remaining in the try block are skipped. If no exception occurs, then the catch blocks are skipped. The catch blocks will also be skipped if an exception that is not caught occurs, such as a RuntimeException, or an exception that the method declared it throws.

You cannot catch an exception that would not occur in the try block, but you can mark a method as throwing an exception that it doesn't (this leaves open the possibility that an extending class can override the method and actually throw the exception).

Notes on try ... catch Blocks and Variable Scope/Initialization

If you declare a variable within a try block, it will not exist outside the try block, since the curly braces define the scope of the variable. You will often need that variable later, if nowhere else other than the catch or finally blocks, so you would need to declare the variable before the try.

If you declare but don't initialize a variable before a try block, and the only place you set a value for that variable is in the try block, then it is possible when execution leaves the try ... catch structure that the variable never received a value.

So, you would get a "possibly uninitialized value" error message from the compiler, since it actually keeps track of that sort of thing.

Usually this happens with object references; you would generally initialize them to null.

Code Sample:

Java-Exceptions/Demos/ExceptionTest.java

public class ExceptionTest { public static void main(String[] args) { int i, j, x = 5, y = 5, z = 0; try { i = x/y; System.out.println("x/y = " + i); j = x/z; System.out.println("x/z = " + j); } catch(ArithmeticException e) { System.out.println("Arithmetic Exception!"); } System.out.println("Done with test"); } }

The program will print the first result, then fail while performing the division for the second equation. Execution will jump to the catch block to print our message on the screen.

Note: ArithmeticException is one of the few you are not required to catch, but you can still catch it if you wish.

Example - An Exception You Must Handle

The preceding example used a RuntimeException which your code is not obligated to handle.

Most methods in the I/O classes throw IOException which is an exception you must handle.

Our KeyboardReader class has try and catch to handle this, essentially stifling the exception, since it is unlikely, if not impossible, to actually get an IOException from the keyboard.

Code Sample:

Java-Exceptions/Demos/IOExceptionTest.java

import java.io.IOException; public class IOExceptionTest { public static void main(String[] args) { int num = 0; num = System.in.read(); // comment out this line try { num = System.in.read(); System.out.println("You entered " + (char) num); } catch (IOException e) { System.out.println("IO Exception occurred"); } } }

The line marked to comment out throws IOException, but is not in a try block, so the compiler rejects it. The second read attempt is within a try block, as it should be.

• Ttry to compile this code as is and then comment out the indicated line.
• There is no way we can force an IOException from the keyboard to test the catch block.

Using Multiple catch Blocks

It is possible that a statement might throw more than one kind of exception. You can list a sequence of catch blocks, one for each possible exception. Remember that there is an object hierarchy for exceptions. Since the first one that matches is used and the others skipped, you can put a derived class first and its base class later (you will actually get a compiler error if you list a more basic class before a derived class, as it is "unreachable code").

Code Sample:

Java-Exceptions/Demos/MultiCatchTest.java

import util.KeyboardReader; public class MultiCatchTest { public static void main(String[] args) { int num1, num2; try { num1 = KeyboardReader.getPromptedInt("Enter a number: "); num2 = KeyboardReader.getPromptedInt("Enter another number: "); System.out.println(num1 + " / " + num2 + " = " + num1/num2); } catch (NumberFormatException e) { System.out.println("Number Format Exception occurred"); } catch (ArithmeticException e) { System.out.println("Divide by Exception occurred"); } catch (Exception e) { System.out.println("General Exception occurred"); } } }

The code in the try block could throw NumberFormatException during the parsing, and ArithmeticException while doing the division, so we have catch blocks for those specific cases. The more generic catch block for Exception would catch other problems, like NullPointerException.

Guaranteeing Execution of Code - The finally Block

---

To guarantee that a line of code runs, whether an exception occurs or not, use a finally block after the try ... catch blocks.

The code in the finally block will almost always execute.

<li>If an exception causes a catch block to execute, the finally block will be executed after the catch block.</li> <li>If an uncaught exception occurs, the finally block executes, and then execution exits this method and the exception is thrown to the method that called this method.</li> <li>If either the try block or a catch block executes a return statement, the finally block executes before we leave the method.</li> <li>If either the try block or a catch block calls System.exit, the finally block will not execute.</li> <li>For the sake of completeness, if a finally block executes a return while an uncaught exception is pending, the exception is stifled; that is, it just disappears.</li> try { risky code block } catch (ExceptionClassName exceptionObjectName) { code to resolve problem } finally { code that will always execute }

In summary, note the following:

• A try block is followed by zero or more catch blocks.
• If the catch block exception classes caught are related, the blocks must be listed in inheritance order from most derived to most basic.
• There may one finally block as the last block in the structure.
• There must be at least one block from the combined set of catch and finally after the try.

It's possible to have a try block followed by a finally block, with no catch block. This is used to prevent an unchecked exception, or an exception the method declared it throws, from exiting the method before cleanup code can be executed.

Code Sample:

Java-Exceptions/Demos/FinallyTest.java

import util.KeyboardReader; public class FinallyTest { public static void main(String[] args) { System.out.println("Returned value is " + go()); } public static int go() { int choice = 0; try { String name = KeyboardReader.getPromptedString("Enter your name: "); System.out.println("MENU:"); System.out.println("1 - normal execution"); System.out.println("2 - uncaught ArithmeticException"); System.out.println("3 - return from try block"); System.out.println("4 - call System.exit"); System.out.println( "5 - return 5 from finally after ArithmeticException"); System.out.println( "6 - return 6 from finally after try returns -1"); System.out.println("X - catch NumberFormatException"); choice = KeyboardReader.getPromptedInt("Enter your choice: "); if (choice == 1) System.out.println("Hello " + name); else if (choice == 2) System.out.println("1 / 0 = " + 1/0); else if (choice == 3) return 3; else if (choice == 4) System.exit(1); else if (choice == 5) System.out.println("1 / 0 = " + 1/0); else if (choice == 6) return -1; } catch (NumberFormatException e) { System.out.println("Number Format Exception occurred"); } finally { System.out.println("Goodbye from finally block"); if (choice == 5) return 5; if (choice == 6) return 6; } return 0; } }

The program shows a menu of possible execution paths you can trigger. The "Goodbye from finally block " message will always appear except from an explicit call to System.exit in the try block:

• When no exception occurs, the finally block will execute after the try.
• If an uncaught exceptions occurs, like when we divide by zero, the finally block will execute before we are thrown out of the method.
• If we execute a return from the try block, the finally block still executes before we leave.
• Catching a NumberFormatException is still followed by executing the finally block.
• But, calling System.exit in the try block causes the JVM to shut down without executing the finally block.
• When we force an uncaught exception but return from the finally block, we do not get a stack trace, indicating that the ArithmeticException just disappeared (compare choices 2 and 5).
• When both the try block and the finally block execute a return statement, the value from the finally block is the one actually returned.

Letting an Exception be Thrown to the Method Caller

---

A method that generates an exception can be written to not catch it. Instead it can let it be thrown back to the method that called it.

The possibility that a method may throw an exception must be defined with the method.

[modifiers] returnType functionName(arguments) throws ExceptionClassName { body including risky code }

Then an instance of ExceptionClassName or a class that extends it may be thrown so, stating that a method throws Exception is about as generic as you can get (stating that it throws Throwableis as generic as you can get, but not recommended). A method can throw more than one type of exception; in which case you would use a comma-separated list of exception types.

In this way, the method is now marked as throwing that type of exception, and a code that calls this method will be obligated to handle it.

When you extend a class and override a method, you cannot add exceptions to the throws list, but a base class method can list exceptions that it does not throw in the expectation that an overriding method will throw the exception. This is another example of the "inheritance cannot restrict access" principle we saw earlier.

If main() throws an exception, the JVM, which runs under Java rules, will handle the exception (by printing a stack trace and closing down the offending thread. In a single-threaded program, this will shut down the JVM).

Throwing an Exception

---

The keyword throw is used to trigger the exception-handling process (or, "raise" the exception, as it is often termed in other languages).

That word is followed by an instance of a throwable object, i.e., an instance of a class that extends Throwable. Usually, a new instance of an appropriate exception class is created to contain information about the exception.

For example, suppose a setAge() method expects a nonnegative integer; we can have it throw an IllegalArgumentException if it receives a negative value. It makes sense for the method that calls setAge() to do something about the problem, since it is where the illegal number came from.

So, we can declare setAge() as throws IllegalArgumentException.

public void setAge(int age) throws IllegalArgumentException { if (age < 0) throw new IllegalArgumentException("Age must be >= 0"); else this.age = age; }

Payroll-Exceptions01: Handling NumberFormatException in Payroll

---

Duration: 5 to 10 minutes. Our program to this point has been prone to potential bad numeric inputs when reading from the keyboard. The parsing methods all throw NumberFormatException.
We could now put each line that requests a number inside a small loop.

The loop could be controlled by a boolean variable, perhaps with a name like isInvalid and initially set to true (using the reverse approach is also a possible strategy).

• Inside the loop, we try the read and parse operations.
• Then, still in the try block, change the state of the boolean to one that will end the loop (because we wouldn't get to that step unless we succeeded).
• In the catch block, print an error message and request to try again.

Where would you put this code? In the payroll main method or in the KeyboardReader class?

Solution:

As a general principle, tools shouldn't attempt to handle exceptions when the handling logic would vary depending on the code using the tool. But, it would be a tremendous burden to put each step of a program that requests a numeric input in a looped try/catch block.

Instead, we could recognize that a common approach would be to loop until the input is numeric, printing an error message each time.

We could overload the get methods in KeyboardReader to accept an error message string, so it could do the looping for us. This way a reasonable solution would be provided, but the original method would still be available if the programmer wants to customize the exception handling.

If a programmer wants a different approach, they are still free to write it in their code and use the original KeyboardReader methods .

Payroll-Exceptions01, continued

---

Duration: 15 to 20 minutes.
1. Go ahead and add a second version of each get numeric method in KeyboardReader that accepts an error message string as a second parameter; have it loop on each numeric input request until it succeeds without throwing the exception (and printing the error message each time the exception occurs).
2. Then modify Payroll to call these methods.

Challenge

This approach still doesn't solve the problem of limited employee types, valid department numbers, etc. Can you think of an approach that would? (Hint: interfaces are a powerful tool ...).

Solution:

Solutions/Payroll-Exceptions01/util/KeyboardReader.java

package util; import java.io.*; public class KeyboardReader { ---- C O D E O M I T T E D ---- public static int getPromptedInt(String prompt, String errMsg) { for ( ; ; ) { try { return Integer.parseInt(getPromptedString(prompt)); } catch (NumberFormatException nfe) { System.out.println(errMsg); } } } public static float getPromptedFloat(String prompt, String errMsg) { for( ; ; ) { try { return Float.parseFloat(getPromptedString(prompt)); } catch (NumberFormatException nfe) { System.out.println(errMsg); } } } public static double getPromptedDouble(String prompt, String errMsg) { for( ; ; ) { try { return Double.parseDouble(getPromptedString(prompt)); } catch (NumberFormatException nfe) { System.out.println(errMsg); } } } }

Solution:

Solutions/Payroll-Exceptions01/Payroll.java

import employees.*; import vendors.*; import finance.*; import util.*; public class Payroll { public static void main(String[] args) { Employee[] e = new Employee[5]; String fName = null; String lName = null; int dept = 0; double payRate = 0.0; double hours = 0.0; for (int i = 0; i < e.length; i++) { char type = KeyboardReader.getPromptedChar( "Enter type: E, N, or C: "); if (type != 'e' && type != 'E' && type != 'n' && type != 'N' && type != 'c' && type != 'C') { System.out.println("Please enter a valid type"); i--; continue; } fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); dept = KeyboardReader.getPromptedInt( "Enter department: ", "Department must be numeric"); do { payRate = KeyboardReader.getPromptedDouble( "Enter pay rate: ", "Pay rate must be numeric"); if (payRate < 0.0) System.out.println("Pay rate must be >= 0"); } while (payRate < 0.0); switch (type) { case 'e': case 'E': e[i] = new ExemptEmployee(fName, lName, dept, payRate); break; case 'n': case 'N': do { hours = KeyboardReader.getPromptedDouble( "Enter hours: ", "Hours must be numeric"); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); e[i] = new NonexemptEmployee( fName, lName, dept, payRate, hours); break; case 'c': case 'C': do { hours = KeyboardReader.getPromptedDouble( "Enter hours: ", "Hours must be numeric"); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); e[i] = new ContractEmployee( fName, lName, dept, payRate, hours); } System.out.println(e[i].getPayInfo()); } ---- C O D E O M I T T E D ---- } }

The revised code uses the new overloads of the getPromptedXXX methods.

Challenge Solution:

Solutions/Payroll-Exceptions01-challenge/util/IntValidator.java

package util; public interface IntValidator { public boolean accept(int candidate); }

This interface specifies a method that will be used to validate integers. A validator for a specific field (like department) would implement this with code to test for legal values for that field. The package contains similar interfaces for floats and doubles.

Challenge Solution:

Solutions/Payroll-Exceptions01-challenge/employees/DeptValidator.java

package employees; import util.IntValidator; public class DeptValidator implements IntValidator { @Override public boolean accept(int dept) { return dept > 0 && dept <= 5; } } /* Sample usage in Payroll dept = KeyboardReader.getPromptedInt( "Enter department: ", "Dept must be numeric", new DeptValidator(), "Valid depts are 1 - 5"); */

This class validates department numbers to be from 1 - 5 inclusive. We also could create separate validators for pay rates, etc.

Challenge Solution:

Solutions/Payroll-Exceptions01-challenge/util/KeyboardReader.java

package util; import java.io.*; public class KeyboardReader { ---- C O D E O M I T T E D ---- public static int getPromptedInt(String prompt) { return Integer.parseInt(getPromptedString(prompt)); } public static int getPromptedInt(String prompt, String errMsg) { for ( ; ; ) { try { return Integer.parseInt(getPromptedString(prompt)); } catch (NumberFormatException e) { System.out.println(errMsg); } } } public static int getPromptedInt( String prompt, String formatErrMsg, IntValidator val, String valErrMsg) { for ( ; ; ) { try { int num = Integer.parseInt(getPromptedString(prompt)); if (val.accept(num)) return num; else System.out.println(valErrMsg); } catch (NumberFormatException e) { System.out.println(formatErrMsg); } } } public static float getPromptedFloat(String prompt) { return Float.parseFloat(getPromptedString(prompt)); } public static float getPromptedFloat(String prompt, String errMsg) { for ( ; ; ) { try { return Float.parseFloat(getPromptedString(prompt)); } catch (NumberFormatException e) { System.out.println(errMsg); } } } public static float getPromptedFloat( String prompt, String formatErrMsg, FloatValidator val, String valErrMsg) { for ( ; ; ) { try { float num = Float.parseFloat(getPromptedString(prompt)); if (val.accept(num)) return num; else System.out.println(valErrMsg); } catch (NumberFormatException e) { System.out.println(formatErrMsg); } } } public static double getPromptedDouble(String prompt) { return Double.parseDouble(getPromptedString(prompt)); } public static double getPromptedDouble(String prompt, String errMsg) { for ( ; ; ) { try { return Double.parseDouble(getPromptedString(prompt)); } catch (NumberFormatException e) { System.out.println(errMsg); } } } public static double getPromptedDouble( String prompt, String formatErrMsg, DoubleValidator val, String valErrMsg) { for ( ; ; ) { try { double num = Double.parseDouble(getPromptedString(prompt)); if (val.accept(num)) return num; else System.out.println(valErrMsg); } catch (NumberFormatException e) { System.out.println(formatErrMsg); } } } }

Exceptions and Inheritance

---

If a base class method throws an exception, that behavior will also occur in any derived classes that do not override the method.

An overriding method may throw the same exception(s) that the base class method threw.
An overriding method cannot add new exceptions to the throws list. Similar to placing more strict access on the method, this would restrict the derived class object in ways that a base class reference would be unaware of.

If the derived class method does not throw the exception that the base class threw, it can either:

Retain the exception in the throws list, even though it does not throw it; this would enable subclasses to throw the exception.
Remove the exception from its throws list, thus blocking subsequent extensions from throwing that exception.
If you have a base class method that does not throw an exception, but you expect that subclasses might, you can declare the base class to throw that exception.

Exception Class Constructors and Methods

There are several forms of constructors defined in the base class for the exception hierarchy.

Constructor	Description
Throwable()	Constructs a new throwable with null as its detail message.
Throwable(String message)	Constructs a new throwable with the specified detail message.
Throwable(String message, Throwable cause)	Constructs a new throwable with the specified detail message and cause.
Throwable(Throwable cause)	Constructs a new throwable with the specified cause and a detail message of (cause==null ? null : cause.toString()) (which typically contains the class and detail message of cause).

The forms involving a cause are used in situations like Servlets and Java Server Pages, where a specific exception is thrown by the JSP engine, but it may be rooted in an exception from your code.

In both cases, a method in a base class is overridden by your code since the writers of the base class did not know what specific exceptions your code might throw, and didn't want to specify something too broad like throws Exception, they settled on throws IOException, ServletException (or JSPException for Java Server Pages).
You would try and catch for your expected exceptions and repackage them inside ServletException objects if you did not want to handle them

Method	Description
getMessage()	Prints the message that was associated with the exception (many of the exceptions that deal with outside resources pass on the message from the outside) - for example, when you connect to a database and run a query, that could generate an error in the database; getMessage() will show that message.
printStackTrace()	Prints to the standard error stream the trace of what function called what function, etc., leading up to the exception. There are variations of this method where you may specify a destination for the printing (note that stack trace includes the message).
printStackTrace(PrintStream stream)	Same as above, but prints to the specified output stream (which could be hooked to a log file, for example).

Also worth noting is that the Java Logging API has logging methods that will accept a Throwable parameter and make a log entry with the stack trace.

Creating and Using Your Own Exception Classes

---

You can create your own exception class by extending an existing exception class.

[modifiers] class NewExceptionClassName extends ExceptionClassName { create constructors that usually delegate to super-constructors }

You could then add any fields or methods that you wish, although often that is not necessary.

You must, however, override any constructors you wish to use: Exception(), Exception(String message), Exception(String message, Throwable cause), Exception(Throwable cause). Usually you can just call the corresponding super-constructor.

If you extend RuntimeException or one of its subclasses, your exception will be treated as a runtime exception (it will not be checked).

When a situation arises for which you would want to throw the exception, use the throw keyword with a new object from your exception class, for example:

throw new ExceptionClassName(messageString);

Code Sample:

Java-Exceptions/Demos/NewExceptionTest.java

class NewException extends Exception { NewException() { super(); } NewException(String message) { super(message); } NewException(String message, Throwable cause) { super(message, cause); } NewException(Throwable cause) { super(cause); } } public class NewExceptionTest { public void thrower() throws NewException { if (Math.random() < 0.5) { throw new NewException("This is my exception"); } } public static void main(String[] args) { NewExceptionTest t = new NewExceptionTest(); try { t.thrower(); } catch(NewException e) { System.out.println("New Exception: " + e.getMessage()); } finally { System.out.println("Done"); } } }

The thrower method randomly throws a NewException, by creating and throwing a new instance of NewException.

main tries to call thrower, and catches the NewException when it occurs.

Payroll-Exceptions02

---

Duration: 20 to 30 minutes.
Our payroll program can now handle things like a bad numeric input for pay rate (valid format, but not sensible, like a negative number) in a more comprehensive manner. We already are checking the numeric inputs from the keyboard, but there is no guarantee that later code will remember to do this. Using an exception mechanism guarantees protection from invalid values.

In the util package, create an exception class for InvalidValueException. Note that the Java API already contains a class for this purpose, IllegalArgumentException, but it is a RuntimeException - we would like ours to be a checked exception.
In Employee (and potentially its subclasses), change the constructors that accept pay rate and the setPayRate methods to now throw that exception (a question to ask yourself - is it necessary to actually test the pay rate value anywhere other than in the Employee class setPayRate method?). You will see that the effect of throwing the exception ripples through a lot of code. For any code that calls those constructors/methods, choose an appropriate approach to dealing with the potential exception.
The solution uses the validators from the previous challenge exercise, it will work without that feature, but feel free to add that logic into your code as well.

Solution:

Solutions/Payroll-Exceptions02/util/InvalidValueException.java

package util; public class InvalidValueException extends Exception { public InvalidValueException() { super(); } public InvalidValueException(String message) { super(message); } public InvalidValueException(Throwable cause) { super(cause); } public InvalidValueException(String message, Throwable cause) { super(message, cause); } }

Solution:

Solutions/Payroll-Exceptions02/employees/Employee.java

package employees; import finance.Payable; import util.*; public class Employee extends Person implements Payable { ---- C O D E O M I T T E D ---- public Employee(String firstName, String lastName, double payRate) throws InvalidValueException { super(firstName, lastName); setPayRate(payRate); } public Employee(String firstName, String lastName, int dept, double payRate) throws InvalidValueException { this(firstName, lastName, dept); setPayRate(payRate); } ---- C O D E O M I T T E D ---- public void setPayRate(double payRate) throws InvalidValueException { DoubleValidator val = new ValidatePayRate(); if (!val.accept(payRate)) throw new InvalidValueException(payRate + " is an invalid pay rate"); this.payRate = payRate; } ---- C O D E O M I T T E D ---- }

The marking of setPayRate throws InvalidValueException ripples through the constructors, so they should be marked as well.

Solution:

Solutions/Payroll-Exceptions02/employees/ExemptEmployee.java

package employees; import util.*; public class ExemptEmployee extends Employee { public ExemptEmployee() { } public ExemptEmployee(String firstName, String lastName) { super(firstName, lastName); } public ExemptEmployee(String firstName,String lastName, int dept) { super(firstName, lastName, dept); } public ExemptEmployee(String firstName, String lastName, double payRate) throws InvalidValueException { super(firstName, lastName, payRate); } public ExemptEmployee(String firstName, String lastName, int dept, double payRate) throws InvalidValueException { super(firstName, lastName, dept, payRate); } public String getPayInfo() { return "Exempt Employee " + getId() + " dept " + getDept() + " " + getFirstName() + " " + getLastName() + " paid " + getPayRate(); } }

Calling super-constructors that throw our exception requires that these constructors also be marked. The other classes, not shown, should be similarly marked.

Solution:

Solutions/Payroll-Exceptions02/Payroll.java

import employees.*; import vendors.*; import util.*; import finance.*; public class Payroll { public static void main(String[] args) { ---- C O D E O M I T T E D ---- for (int i = 0; i < e.length; i++) { try { ---- C O D E O M I T T E D ---- do { payRate = KeyboardReader.getPromptedDouble("Enter pay rate: ", "Pay rate must be numeric"); if (payRate < 0.0) System.out.println("Pay rate must be >= 0"); } while (payRate < 0.0); switch (type) { case 'e': case 'E': e[i] = new ExemptEmployee(fName, lName, dept, payRate); break; case 'n': case 'N': do { hours = KeyboardReader.getPromptedDouble( "Enter hours: ", "Hours must be numeric"); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); e[i] = new NonexemptEmployee(fName, lName, dept, payRate, hours); break; case 'c': case 'C': do { hours = KeyboardReader.getPromptedDouble( "Enter hours: ", "Hours must be numeric"); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); e[i] = new ContractEmployee(fName, lName, dept, payRate, hours); } ---- C O D E O M I T T E D ---- } catch (InvalidValueException ex) { System.out.println(ex.getMessage()); i--; //failed, so back up counter to repeat this employee } } ---- C O D E O M I T T E D ---- } }

Since we are already checking the values of the pay rate and hours, we shouldn't expect to see any exceptions thrown, so it is reasonable to put the entire block that gets the employee data and creates an employee in a try block. If we decrement the counter upon a failure, then that employee's data will be requested again.

You might want to test your logic by temporarily changing one of the test conditions you use when reading input (like hours > 0 to hours > -20), so that you can the result (keep count of how many employees you are asked to enter).

Rethrowing Exceptions

---

An exception may be rethrown.

When we throw an exception, it does not necessarily have to be a new object. We can reuse an existing one.

This allows us to partially process the exception and then pass it up to the method that called this one to complete processing. This is often used in servlets and JSPs to handle part of the problem (possibly just log it), but then pass the problem up to the servlet or JSP container to abort and send an error page.

String s = "1234X"; try { Integer.parseInt(s); } catch (NumberFormatException e) { System.out.println("Bad number, passing buck to JVM"); throw e; }

The stack trace will still have the original information. The fillInStackTrace method for the exception object will replace the original information with information detailing the line on which fillInStackTrace was called as the origin of the exception.

Initializer Blocks

---

Class properties that are object types can be initialized with a newly constructed object.

public class MyClass { private Random rand = new java.util.Random(); private MegaString ms = new MegaString("Hello " + rand.nextInt(100)); private int x = rand.nextInt(100); . . . }

The MegaString class constructor code will run whenever a MyClass object is instantiated.

But what if the object's constructor throws an exception?

class MegaString{ public MegaString(String s) throws Exception { . . . } }

The MyClass code won't compile - you cannot put a property declaration into a try ... catch structure and there is no place to state that the property declaration throws an exception.

You can use an initializer block to handle this situation.

public class MyClass { private java.util.Random rand = new java.util.Random(); private MegaString ms = null; { try { ms = new MegaString()"Hello " + rand.nextInt(100); } catch (Exception e) { . . . } } private int x = rand.nextInt(100); . . . }

This is not absolutely necessary, since the initialization could be done in a constructor, where a try ... catch would be legal. But then it would need to be done in every constructor, which someone adding another constructor later might forget.

Initializers are run in the order in which they appear in the code, whether standalone initializers, or initializers in a field declaration so, in the above code:

The Random object gets created for the first field.
The MegaString gets the first generated random number.
x gets the second generated random number.

Static Initializer Blocks

If a field is static, and is populated with a newly constructed object, that object's constructor code will run when the class loads. In our example, if we make the MegaString property static, its constructor will run when the class loads.

public class MyClass { private static MegaString sms = new MegaString("Goodbye"); . . . }

Again, this won't compile, but now there is no way even to defer the issue to the constructors, since the element is static.

You can use a static initializer block to handle this problem.

public class MyClass { private static MegaString sms = null; static { try { sms = new MegaString("Hello"); } catch (Exception e) { . . . } } . . . }

Again, the initializers are run in the order in which they appear in the code, when the class is loaded.

Assertions

---

Java 1.4 added the concept of assertions, code lines that test that a presumed state actually exists

-If the state is not as presumed, then an AssertionError will be thrown.
-Assertions are not intended for testing values that could be expected; they are intended to be used when it is believed that a state exists, but we are not absolutely sure we have covered all the possible avenues that affect the state.

To use an assertion in code:

assert (condition) [: messageExpression];

The optional messageExpression will be converted to a String and passed as the message to the AssertionError constructor, so it cannot be a call to a function declared as void.

For example, perhaps we are using a third-party function that is specified to return a double value between 0 and 1, but we'd like to guarantee that is the case.

Code Sample:

Java-Exceptions/Demos/AssertionTest.java

public class AssertionTest { public static void main(String[] args) { double value = thirdPartyFunction(); assert (value >= 0 && value < 1) : " thirdPartyFunction value " + value + " out of range"; System.out.println("Value is " + value); } public static double thirdPartyFunction() { return 5.0; } }

If the function returns a value outside of our expected range, like 5.0, the assertion condition will evaluate to false, so an AssertionError will be thrown with the message "thirdPartyFunction value 5.0 out of range."

Note: in a 1.4 compiler, you must inform the compiler that you are compiling your code under Java 1.4 rules to use assertions, using the -source 1.4 command line switch:

javac -source 1.4 ClassName.java

In Java 5 and later this is not necessary.

Assertions are used for debugging a program, and usually not enabled for production runs. You must specifically enable assertions when you run the program, by using the command line switch -enableassertions (or -ea).

java -enableassertions ClassName java -ea ClassName

Oracle's "rules" for assertions emphasize that they will be disabled most of the time:

-They should not be used for checking the values passed into public methods, since that check will disappear if assertions are not enabled.
-The assertion code shouldn't have any side effects required for normal operation.

14 - JAVA COLLECTIONS

The Java Collections API is a set of classes and interfaces designed to store multiple objects.

There are a variety of classes that store objects in different ways:

• Lists store objects in a specific order.
• Sets reject duplicates of any objects already in the collection.
• Maps store objects in association with a key, which is later used to look up and retrieve the object (note that if an item with a duplicate key is put into a map, the new item will replace the old item).

The basic distinctions are defined in several interfaces in the java.util package:

Collection is the most basic generally useful interface that most, but not all, collection classes implement.
• It specifies a number of useful methods, such as those to add and remove elements, ascertain the size of the collection, determine if a specific object is contained in the collection, or return an Iterator that can be used to loop through all elements of the collection (more on this later).
• Methods include: add(Object o), remove(Object o), contains(Object o), iterator().
• Note that removing an element removes an object that compares as equal to a specified object, rather than by position.
• Collection extends the Iterable interface, which only requires one method, which supplies an object used to iterate through the collection.
• The List interface adds the ability to insert and delete at a specified index within the collection, or retrieve from a specific position.
• The Set interface expects that implementing classes will modify the add methods to prevent duplicates, and also that any constructors will prevent duplicates (the add method returns a boolean that states whether the operation succeeded or not; i.e., if the object could be added because it was not already there).
• Sets do not support any indexed retrieval.
• The Map interface does not extend Collection, because its adding, removing, and retrieving methods use a key value to identify an element.
• Methods include: get(Object key), put(Object key, Object value), remove(Object key), containsKey(Object key), containsValue(Object value), keySet(), entrySet().
• Maps do not support any indexed retrieval.

In addition to the List, Set, and Map categories, there are also several inferences you can make from some of the collection class names:

• A name beginning with Hash uses a hashing and mapping strategy internally, although the key values usually have no meaning (the hashing approach attempts to provide an efficient and approximately equal lookup time for any element).
• A name beginning with Linked uses a linking strategy to preserve the order of insertion and is optimized for insertion/deletion as opposed to appending or iterating.
• A name beginning with Tree uses a binary tree to impose an ordering scheme, either the natural order of the elements (as specified by the Comparable interface implemented by many classes including String and the numeric wrapper classes) or an order dictated by a special helper class object (a Comparator).

Several additional interfaces are used to define useful helper classes:

• Enumeration provides a pair of methods that enable you to loop through a collection in a standardized manner, regardless of the type of collection (you test if there are more elements, and, if so, retrieve the next element).
• This interface is less frequently used now that the following interface has been added to the API.
• But, many of the elements in J2EE (servlets in particular) predate the Iterator concept and were specified to use enumerations, so they will still appear in new code.
• Iterator is an improved version that allows an object to be removed from the collection through the iterator.

The following diagrams show some of the classes and interfaces that are available:

Using the Collection Classes

---

The following are several examples of collection classes:

Vector stores objects in a linear list, in order of addition. Some additional notes on Vector are:

• You can insert and delete objects at any location.
• All methods are synchronized, so that the class is thread-safe.
• Vector predates the collections framework, but was marked to implement List when the collections API was developed

As a result, there are many duplicate methods, like add and addElement, since the names chosen for Collection methods didn't all match existing method names in Vector.

Vector was used extensively in the past, and therefore you will see it in a lot of code, but most recent code uses ArrayList instead.

ArrayList, like Vector, stores objects in a linear list, in order of addition. Methods are not synchronized, so that the class is not inherently thread-safe (but there are now tools in the Collections API to provide a thread-safe wrapper for any collection, which is why Vector has fallen into disuse).

TreeSet stores objects in a linear sequence, sorted by a comparison, with no duplicates. TreeSet also:

Stores Comparable items or uses a separate Comparator object to determine ordering.

Uses a balanced tree approach to manage the ordering and retrieval.

Note that there is no tree list collection, because the concepts of insertion order and natural order are incompatible. Since sets reject duplicates, any comparison algorithm should include a guaranteed tiebreaker (for example, to store employees in last name, first name order: to allow for two Joe Smiths, we should include the employee id as the final level of comparison).

TreeMap stores objects in a Map, where any subcollection or iterator obtained will be sorted by the key values. Note that:

Keys must be Comparable items or have a separate Comparator object.

For maps, an iterator is not directly available. You must get either the key set or entry set, from which an iterator is available.

Hashtable stores objects in a Map. Note also that:

All methods are synchronized, so that the class is thread-safe.

Hashtable predates the collections framework, but was marked to implement Map when the collections API was developed.

Like Vector, Hashtablehas some duplicate methods.

Hashtable extends an obsolete class called Dictionary.

HashSet uses hashing strategy to manage a Set. Note also that:

HashSet rejects duplicate entries.

Entries are managed by an internal HashMap that uses the entry hashCode values as the keys.

Methods are not synchronized.

Using the Iterator Interface

---

Iterators provide a standard way to loop through all items in a collection, regardless of the type of collection. Note that:

All collection classes implement an iterator() method that returns the object's iterator (declared as Iterator iterator()). This method is specified by the Iterable interface, which is the base interface for Collection. For maps, the collection itself is not Iterable, but the set of keys and the set of entries are. You can use a for-each loop for any Iterable object.

Without an iterator, you could still use an indexed loop to walk through a list using the size() method to find the upper limit, and the get(int index) method to retrieve an item, but other types of collections may not have the concept of an index, so an iterator is a better choice.

There are two key methods supplied by an iterator:

1. boolean hasNext(), which returns true until there are no more elements.
2. Object next(), which retrieves the next element and also moves the iterator's internal pointer to it.

Some collections allow you to remove an element through the iterator. The remove method is marked in the docs as optional by the definition of interfaces it has to be present, but the optional status indicates that it may be implemented to merely throw an UnsupportedOperationException.

In any case, if the collection is modified from a route other than via the iterator (perhaps by using remove(int index), or even just using the add method), a ConcurrentModificationException is thrown.

The Enumeration class is an older approach to this concept; it has methods hasMoreElements() and nextElement().

Code Sample:

Java-Collections/Demos/CollectionsTest.java

import java.util.*; public class CollectionsTest { public static void main(String[] args) { List l = new ArrayList(); Map m = new TreeMap(); Set s = new TreeSet(); l.add(new Integer(1)); l.add(new Integer(4)); l.add(new Integer(3)); l.add(new Integer(2)); l.add(new Integer(3)); m.put(new Integer(1), "A"); m.put(new Integer(4), "B"); m.put(new Integer(3), "C"); m.put(new Integer(2), "D"); m.put(new Integer(3), "E"); System.out.println("Adding to Set"); System.out.println("Adding 1: " + s.add(new Integer(1))); System.out.println("Adding 4: " + s.add(new Integer(4))); System.out.println("Adding 3: " + s.add(new Integer(3))); System.out.println("Adding 2: " + s.add(new Integer(2))); System.out.println("Adding 3: " + s.add(new Integer(3))); System.out.println("List"); Iterator i = l.iterator(); while (i.hasNext()) System.out.println(i.next()); System.out.println("Map using keys"); i = m.keySet().iterator(); while (i.hasNext()) System.out.println(m.get(i.next())); System.out.println("Map using entries"); i = m.entrySet().iterator(); while (i.hasNext()) System.out.println(i.next()); System.out.println("Set"); i = s.iterator(); while (i.hasNext()) System.out.println(i.next()); } }

This program demonstrates the three types of collections. As is commonly done, the variables are typed as the most basic interfaces (List, Set, and Map).

We attempt to add the same sequence of values to each: 1, 4, 3, 2, and 3; then:

They are deliberately out of sequence and contain a duplicate.

For the Map, the numbers are the keys, and single-letter strings are used for the associated values.

In the output, first note the true and false values resulting from attempting to add the values to the Set. Also note in the Map listing, which value associated with the key 3 is retained.

An iterator is then obtained for each and the series printed out (for the Map, we try two different approaches: iterating through the keys and retrieving the associated entries, and iterating directly through the set of entries).

Note the order of the values for each, and also which of the duplicates was kept or not. Note also that:

• Tthe List object stores all the objects and iterates through them in order of addition.
• The Map object stores by key; since a TreeMap is used, its iterator returns the elements sorted in order by the keys.
• Since one key is duplicated, the later of the two values stored under that key is kept.
• The Set object rejects the duplicate, so the first item entered is kept (although in this case it would be hard to tell from the iterator listing alone which one was actually stored).

Creating Collectible Classes

---

hashCode and equals

Both the equals(Object) method and hashCode() methods are used by methods in the Collections API. Note also that:

• The Map classes use them to determine if a key is already present.
• The Set classes use them to determine if an object is already in the set.
• All collections classes use them in contains and related methods.

Oracle specifies that the behavior of hashCode should be "consistent with equals", meaning that two objects that compare as equal should return the same hash code. The reverse is not required; two objects with the same hash code might be unequal, since hash codes provide "bins" for storing objects.

This is critical when writing collectible classes. For example, the implementation of HashSet, which should reject duplicate entries, compares a candidate entry's hashcode against that of each object currently in the collection. It will only call equals if it finds a matching hash code. If no hash code matches, it assumes that the candidate object must not match any already present in the set.

Comparable and Comparator

Sorted collections can sort elements in two ways:

1. By the natural order of the elements - objects that implement the Comparable interface have a natural order.
2. By using a third-party class that implements Comparator.
Comparable specifies one method: compareTo(Object o) returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

Comparator specifies two methods:
3. compare(Object a, Object b) returns a negative integer, zero, or a positive integer if a is less than, equal to, or greater than b.
4. equals(Object o), as in Object, is used not to compare the stored values for value, but to determine if two comparator classes can be considered equal. However, note that the behavior of the compare method should be consistent with equals, as Oracle's documentation advises; that is, compare(a, b) should return 0 when a.equals(b) returns true

As an example: TreeSet uses a tree structure to store items. Tthe tree part of the name is just for identifying the algorithm used for storage; you cannot make use of any of the node-related behaviors from the outside. There are several forms of constructors, most notably:

• TreeSet() uses the natural order of the items, so they must implement the Comparable interface (and the items should be mutually comparable, to avoid casting exceptions being thrown during a comparison).
• TreeSet(Comparator c) - uses the specified Comparator to compare the items for ordering (and, again, the mutually comparable caveat applies).

Code Sample:

Java-Collections/Demos/UseComparable.java

import java.util.*; public class UseComparable { public static void main(String[] args) throws java.io.IOException { String[] names = { "Sue", "Bill", "Tom", "Dave", "Andy", "Mary", "Beth", "Bill", "Mike" }; TreeSet sl = new TreeSet(Arrays.asList(names)); Iterator it = sl.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } }

Since String implements Comparable, the names will appear in alphabetical order when we iterate through the set.

The Arrays class provides useful methods for working with arrays, some of which will return a collection backed by the array (the Collections classes contain useful methods for working with collections, some of which perform the reverse operation).

Creating a Comparable Class

Classes that implement the Comparable interface may be stored in ordered collections. They must have a int compareTo(Object other) method to implement the interface. Note the following:

• It is said that these objects have a natural order as determined by this method.
• The function returns a negative value for this object considered less than the object passed as parameter other, a positive value for this object considered greater than the object passed as parameter other, and 0 if they are equal.
• Since this capability is built into the object, it is important that it the results of the compareTo method match with the results of the equals and hashCode methods.

Creating and Using a Comparator Class

Classes that implement the Comparator interface may be also used with ordered collections, but the collection must be constructed with an explicit reference to an instance of the Comparator. The Comparator is a separate class that will compare two instances of your class to determine the ordering.

The interface specifies int compare(Object a, Object b). The function returns a negative value for an object considered less than the object b, a positive value for b considered greater than a, and 0 if they are equal.

It is still important that the results of the compareTo method match with the results of the objects' equals method. Note that you should usually implement this method to avoid "ties" for objects that would not be considered equal. For example, for two different employees who coincidentally have the same name would be returned in an indeterminate order.

Code Sample:

Java-Collections/Demos/UseComparator.java

import java.util.*; public class UseComparator { public static void main(String[] args) throws java.io.IOException { String[] names = { "Sue", "Bill", "Tom", "Dave", "Andy", "Mary", "Beth", "Bill", "Mike" }; TreeSet s2 = new TreeSet(new ReverseComparator()); s2.addAll(Arrays.asList(names)); Iterator it = s2.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } } class ReverseComparator implements Comparator { public int compare(Object o1, Object o2) { if (o1 instanceof String && o2 instanceof String) return -((String)o1).compareTo((String)o2); else throw new ClassCastException("Objects are not Strings"); } }

The compare method of our comparator makes use of the existing compareTo method in String and simply inverts the result. Note that the objects being compared are tested to make sure both are String objects. If the test fails, the method throws a ClassCastException.

Code Sample:

Java-Collections/Demos/UseComparableAndComparator.java

import java.util.*; public class UseComparableAndComparator { public static void main(String[] args) throws java.io.IOException { String[] names = { "Sue", "Bill", "Tom", "Dave", "Andy", "Mary", "Beth", "Bill", "Mike" }; TreeSet sl = new TreeSet(Arrays.asList(names)); Iterator it = sl.iterator(); while (it.hasNext()) { System.out.println(it.next()); } TreeSet s2 = new TreeSet(new ReverseComparator()); s2.addAll(Arrays.asList(names)); it = s2.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } }

Since all the collections store are references, it will not use a lot of memory to store the same references in different collections. This creates an analog to a set of table indexes in a database

Collections in Java 5.0: Generics

---

Java 5.0 added the concept of Generics, which allow data types to be parameterized for a class

In earlier versions of Java, the collection methods to store objects all received a parameter whose type was Object. Therefore, the methods to retrieve elements were typed to return Object. To use a retrieved element, you had to typecast the returned object back to whatever it actually was (and somehow you had to know what it actually was).

The collections in Java 5.0 use a special, new syntax where the type of object is stated in angle brackets after the collection class name.

Instead of ArrayList, there is now ArrayList<E>, where the E can be replaced by any type. Within the class, method parameters and return values can be parameterized with the same type.

public class ArrayList<E> { . . . public void add(int index, E element) { ... } . . . public E get(int index) { } . . . }

For example, an ArrayList of String objects would be ArrayList<String>.

Code Sample:

Java-Collections/Demos/GenericCollectionsTest.java

import java.util.*; public class GenericCollectionsTest { public static void main(String[] args) { List<String> ls = new ArrayList<String>(); ls.add("Hello"); ls.add("how"); ls.add("are"); ls.add("you"); ls.add("today"); // using iterator StringBuffer result = new StringBuffer(); Iterator<String> is = ls.iterator(); while (is.hasNext()) result.append(is.next().toUpperCase()).append(' '); result.append('?'); System.out.println(result); // using for-each loop result = new StringBuffer(); for (String s : ls) result.append(s.toLowerCase()).append(' '); result.append('?'); System.out.println(result); // old way List l = new ArrayList(); l.add("Hello"); l.add("how"); l.add("are"); l.add("you"); l.add("today"); // using iterator result = new StringBuffer(); Iterator i = l.iterator(); while (i.hasNext()) result.append(((String)i.next()).toUpperCase()).append(' '); result.append('?'); System.out.println(result); // using for-each loop result = new StringBuffer(); for (Object o : l) result.append(((String)o).toLowerCase()).append(' '); result.append('?'); System.out.println(result); } }

As you can see, the objects retrieved from the ArrayList are already typed as being String objects. Note the following:

• We need to have them as String objects in order to call toUpperCase, whereas our previous examples only printed the objects, so being typed as Object was okay.
• Without generics, we must typecast each retrieved element in order to call toUpperCase.
• To use an iterator, we would declare the variable to use the same type of element as the collection we draw from, as in Iterator<String>.

Bounded Types

---

A type parameter may set bounds on the type used, by setting an upper limit (in inheritance diagram terms) on the class used. The extends keyword is used to mean that the class must either be an instance of the specified boundary class, or extend it, or, if it is an interface, implement it:

public class EmployeeLocator<T extends Employee> { . . . } public class CheckPrinter<T extends Payable> { . . . }

In the first case, the class may be parameterized with Employee, or any class that extends Employee. In the second, the class may be parameterized with Payable or any type that implements the Payable interface.

Extending Generic Classes and Implementing Generic Interfaces

---

When extending a generic class or implementing a generic interface, you can maintain the generic type, as in public class ArrayList<T> implements List<T>. In this case, types are still stated in terms of T.

You can lock in the generic type: public class EmployeeList extends ArrayList<Employee> or public class StringList implements java.util.List<String>. In these cases, methods would use the fixed type. For example, if you overrode add(E) in ArrayList<E> in the above EmployeeList, it would be add(Employee).

Generic Methods

---

Methods may be generic, whether or not they are in a generic class. The syntax is somewhat ugly, since it requires listing the type variable before the return type and requires that at least one parameter to the method be of the generic type (that is how the compiler knows what the type is).

public <T> T chooseRandomItem(T[] items) { Random r = new Random(); return items[r.nextInt(items.length)]; }

The above method is parameterized with type T. The type for T is established by whatever type of array is passed in; if we pass in a String array, then T is String. The method will then randomly pick one to return.

The type may be bounded with extends.

Variations on Generics - Wildcards

---

In the documentation for a collections class, you may see some strange type parameters for methods or constructors, such as:

public boolean containsAll(Collection<?> c) public boolean addAll(Collection<? extends E> c) public TreeSet(Comparator<? super E> comparator)

he question mark is a wildcard, indicating that the actual type is unknown. But, we at least know limits in the second two cases. The extends keyword in this usage actually means "is, extends, or implements" (which is the same criteria the instanceof operator applies). The super keyword means essentially the opposite: that the type parameter of the other class is, or is more basic than, this class's type. The usages with extends and super are called bounded wildcards.

This syntax only occurs when the variable is itself a generic class. The wildcards then state how that class's generic type relates to this class's type.

Why this is necessary leads down a long and winding path. To start, consider the following:

List<Employee> exEmps = new ArrayList<ExemptEmployee>();

This seems reasonable at first glance, but then consider if this line followed:

<textarea>exEmps.add(new ContractEmployee());</textarea>

Perfectly legal as far as the compiler is concerned, since ContractEmploye fits within the Employee type that the exEmps variable requires, but now we have a contract employee in a list instance that is supposed to hold only exempt employees. So, an instance of a class parameterized with a derived class is not an instance of that class parameterized with the base class, even though individual instances of the derived class can be used in the base-parameterized generic class; e.g., our List<Employee> can add individual exempt employees.

For the first wildcard case above, public boolean containsAll(Collection<?> c), it does no harm for us to see if our collection contains all the elements of some other collection that may contain an entirely unrelated type (but few, if any, of the items would compare as equal). Note that the contains method accepts an Object parameter, not an E, for this same reason.

The extends term in public boolean addAll(Collection<? extends E> c)means that the unknown class is, extends, or implements the listed type. For instance, we could add all the elements of an ArrayList<ExemptEmployee> to an ArrayList<Employee>. That makes sense, since we could add individual exempt employees to a basic employee collection. But, since we don't actually know what the parameterized type of the incoming collection is (it is the ? class), we cannot call any methods on that object that depend on its parameterized type. So we can't add to that collection; we can only read from it.

The super term is seen less often; it means that the parameterized type of the incoming collection must be of the same type or a more basic type. The TreeSet constructor can accept a Comparator for its actual type, or any type more basic (e.g., a Comparator<Object> can be used for a TreeSet of anything, since its compare method will accept any type of data). It is, however, likely that many "acceptable" comparators will end up throwing a ClassCastException at runtime if they can't actually compare the types involved. So, for example, if we had a Comparator<Employee> class that compared employee ids, we might still wish to use it in a TreeSet<ExemptEmployee>, where it would be perfectly valid (in fact, it would be an annoyance to have to write a special comparator for every employee type, if all the comparators did was compare the ids).

Payroll Using Generics

---

Duration: 15 to 25 minutes.
We can modify our payroll application to use generic lists instead of arrays for our employees, invoices, and payables.

1. Make the Employee[] variable a List<Employee>, and populate it with a new ArrayList<Employee>.</Employee>
2. Since lists have no fixed size, you will need to change the first for loop, perhaps to a fixed number of iterations.</Employee>
3. Modify the lines that add employees from using array indices to using the add method.</Employee>
4. Turn the Invoice[] into a List<Invoice> populated with a Vector<Invoice>, similar to what we did in we did in step 1.</Invoice>
5. Modify the lines that populate that list.</Invoice>
6. Create an ArrayList<Payable> in a List<Payable> payables variable.</Payable>
7. Create an ArrayList<Payable> in a List<Payable> payments variable.</Payable>
8. Then call that list's addAll method once and pass in the employee list.</Payable>
9. Then add all the invoices the same way.</Payable>
10. Since we might not want to modify CheckPrinter, you can generate a Payable array for it with:</Payable>

CheckPrinter.printChecks( payments.toArray(new Payable[] { }) );

The parameter is a "dummy" array used to tell the generic method what type of array to create. Note in the Collection documentation that this method is typed with T rather than the E used in the rest of the class. This method has its own local type, which is determined by the type of the array passed in.

Solution:

Solutions/Payroll-Collections01/Payroll.java

import employees.*; import vendors.*; import util.*; import finance.*; import java.util.*; public class Payroll { public static void main(String[] args) { List<Employee> e = new ArrayList<Employee>(); Employee empl = null; String fName = null; String lName = null; int dept = 0; double payRate = 0.0; double hours = 0.0; for (int i = 0; i < 5; i++) { try { char type = KeyboardReader.getPromptedChar("Enter type: E, N, or C: "); if (type != 'e' && type != 'E' && type != 'n' && type != 'N' && type != 'c' && type != 'C') { System.out.println("Please enter a valid type"); i--; continue; } fName = KeyboardReader.getPromptedString("Enter first name: "); lName = KeyboardReader.getPromptedString("Enter last name: "); dept = KeyboardReader.getPromptedInt( "Enter department: ", "Department must be numeric", new DeptValidator(), "Valid departments are 1 - 5"); do { payRate = KeyboardReader.getPromptedDouble("Enter pay rate: ", "Pay rate must be numeric"); if (payRate < 0.0) System.out.println("Pay rate must be >= 0"); } while (payRate < 0.0); switch (type) { case 'e': case 'E': empl = new ExemptEmployee(fName, lName, dept, payRate); e.add(empl); break; case 'n': case 'N': do { hours = KeyboardReader.getPromptedDouble("Enter hours: "); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); empl = new NonexemptEmployee(fName,lName,dept,payRate,hours); e.add(empl); break; case 'c': case 'C': do { hours = KeyboardReader.getPromptedDouble("Enter hours: "); if (hours < 0.0) System.out.println("Hours must be >= 0"); } while (hours < 0.0); empl = new ContractEmployee(fName,lName,dept,payRate,hours); e.add(empl); } System.out.println(empl.getPayInfo()); } catch (InvalidValueException ex) { System.out.println(ex.getMessage()); i--; //failed, so back up counter to repeat this employee } } System.out.println(); System.out.println("Exempt Employees"); System.out.println("====== ========="); for (Employee emp : e) { if (emp instanceof ExemptEmployee) { System.out.println(emp.getPayInfo()); } } System.out.println(); System.out.println("Nonexempt Employees"); System.out.println("======== ========="); for (Employee emp : e) { if (emp instanceof NonexemptEmployee) { System.out.println(emp.getPayInfo()); } } System.out.println(); System.out.println("Contract Employees"); System.out.println("======== ========="); for (Employee emp : e) { if (emp instanceof ContractEmployee) { System.out.println(emp.getPayInfo()); } } List<Invoice> inv = new Vector<Invoice>(); inv.add(new Invoice("ABC Co.", 456.78)); inv.add(new Invoice("XYZ Co.", 1234.56)); inv.add(new Invoice("Hello, Inc.", 999.99)); inv.add(new Invoice("World, Ltd.", 0.43)); List<Payable> payments = new ArrayList<Payable>(); payments.addAll(e); payments.addAll(inv); CheckPrinter.printChecks( payments.toArray(new Payable[] { }) ); } } Notice that we didn't have to change the for-each loops; they work equally well for Iterable objects, like lists, as they do for arrays.

Also, the addAll method accepts any Collection, so it can take an ArrayList or a Vector equally well. And, since it accepts Collection<? extends E>, it can take collections of either Employee or Invoice (both implement the Payable type used for E in the the receiving collection).