Flow Control 8: Branching Statements - return

public class ReturnDemo {
        /* The return statement is the simplest of the
         * branching statements. It is used to  exit
         * the current method and return a value.
         */
        public static String month1 (int value) {
                String a = "Welcome to January!";
                return a;
        }
        public static String month2 (int value) {
                String a = "Welcome to February!";
                return a;
        }
        public static String month3 (int value) {
                String a = "Welcome to March!";
                return a;
        }
        public static String month4 (int value) {
                String a = "Welcome to April!";
                return a;
        }

        public static void main(String[] args) {
                String text = "If I wasn't so lazey the year would be complete.";

                for (int month = 1; month <= 12; month++) {
                        switch (month) {
                                case 1:
                                        System.out.println(month1(month));
                                        break;
                                case 2:
                                        System.out.println(month2(month));
                                        break;
                                case 3:
                                        System.out.println(month3(month));
                                        break;
                                case 4:
                                        System.out.println(month4(month));
                                        break;
                                default:
                                        System.out.println(text);
                                        break;
                        }
                }
        }
}

Flow Control 7: Branching Statements - continue

public class ContinueDemo {
        /* The continue statement works in a similar way
         * to the break statement. It works with for,
         * while and do-while loops and comes in labelled
         * and unlabelled forms.
         *
         * When invoked, continue skips the current iteration
         * of the loop.
         */
        public static void main(String[] args) {
                // Unlabelled example of continue.
                String searchMe = "peter piper picked a peck of pickled peppers.";
                int max = searchMe.length();
                int numPs = 0;

                for (int i = 0; i < max; i++) {
                        if (searchMe.charAt(i) != 'p')
                                continue;

                        numPs++;
                }
                System.out.println("Found " + numPs + " Ps.\n");

                // Labelled example of continue.
                searchMe = "Look for a sub string in me.";
                String substring = "sub";
                boolean foundIt = false;
                max = searchMe.length() - substring.length();

                test:
                        for (int i = 0; i <= max; i++) {
                                int n = substring.length();
                                int j = i;
                                int k = 0;

                                while (n-- != 0) {
                                        if (searchMe.charAt(j++) != searchMe.charAt(k++)) {
                                                continue test;
                                        }
                                }

                                foundIt = true;
                                        break test;
                        }
                        System.out.println(foundIt ? "Fount it" : "Didn't find it");
        }
}

Flow Control 6: Branching Statements - Labelled break

public class LabelledBreakDemo {
        /* In this example the labelled break statement
         * terminates the outermost loop.
         */
        public static void main(String[] args) {
                int[][] numbers = {
                                {1,2,3,4,5},
                                {10,20,30,40,50},
                                {100,200,300,400,500}
                };
                boolean foundIt = false;
                int searchFor = 30;
                int i = 0;
                int j = 0;

                search: // This is the label for the outer loop.
                        for (i = 0; i < numbers.length; i++) {
                                for (j = 0; j < numbers[i].length; j++) {
                                        if (numbers[i][j] == searchFor) {
                                                foundIt = true;
                                                break search;
                                        }
                                }
                        }

                if (foundIt) {
                        System.out.println(searchFor + " found at position " + i + ":" + j);
                } else {
                        System.out.println(searchFor + " could not be found.");
                }
        }
}

Flow Control 5: Branching Statements - break

public class BreakDemo {
        /* break statements are used to terminate
         * switch blocks, for, while and do-while loops.
         */
        public static void main(String[] args) {
                // Variable declarations;
                int i = 2;
                int searchFor = 3;
                int[] numbers = {0,1,2,3,4,5};
                boolean foundIt = false;

                // Simple switch block with break statements.
                switch (i) {
                        case 0:
                                System.out.println("A = " + (i++));
                                break;
                        case 1:
                                System.out.println("A = " + (i++));
                                break;
                        case 2:
                                System.out.println("A = " + (i++));
                                break;
                        default:
                                System.out.println("Resetting A.");
                                i = 0;
                                break;
                }

                // Simple for loop with a break statement.
                for (i = 0; i < numbers.length; i++) {
                        if (numbers[i] == searchFor) {
                                foundIt = true;
                                break;
                        }
                }
                if (foundIt) {
                        System.out.println(searchFor + " is at index " + i);
                } else {
                        System.out.println(searchFor + " could not be found.");
                }

                // Simple while loop with a break statement.
                while(foundIt) {
                        System.out.println("i = " + (i++));
                        if (i == 100) {
                                System.out.println("i = " + i);
                                i = 0;
                                break;
                        }
                }

                // Simple do-while loop with a break statement.
                do {
                        if (i == 100) {
                                System.out.println("i = " + i);
                                break;
                        }
                        System.out.println("i = " + (i++));
                } while (foundIt);

                /* Since there is no code included in either
                 * of the while or do-while loops to make foundIt
                 * false. Both loops should effectively be infinite.
                 * However using if-then with break gives us another
                 * opportunity to test for a condition that should
                 * terminate the loop.
                 */
        }
}

