COP-3330: Object Oriented Programming

Flow ControlMay 16, 2012

Eng. Hector M Lugo-Cordero, MS

What are flow control instructions?

• A program’s normal execution is sequential, i.e. instructions are executed line by line

• Flow control instructions simply allow to change this• Main difference between C/C++’s and Java’s flow

control– C/C++ utilizes numbers to represent TRUE/FALSE, anything

different than 0 is a TRUE, and the value 0 is FALSE– Java has a boolean data type which may assume the values

true or false. Assigning a number to a boolean variable is an error

Conditions

• Equal: == a == b• Not Equal: != a != b• Greater: > a > b• Less: < a < b• Greater or Equal: >= a >= b• Less or Equal: <= a <= b • Not: ! !(a == 0)

!(b > 2)

Conditional Assignment

• Allows assigning a value if a condition is met, another otherwise

• Syntax:– <variable> = <condition> ? <value_if_true> : <value_if_false>;

• E.g. consider a clock that is stored in 24 hrs format, but has the option of working with AM/PM format

int displayHour = hour > 12 ? hour – 12 : hour;

Multiple Conditions

• Multiple conditions must be met (AND)x == y && x > 0• At least one condition must be met (OR)x == y || x > y• Complex conditions may be not as well!(x == y || x > y)

Conditionals

• if(condition){…code…}• if(condition1){…} else if(condition2){} else{}– The else if are optional and may include as many

as you need– else is optional unlike C/C++ where is required

after using the else if• Omiting the {} will only execute the next

instruction after the if

Switches

• Switches are an alternative for having multiple conditions (equality)

• The condition of a switch is a number or enum• Java 1.7 aka Java 7 allows usage of String

variables within a switch as well• Switches do not accept boolean expressions• Each case in a switch is terminated by a break, if

no break is added then subsequent cases may be executed as well

Switch Example• Exampleif(x == 0) ….else if(x == 1) ……else• May be written as:switch(x){

case 0:break;

case 1:break;

….default:

}• Important: DO NOT FORGET THE BREAK

Enums

• Specify a collection of values where only one may be assigned

• Example the boolean data type may be an enum as well• public enum myBoolean {

FALSE,TRUE;

};• Enums work like this in C/C++, but Java further extends

to having methods for the enums as well– So an enum is also an Object

Loops

• Follow the same convention as in C/C++– for(init_control; condition ;increment){}– while(condition){}– do{}while(condition);

• There is also a foreach which may be used to read sequentially a collection (this will make more sense later)– for(String name : allNames){…}– Equivalent to having a

• for(int i = 0; i < allNames.length; ++i){String name = allNames[i];…

}

Comparing Strings

• An error would be to compare strings with == or !=

• Test for equality .equals– if(lastName.equals(otherLastName))

• Test for equality ignoring case .equalsIgnoreCase– if(user.equalsIgnoreCase(storedUser))

• Both methods (functions) return a boolean

Comparing Objects• As with Strings (which are object in Java as well) == and != have

different sense – == tests to see if the location where two variables are stored are the

same– != tests to see if the location where two variables are stored are not

the same• So how do we test for their values?

– The method compareTo and compare– compareTo is applied to an object– compare is static, hence it receives two parameters

• We shall cover more on this

• Compares return a > 0 number if the first operand is greater, a < 0 number if it is less, and 0 if they are equal

Conditions for Comparing Objects

• A class should implement Comparable, what implements means will be discussed later in course

• Otherwise it may implement Comparator to compare two objects of another class, will cover this as well later

So what is an object then?

• From Java’s point of view is another data type• To avoid too many abstractions, an object is an area in

memory just like a data type, but it holds a collection of values

• Is this a struct as in C?struct Complex{

double real;double imag;

};• In a sense yes, but no since Java objects are classes and as we

shall see, there are more things that can be done with classes

compareTo Examplepublic class Complex implements Comparable {

… //all necessary code comes before or later this methodpublic int compareTo(Complex other){

double thisMagnitude = this.Magnitude();double otherMagnitude = other.Magnitude();double thisAngle = this.Angle();double otherAngle = other.Angle();//test for greaterif(thisMagnitude > otherMagnitude){return 1;}//test for lessif(thisMagnitude < otherMagnitude){return -1;}//test for equalreturn thisAngle – otherAngle;

}}

compare Example

public class ComplexComparator implements Comparator{

public static int compare(Complex first, Complex second){

//may used the already defined method//or redefine the method herereturn first.compareTo(second);

}}

Dealing with booleans• Consider this variable definition

– boolean isPresent = true;• A common non-required way of testing with such values is• For true

– if(isPresent == true) or if(isPresent != false)– Correct: if(isPresent)

• For false – if(isPresent == false) or if(isPresent != true)– Correct: if(!isPresent)

• In a function that checks if a list is empty one could return:– return list.size() == 0– return list.isEmpty()– No need for return true or return false, such may be used under different

situations

Exceptions

• Exceptions are special cases that normally should not occur on a program (hence its name exception), and must be handled before continuing execution

• Example:– double average = sum / count;– What could be a problem with this line?– How do we fix it? If? while? Something better?

Exception Handling

• Each potential problem code is enclosed with a try keyword

• An error or exceptional case may be catch with the catch keyword

• Exceptions are also in C++ and are enclosed by a try{} catch(Exception e){} blocks

• Java also contains another keyword named finally where the code inside is executed always no matter if there is a exception or not, or even if there is a return inside

Exceptions by Example

try{double average = sum / count;return average;

}catch(Exception e){

System.err.println(e.getMessage());return Double.NaN;

}finally{

System.out.println(“Average Function Exited”);}