ICSE Class X Conditional Statements in java

Outline
The if Statement and
Conditions Other Conditional
Statements Comparing Data
After midterm:
The while
Statement Iterators
Other Repetition
Statements

Flow of
Control
Unless specified otherwise, the order of statement execution
through a method is linear: one statement after another in
sequence
Some programming statements allow us to:
decide whether or not to execute a particular statement
execute a statement over and over, repetitively
These decisions are based on booleanexpressions(or conditions)
that evaluate to true or false
The order of statement execution is called the flow of control

Conditional
Statements
Aconditional statement lets us choose which statement will be
executed next
Therefore they are sometimescalled selection statements
Conditional statements give us the power to make basic
decisions
The Java conditional statements are the:
if statement
if-else statement
switch statement

The if
Statement
if is a Java
reserved word
The if statement has the following syntax:
The condition must be a
boolean expression. It must
evaluate to either true or
false.
if ( condition )
statement;
If the condition is true, the statement is executed.
If it is false, the statement is skipped.

Logic of an if
statement
state ment
condition
evaluated
tru
e
f
a
l
s
e

Boolean
Expressions
Acondition often uses one of Java's equality operatorsor
relational operators, which all return boolean results:
==
!=
<
>
<=
>=
equal to
not equal
to less
than
greater
than
less than or equal to
greater than or equal
to
Note the difference between the equality operator (==) and
the assignment operator (=)

The if
Statement
An example of an if statement:
if (sum > MAX)
delta = sum - MAX;
System.out.println ("The sum is " + sum);
•
• First the condition is evaluated -- the value of sum
is either greater than the value of MAX, or it is not
If the condition is true, the assignment statement
is executed -- if it isn’t, it is skipped.
• Either way, the call to println is executed
next

Age.jav
a
…
public static void main (String[] args)
{
final int MINOR = 21;
Scanner scan = new Scanner (System.in);
System.out.print ("Enter your age: ");
int age = scan.nextInt();
System.out.println ("You entered: " + age);
if (age < MINOR)
System.out.println ("Youth is a
wonderful thing. "
+ "Enjoy.");
System.out.println ("Age is a state of
mind.");
}
}

Age.java
Output
----jGRASP exec: java Age
Enter your age: 12
You entered: 12
Youth is a wonderful thing. Enjoy.
Age is a state of mind.
----jGRASP: operation complete.
----jGRASP exec: java Age
Enter your age: 100
You entered: 100
Age is a state of mind.
----jGRASP: operation

Indentation
The statement controlled by the if statement is indented to
indicate that relationship
The use of a consistent indentation style makes a program
easier to read and understand
Although it makes no difference to the compiler, proper
indentation is crucial
"Always code as if the person who ends up
maintaining your code will be a violent
psychopath who knows where you live."
-- Martin Golding

The if
Statement
What do the following statements do?
if (top >= MAXIMUM)
top = 0;
Sets top to zero if the current value of top is greater
than or equal to the value of MAXIMUM
if (total != stock + warehouse)
inventoryError = true;
Sets a flag to true if the value of total is not equal to
the sum of stock and warehouse
• The precedence of the arithmetic operators is
higher than the precedence of the equality and
relational operators

Logical
Operators
Boolean expressions can also use the following logical operators:
!
&&
||
Logical NOT
Logical
AND
Logical OR
They all take boolean operands and produce boolean results
Logical NOT is a unary operator (it operates on one operand)
Logical AND and logical OR are binary operators (each operates
on two operands)

Logical
NOT
The logical NOToperation is also called logical negation or
logical complement
If some boolean condition a is true, then !a is false;
if a is false, then !a is true
Logical expressions can be shown using a truth table
a
true
false
!a
false
true

Logical AND and Logical
OR
The logical AND expression
a && b
is true if both a and b are true, and false
otherwise
The logical OR expression
a || b
is true if a or b or both are true, and false
otherwise

Logical
Operators
Expressions that use logical operators can form complex
conditions
if (total < MAX+5 && !found)
System.out.println ("Processing…");
• All logical operators have lower precedence than
the relational operators
• Logical NOT has higher precedence than logical
AND and logical OR

Logical
Operators
Atruth table shows all possible true-false combinations of the
terms
Since && and || each have two operands, there are
four possible combinations of conditions a and b
a b a && b a || b
true true true true
true false false true
false true false true
false false false false

