Chapter 5: Control Statements

1. Chapter 5: Control Statements Control Flow: A control flow Statement regulates the order in which statements get executed. • Flow-order in which the computer executes the lines of code in our program • Control flow blocks are basically blocks of code that control the way data flows, or else which statements are executed when. This can be useful if you only want certain areas of your code to be executed under a given condition.

2. The default flow of control in a program is TOP to BOTTOM, i.e. all the statements of a program are executed one by one in the sequence from top to Bottom. This execution order can be altered with the help of control instructions. • Java supports three types of control instructions - 1. Sequence Statement 2.Decision Making / Conditional / Selection Statements 3..Looping / Iterative Statements

3. Program Structure // comments about the class public class MyProgram { } // comments about themethod public static void main (String[] args) { } method header methodbody

4. SEQUENCE • The sequence means the statements are being executed sequentially. This represents default flow of statement. Statement 1 Statement 2 Statement 3

5. Condition ? Condition ? Condition ? Condition? Condition ? Condition ? Condition ? Condition ? Condition ? Condition ? Condition ? Condition ? Condition ? Condition ? Condition ? false false false false false false false true true true Body of iF Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Body of else Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 Statement 1 SELECTION The sequence Statements means the execution of statement(s) depending upon a given condition. Statement 1 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2 Statement 2

6. Conditional Statement - if Statement • First Form of if Statement • if ( <conditional expression> ) { • execute statements -for-the-true-case; • } • =>Second form • if ( < conditional expression > ) { • execute statement1 -for-the-true-case • } • else { • execute statement2 -for-the-false-case • } • Result of conditional expression : Logical Type(true or false)

7. There are certain points worth remembering about the if statement as outlined below: • The conditional expression is always enclosed in parenthesis. • The conditional expression may be a simple expression or a compound expression. • Each statement block may have a single or multiple statements to be executed.

8. In case there is a single statement to be executed then it is not mandatory to enclose it in curly braces ({}) but if there are multiple statements then they must be enclosed in curly braces ({}) • The else clause is optional and needs to be included only when some action is to be taken if the test condition evaluates to false.