Flow Control 4: for

public class ForLoopDemo {
        /* In addition to the while and do-while loops.
         * The Java language also provides the for loop.
         * This is used to iterate through a range of values.
         */
        public static void main(String[] args) {
                // Count to 5 with a basic for loop.
                for (int A = 0; A <= 5; A++){
                        System.out.println("A = " + A);
                }

                /* So the code above executes for as long as the
                 * value of A is less than or equal to 5.
                 *
                 * The next example will work it's way through
                 * an array. This is called an enhanced for loop.
                 */
                int[] B = {6,7,8,9,10};
               
                for (int item : B) {
                        System.out.println("B = " + item);
                }

                // We can also do the same for strings.
                String[] months = {"January","February","March","April","May","June",
                        "July","August","September","October","November","December"};

                for (String item : months) {
                        System.out.println("The month is " + item);
                }
        }
}

Flow Control 3: while, do-while

public class WhileLoopDemo {
        /* The Java Language provides the while and do-while
         * loops to allow code to execute repeatedly until a
         * condition is no longer true.
         *
         * The primary difference between while and do-while
         * is the point at which the expression is evaluated.
         *
         * For while loops the expression is evaluated at the
         * top of the loop. The beginning of the code block.
         * So if the expression evaluates to false. The
         * following statements will not run.
         *
         * do-while loops evaluate their expression at the bottom
         * of the loop. The end of the code block. So do-while
         * loops ALWAYS execute their statements at least once.
         */
        public static void main(String[] args) {
                int A = 0;
                int B = 5;

                /* The code in this while loop will only run
                 * because A is less than B.
                 */
                while(A < B) {
                        System.out.println("A = " + (A++));
                }

                // Now that A is = to B the code won't run any more.
                while(A < B) {
                        System.out.println("A = " + (A++));
                }

                /* But if we use a do-while loop. The code should run at
                 * least once.
                 */
                do {
                        System.out.println("\nThis is a do-while loop.");
                        System.out.println("A = " + (A++));
                } while (A < B);
        }
}

Flow Control 2: Switch Blocks

public class SwitchBlockDemo {
        public static void main(String[] args) {
                int A = 0;

                // if-then-else purely for comparison to switch
                if(A == 0){
                        System.out.println("A = " + A + "\n");
                        ++A;
                } else if(A == 1) {
                        System.out.println("A = " + A + "\n");
                        ++A;
                } else if(A == 2) {
                        System.out.println("A = " + A + "\n");
                        ++A;
                } else if(A == 3) {
                        System.out.println("A = " + A + "\n");
                        ++A;
                } else if(A == 4) {
                        System.out.println("A = " + A + "\n");
                        ++A;
                } else if(A == 5) {
                        System.out.println("A = " + A + "\n");
                        ++A;
                } else {
                        System.out.println("A = " + A);
                        System.out.println("A is not 0. A will be reset.");
                        System.out.println("If only we had some way to loop this code.");
                        A = 0;
                }

                /* Unlike the if-then-else code above, the switch
                 * block below will execute all the code that comes
                 * after the matching case statement.
                 */
                switch (A) {
                        case 0: System.out.println("A = " + (A++));
                        case 1: System.out.println("A = " + (A++));
                        case 2: System.out.println("A = " + (A++));
                        case 3: System.out.println("A = " + (A++));
                        case 4: System.out.println("A = " + (A++));
                        case 5: System.out.println("A = " + A);
                        default:
                        System.out.println("A is not 0. A will be reset.\n");
                                A = 0;
                                break;
                }

                // This is a condensed version of the above switch block.
                switch (A) {
                        case 1: case 2: case 3: case 4: case 5:
                                System.out.println("\nA = " + (A++));
                        default:
                                System.out.println("A is not equal to 0. A will be reset");
                                System.out.println("If only I could loop this code.");
                                A = 0;
                                break;
                }

                /* Adding break statements "breaks" the program out of the switch
                 * block. The default code executes when none of the case statements
                 * are satisfied. A break statement is not needed here. But it can
                 * help make the code more robust and readable.
                 */
                switch (A) {
                        case 0:
                                System.out.println("A = " + (A++));
                                break;
                        case 1:
                                System.out.println("A = " + (A++));
                                break;
                        case 2:
                                System.out.println("A = " + (A++));
                                break;
                        case 3:
                                System.out.println("A = " + (A++));
                                break;
                        case 4:
                                System.out.println("A = " + (A++));
                                break;
                        case 5:
                                System.out.println("A = " + A);
                                break;
                        default:
                                System.out.println("A is not 0. A will be reset.");
                                A = 0;
                                break;
                }
        }
}

Note:

When coding the switch blocks in the examples above. Eclipse decided they should not be indented. Forcing Eclipse to indent these switch blocks properly wasn't too hard. It just meant correcting the error a few times.

Indentation is clearly not mandatory in Java. However Oracle's own examples are indented. So I presume this is how switch blocks are supposed to be written.