Boolean
Expressions
Specific expressions can be evaluated using truth tables
total < MAX found !found total < MAX && !found
false
false
true
true
false
true
false
true
true
false
true
false
false
false
true
false

English conditions in
Java
true if ch is the first letter in the alphabet
Test if a variable’s value is within a specified range
true if x is between min and max inclusive (including
min and max)
true if x is between min and max exclusive (excluding the
endpoints
Test if variable’s value is outside the range
true if x is less than min or greater than max

Testin
g
Execute all paths through the program
Recall the flow-chart
Good idea to test all combinations of an && and a ||
When numeric ranges, test the values around change in
behavior
Not necessary to test all possible values
Most cases it is impossible to test exhaustively

Outline
The if Statement and
Conditions Other Conditional
Statements Comparing Data

The if-else
Statement
An elseclausecan be added to an if statement to make an
if- else statement
if ( condition )
statement1;
else
statemen
t2;
•
• If the condition is true, statement1 is
executed; if the condition is false, statement2 is
executed
One or the other will be executed, but not both

from Wages.java
final double RATE = 8.25; // regular pay rate
final int STANDARD = 40; // standard hours in a work
// week
double pay = 0.0;
System.out.print ("Enter the number of hours worked: ");
int hours = scan.nextInt();
System.out.println ();
// Pay overtime at "time and a half"
if (hours > STANDARD)
pay = STANDARD * RATE + (hours-STANDARD) *
(RATE * 1.5);
else
pay = hours * RATE;

Logic of an if-else
statement
condition
evaluated
statement1
true false
statement 2

if Statement with Two
Alternatives
 Statements that print “February has 29 days” if it is a leap year and otherwise
prints “February has 28 days”
 Hint: Requires the else statement
int leapYear = scan.nextInt()

The Coin
Class
Let's examine a class that represents a coin that can be flipped
Instance data is used to indicate which face (heads or tails) is
currently showing
//
************************************************************
*
// Coin.java Author: Lewis/Loftus
//
// Represents a coin with two sides that can be flipped.
//
************************************************************
*
public class Coin
{
private static final int HEADS = 0;
private static final int TAILS = 1;
private int face;

Coin.java
//----------------------------------------------------------
// Sets up the coin by flipping it initially.
//----------------------------------------------------------
public Coin ()
{
flip();
}
//----------------------------------------------------------
// Flips the coin by randomly choosing a face value.
//----------------------------------------------------------
public void flip ()
{
face = (int) (Math.random() * 2);
}
//----------------------------------------------------------
// Returns true if the current face of the coin is heads.
//----------------------------------------------------------
public boolean isHeads ()
{
return (face == HEADS);
}

Coin.java
//---------------------------------------------------------
-
// Returns the current face of the coin as a string.
//---------------------------------------------------------
-
public String toString()
{
String faceName;
if (face == HEADS)
faceName = "Heads";
else
faceName = "Tails";
return faceName;
}
}

CoinFlip.java
//*************************************************************
// CoinFlip.java Author: Lewis/Loftus
//
// Demonstrates the use of an if-else statement.
//*************************************************************
public class CoinFlip
{
//----------------------------------------------------------
// Creates a Coin object, flips it, and prints the
results.
//----------------------------------------------------------
{
Coin myCoin = new Coin();
myCoin.flip();
System.out.println (myCoin);
if (myCoin.isHeads())
System.out.println ("You win.");
else
System.out.println ("Better
luck next time.");
}
}

else if
drift
String grdStr;
if (grade >= 90)
grdStr = “A”;
else
if (grade
>= 80)
grdStr = “B”;
else
if (grade >= 70)
grdStr = “C”;
else
if (grade >= 60)
grdStr = “D”;
else
grdStr = “F”;
String grdStr;
if (grade >= 90)
grdStr = “A”;
else if (grade >= 80)
grdStr = “B”;
grdStr = “C”;
grdStr = “D”;
else
grdStr =
“F”;

Indentation
Revisited
Remember that indentation is for the human reader, and is
ignored by the computer
if (total > MAX)
System.out.println ("Error!!");
errorCount++;
Despite what is implied by the indentation, the
increment will occur whether the condition is
true or not

Block
Statements
Several statements can be grouped together into a block
statement delimited by braces
Ablock statement can be used wherever a statement is called
for in the Java syntax rules
if (total > MAX)
{
errorCount++;
}

Block
Statements
In an if-else statement, the if portion, or the
else
portion, or both, could be block statements
if (total > MAX)
{
errorCount++;
}
else
{
System.out.println ("Total: " + total);
current = total*2;
}

Guessing.java
…
final int MAX = 10;
int answer, guess;
Random generator = new Random();
answer = generator.nextInt(MAX) + 1;
System.out.print ("I'm thinking of a number between 1 " +
"and " + MAX + ". Guess what it is: ");
guess = scan.nextInt();
if (guess == answer)
System.out.println ("You got it! Good guessing!");
else
{
System.out.println ("That is not correct,
sorry."); System.out.println ("The number was " +
answer);
}
}
}