9. Example • if ( j<5 ) { // This is recommended System.out.println(“j is less than 5”): } Else { System.out.println(“j is no less than 5”): } OR if ( j<5 ) System.out.println(“j is less than 5”): //single statement else System.out.println(“j is no less than 5”):

10. if( testScore < 70 ) JOptionPane.showMessageDialog(null,"You did not pass"); else JOptionPane.showMessageDialog(null,"You did pass "); Boolean Expression Then Block Else Block Syntax for the if Statement if( <boolean expression> ) <then block> else <else block> Can be visualized as a flowchart Indentation is important!

11. if (<cond. expr.>) if (<cond. expr.>) // . . . <statement> • Nested if statement if (<cond. expr.1>) <statement 1> else if (<cond. expr.2>) < statement 2> … else if (<cond. expr. n>) < statement n> else < statement>

13. Conditional Operator(?) if (x > 0) { y = 1 } else { y = -1; } is equivalent to y = (x > 0) ? 1 : -1;

14. Arithmetic Expression switch ( gradeLevel ) { case 1: System.out.print("Go to the Gymnasium"); break; case 2: System.out.print("Go to the Science Auditorium"); break; case 3: System.out.print("Go to Harris Hall Rm A3"); break; case 4: System.out.print("Go to Bolt Hall Rm 101"); break; } Case Label Case Body Syntax for the switch Statement switch( <arithmetic expression> ) { <case label 1> : <case body 1> … <case label n> : <case body n> } This is the general syntax rule for a switch statement. The case body may contain zero or more statements.

15. Example • switch(x) • { • case 1: • System.out.println(“go to 1”); • break; // what happened if break is not here? • case 2: • case 3: • System.out.println(“go to 2 or 3”); • break; • default : • System.out.println(“not 1, 2 or 3”); • }

16. =>The expression of switch must not be long, float, double, or Boolean, it must be either byte, short, char, or int. (assignment compatible with int) • =>The arguments to case labels must be constants, or at least a constant expression that can be fully evaluated at compile time. • =>Can not use a variable or expression involving variables. • =>Default clause can be placed any where in, the block. • => The fall of control to the following cses of matching case is called FALL –THROUGH.

17. Switch • There are times in which you wish to check for a number of conditions, and to execute different code depending on the condition. One way to do this is with if/else logic, such as the example below: • int x = 1; int y = 2; • if (SOME_INT == x) • { //DO SOMETHING } • elseif (SOME_INT == y) • { //DO SOMETHING ELSE } • else • { //DEFAULT CONDITION }

18. This works, however another structure exists which allows us to do the same thing. Switch statements allow the programmer to execute certain blocks of code depending on exclusive conditions. The example below shows how a switch statement can be used: • int x = 1; int y = 2; • switch (SOME_INT) • { • case x: • method1(SOME_INT); • break; • case y: • method2(SOME_INT); • break; • default: • method3(); • break; • }

19. Switch takes a single parameter, which can be either an integer or a char. In this case the switch statement is evaluating SOME_INT, which is presumably an integer. When the switch statement is encountered SOME_INT is evaluated, and when it is equal to x or y, method1 and method2 are executed, respectively. The default case executes if SOME_INT does not equal x or y, in this case method3 is executed. You may have as many case statements as you wish within a switch statement. • Notice in the example above that "break" is listed after each case. This keyword ensures that execution of the switch statement stops immediately, rather than continuing to the next case. Were the break statement were not included "fall-through" would occur and the next case would be evaluated (and possibly executed if it meets the conditions).

20. Differences between the If-else and Switch ST: • Switch can only test for equality whereas if can evaluate a relational or logical expression that is multiple condition. • The switch statement select its branches by testing the value of same variable whereas the if-else construction allow you use a series of expression that may involve unrelated variables and complex expressions. • The if-else is more versatile of the two statements. • The if-else statement can handle floating-point tests also apart from handling integer and character test whereas a switch cannot handle floating-point test. the case labels of switch must be an integer byte,short,int or a char. • The switch case label value must be a constant. so if two or more variables are to be compared ,use if-else. • The switch statement is more efficient choice in terms of code used in a situation that supports the nature of switch operation( testing a value against a se of constant).

21. Repetitions • for Loops • while Loops • do Loops • break and continue

22. Looping / Repetitive Statement Some time some portion of the program (one or more statement) needs to be executed repeatedly for fixed no. of time or till a particular condition is being satisfied. This repetitive operation is done through a looping statement. Definition A loop is repetition of one or more instructions, which continues till certain condition is met.

23. Condition ? false True Statement 1 Statement 2 ITERATION / LOOP Looping structures are the statements that execute instructions repeatedly until a certain condition is fulfilled(true). Statement n

24. In an Entry-Controlled loop/Top-Tested/Pre-Tested loop the test expression is evaluated before entering into a loop. • for Examples: For loop and While loop. • In an Exit-Controlled loop/Bottom-Tested/Post-Tested loopthe test expression is evaluated before exiting from the loop. • for Examples: do-While loop. • Do not put a semicolon after the right parenthesis. If you do, the for loop would think that there no statements to execute. it would continue looping, doing nothing each time until the test expression becomes false.

25. for Loops for (initialization; Test-condition; update-statement) { //loop body; } Example: int i; for (i = 0; i<100; i++) { System.out.println("Welcome to Java! ” + i); }

26. In for loop contains three parts separated by semicolons(;) • Initialization Before entering in a loop, its variables must be initialized. The initialization expression is executed only once in the beginning of the loop. • Test Expression It decides whether the loop-body will be executed or not. if the test expression evaluates to true the loop-body gets executed, otherwise the loop is terminated. Test expression gets checked every time before entering in the body of the loop. • Update Expression(s) The update expressions change the values of loop variables. The update expression is executed every time after executing the loop-body . • The body of the loop The statements that are executed repeatedly (as long as the test-expression is nonzero) from the body of the loop.

27. for Loop Flow Chart

28. for // print 1 2 3 4 5 6 7 8 9 10 public class ClassXI { public static void main(String args[]) { int n; for(n=1; n<=10; n++) { System.out.println(“ ” + n); }// end for loop }// end main } // end class

29. INFINITE LOOP: An infinite loop can be created by omitting the test expression as shown below: • for( int j=25; ; --j) { System.out.println(“ An infinite for Loop”); } 2. for ( ; ; ) // infinite loop { System.out.println(“ An infinite for Loop”); }

30. 3.Empty Loop: If a loop does not contain any statement in its loop-body, it is said to be an empty loop. For(int j=20;j>=0;--j); 4. Declaration of variable inside the loops and if: A variable declared within an if or for/while/do-while statement cannot be accessed after the statement is over, because its scope becomes the body of the statement(if/for/while/ do-while). It cannot be accessed outside the statement body.

32. while Loops while (condition) { // loop-body; } Note: A while loop is pre-test loop. It first tests a specified conditional expression and as long as the conditional expression is evaluated to non zero (true), action taken (i.e. statements or block after the loop is executed).

33. while Loop Flow Chart START

34. while // Demonstrate the while loop. public class While { public static void main(String args[]) { int n = 1; while(n<=1 0) { System.out.println(“ " + n); n++; } //end while } // end main } // end class

35. do Loops do { // Loop body; } while (continue-condition); The Do-while loop is an POST-TEST or bottom test loop.that is, it executes its body at least once without testing specified conditional expression and then makes test. the do-while loop terminates when the text expression is evaluated to be False(0).

36. do Loop Flow Chart

37. do-while // Demonstrate the do-while loop. public class DoWhile { public static void main(String args[]) { int n =1; do { System.out.println(" " + n); n++; } while(n <= 0); } // main } // class

38. Jump • Java supports three jump statements: • break, • continue, and • return. • These statements transfer control to another part of your program.

39. break • In Java, the break statement has three uses. • First, as you have seen, it terminates a statement sequence in a switch statement. • Second, it can be used to exit a loop. • Third, it can be used as a "civilized" form of goto. • java does not support goto statement

40. break statement • Alter flow of control • Causes immediate exit from control structure • Used in while, for, do…while or switch statements • Labeled break • Labeled block • Set of statements enclosed by { } • Preceded by a label • Labeled break statement • Exit from nested control structures • Proceeds to end of specified labeled block

41. break • The general form of the labeled break statement is shown here: break label;

42. The break Keyword

43. break // Using break to exit from for loop. class BreakLoop { public static void main(String args[]) { for(int i=0; i<100; i++) { if(i = = 10) break; // terminate loop if i is 10 System.out.println(“ i: " + i); } System.out.println("Loop complete."); } }

44. break // Using break to exit from while loop. class BreakLoop2 { public static void main(String args[]) { int i = 0; while(i < 100) { if(i == 10) break; // terminate loop if i is 10 System.out.println("i: " + i); i++; } System.out.println("Loop complete."); } }

45. break // Using break to exit from do while loop. class BreakLoop2 { public static void main(String args[]) { int i = 0; do { if(i == 10) break; // terminate loop if i is 10 System.out.println("i: " + i); i++; } while(i < 100); } System.out.println("Loop complete."); }

46. Branch Statement - break Statement • To move control to the out of the block • From of break statement break [label] ; int i = 1; while (true) { if (i = = 3) break; System.out.println("This is a " + i + " iteration"); ++i; }

47. continue • you might want to continue running the loop, but stop processing the remainder of the code in its body for particular iteration. This is, in effect, a goto just past the body of the loop, to the loop's end. • In while and do-while loops, a continue statement causes control to be transferred directly to the conditional expression that controls the loop. • In a for loop, control goes first to the iteration portion of the for statement and then to the conditional expression.

48. continue statement • As with the break statement, continue may specify a label to describe which enclosing loop to continue. • Skips remaining statements in loop body • Proceeds to next iteration • Used in while, for or do…while statements • Labeled continue statement • Skips remaining statements in nested-loop body • Proceeds to beginning of specified labeled block

49. The continue Keyword

50. // Demonstrate continue. class Continue { public static void main(String args[]) { for(int i=0; i<10; i++) { System.out.print(i + " "); if (i%2 == 0) continue; System.out.println(""); } } }