Nested if
Statements
The statement executed as a result of an if statement or
else clause could be another if statement
These are called nested if statements
An else clause is matched to the last unmatched if
(no matter what the indentation implies)
Braces can be used to specify the if statement to which
an
else clause belongs

MinOfThree.java
…
int num1, num2, num3, min = 0;
System.out.println ("Enter three integers: ");
num1 = scan.nextInt();
num2 = scan.nextInt();
num3 =
scan.nextInt();
if (num1 < num2)
if (num1 < num3)
min = num1;
else
min = num3;
else
if (num2 < num3)
min = num2;
else
min = num3;
System.out.println
("Minimum value: "
+ min);
}
}

Importance of Curly
Braces
Print “Wehave a problem” if examGrade < 60
Print “Wehave a real problem” if examGrade < 60 and
quizGrade < 10
Print “Ok” if examGrade >= 60
int examGrade, quizGrade;
if (examGrade < 60)
System.out.println(“We have a problem”);
if (quizGrade < 10)
System.out.println(“We have a real problem”);
else
System.out.println(“Ok”);

Exam Grade
Flowchart
int examGrade, quizGrade;
if (examGrade < 60)
System.out.println(“We have a problem”);
if (quizGrade < 10)
System.out.println(“We have a real problem”);
else
System.out.println(“Ok”);

Writing
Cases
 Print “Wehave a problem” if examGrade < 60
 Print “Wehave a real problem” if examGrade < 60 and quizGrade <
10
 Print “Ok” if examGrade >= 60
examGrade < 60 quizGrade < 10 Action
Case 1 “We have a problem”
Case 2 “We have a problem” and
“We have a real
problem”
Case 3 “Ok”

Putting it all
together
int examGrade = scan.nextInt();
int quizGrade = scan.nextInt();
if (examGrade < 60)

The switch
Statement
The switch statement provides another way to decide which
statement to execute next
The switch statement evaluates an expression, then
attempts to match the result to one of several possible
cases
Each case contains a value and a list of statements
The flow of control transfers to statement associated with
the first case value that matches

The switch Statement
The general syntax of a switch statement is:
switch ( expression )
{
case value1 :
statement-list1
case value2 :
statement-list2
case value3 :
statement-list3
case ...
}
switch
and
case
are
reserved
words
If expression
matches value2,
control jumps
to here

The switch
Statement
Often a break statement is used as the last statement
in each case's statement list
A break statement causes control to transfer to the
end of the switch statement
If a break statement is not used, the flow of control
will continue into the next case
Sometimes this may be appropriate, but often we
want to execute only the statements associated
with one case

The switch
Statement
An example of a switch statement:
switch (option)
{
case 'A':
aCount++; break;
case 'B':
bCount++; break;
case 'C':
cCount++; break;
}

The switch
Statement
Aswitch statement can have an optional default case
The default case has no associated value and simplyuses the
reserved word default
If the default caseis present, control will transfer to it if no
other case value matches
If there is no default case, and no other value matches,
control falls through to the statement after the switch

The switch
Statement
The expression of a switch statement must result in an
integral type,meaning an int or a char
It cannot be a boolean value, a floating point
value (float or double), or another integer
type
The implicit boolean condition in a switch statement is
equality
You cannot perform relational checks with a switch
statement

GradeReport.java
public class GradeReport
{
//----------------------------------------------------------
// Reads a grade from the user and prints comments
// accordingly.
//----------------------------------------------------------
{
int grade, category;
System.out.print ("Enter a numeric grade (0 to 100): ");
grade = scan.nextInt();
category = grade / 10;
System.out.print ("That grade is ");

GradeReport.java
switch (category)
{
case 10:
System.out.println ("a perfect score. Well done.");
break;
case 9:
System.out.println ("well above average. Great.");
break;
case 8:
System.out.println ("above average. Nice job.");
break;
case 7:
System.out.println ("average.");
break;
case 6:
System.out.println ("below average.");
System.out.println ("See the instructor.");
break;
default:
System.out.println ("not passing.");
}
}
}

Comparing
Data
When comparing data using boolean expressions, it's
important to understand the nuances of certain data
types
Let's examine some key situations:
Comparing floating point values for equality
Comparing characters
Comparing strings (alphabetical order)
Comparing object vs. comparing object references

Comparing Float
Values
You should rarely use the equality operator (==) when
comparing two floating point values (float or
double)
Two floating point values are equal only if their underlying
binary representations match exactly
Computations often result in slight differences that may be
irrelevant
In many situations, you might consider two floating point
numbers to be "close enough" even if they aren't exactly
equal

Comparing Float
Values
To determine the equality of two floats, you may want to use
the following technique:
if (Math.abs(f1 - f2) < TOLERANCE)
System.out.println ("Essentially equal");
• If the difference between the two floating point
values is less than the tolerance, they are
considered to be equal
• The tolerance could be set to any appropriate
level, such as 0.000001

Comparing
Characters
As we've discussed, Java character data is based on the
Unicode character set
Unicode establishes a particular numeric value for each
character, and therefore an ordering
We can use relational operators on character data based on
this ordering
For example, the character '+' is less than the character
'J'
because it comes before it in the Unicode character set
Appendix C provides an overview of Unicode

Comparing
Characters
In Unicode, the digit characters (0-9) are contiguous and in
order
Likewise, the uppercase letters (A-Z) and lowercase letters
(a-
z) are contiguous and in order
Characters
0 – 9
A – Z
a – z
Unicode Values
48 through 57
65 through 90
97 through 122

Comparing
Strings
Remember that in Javaa character string is an object
The equals method can be called with strings to
determine if two strings contain exactly the same characters
in the same order
The equals method returns a boolean result
if (name1.equals(name2))
System.out.println ("Same name");

Comparing
Strings
We cannot use the relational operators to compare strings
The String class contains a method called compareTo
to determine if one string comes before another
Acall to name1.compareTo(name2)
returns zero if name1 and name2 are equal (contain
the same characters)
returns a negative value if name1 is less than name2
returns a positive value if name1 is greater than name2

Comparing
Strings
if (name1.compareTo(name2) < 0)
System.out.println (name1 + "comes first");
else
if (name1.compareTo(name2) == 0)
System.out.println ("Same name");
else
System.out.println (name2 + "comes
first");
• Because comparing characters and strings is
based on a character set, it is called a
lexicographic ordering

Lexicographic
Ordering
Lexicographic ordering is not strictly alphabeticalwhen
uppercase and lowercase characters are mixed
For example, the string "Great" comes before the string
"fantastic" because all of the uppercase letters
come before all of the lowercase letters in Unicode
Also, short strings come before longer strings with the same
prefix (lexicographically)
Therefore "book" comes before "bookcase"

Comparing
Objects
The == operator can be applied to objects – it returns true if the
two references are aliases of each other
The equals method is defined for all objects, but unless we
redefine it when we write a class, it has the same semantics as
the
== operator
It has been redefined in the String class to compare
the characters in the two strings
When you write a class, you can redefine the equals
method to return true under whatever conditions are
appropriate

== vs.
equals
 What is printed?
public static void main(String [] args)
{
GregorianCalendar today1 = new GregorianCalendar();
GregorianCalendar today2 = new
GregorianCalendar(); GregorianCalendar todayCopy =
today1;
System.out.println("today1 == today2: " +
(today1 == today2));
System.out.println("today1 == todayCopy: " +
(today1 == todayCopy));
System.out.println("todayCopy == today2: " +
(todayCopy == today2));
System.out.println("today1.equals(today2): " +
today1.equals(today2));
System.out.println("today1.equals(todayCopy): " +
today1.equa
ls(todayCopy));
System.out.println("todayCopy.
equals(today2): " +
todayCopy.e
quals(today2));
}

Exercis
e
Complete the Card Class
Add methods equals, compareTo, and toString
Add methods isFaceCard and isRed
Found in
http://www.cs.loyola.edu/~lawrie/CS630/F05/examples/Ex6/

ICSE Class X Conditional Statements in java

More Related Content

Similar to ICSE Class X Conditional Statements in java (20)

Recently uploaded (20)

ICSE Class X Conditional Statements in java