Welcome to the Java Programming Forums


The professional, friendly Java community. 21,500 members and growing!


The Java Programming Forums are a community of Java programmers from all around the World. Our members have a wide range of skills and they all have one thing in common: A passion to learn and code Java. We invite beginner Java programmers right through to Java professionals to post here and share your knowledge. Become a part of the community, help others, expand your knowledge of Java and enjoy talking with like minded people. Registration is quick and best of all free. We look forward to meeting you.


>> REGISTER NOW TO START POSTING


Members have full access to the forums. Advertisements are removed for registered users.

Results 1 to 3 of 3

Thread: IF and SWITCH Statements: How and When to Use Them

  1. #1
    Member snowguy13's Avatar
    Join Date
    Nov 2011
    Location
    In Hyrule enjoying a chat with Demise and Ganondorf
    Posts
    339
    My Mood
    Happy
    Thanks
    31
    Thanked 48 Times in 42 Posts

    Lightbulb IF and SWITCH Statements: How and When to Use Them

    In the short time that Iíve been programming, Iíve found that if-else-if statements and switch statements both are incredibly powerful, but to use they each have situations to which they are most appropriate. If and switch are both control flow statements, as defined by Oracle's tutorials. Next I will go a little more in-depth about if and switch statements.

    The If Statement
    If statements are the simplest and easiest control flow statements to handle. The block of code after and if statement executes if and only if all the conditions contained in the if clause are met. Writing an if statement is very simple:



    if(boolean)
    {

    //code here executes *if* boolean's value is true

    }

    Note:
    This boolean can be a variable or a method that returns a boolean.

    --OR--

    if(boolean expression)
    {

    //code here executes *if* boolean expression is true

    }

    Also note that if expressions CANNOT be followed by semicolons if the conditional code block they represent is to execute correctly.



    There are multiple ways to write code that follows an if-statement. If you only need to execute one line of code under a certain condition, then you do not need to use brackets to surround that code.

       boolean isRaining = true;
       if(isRaining)
          System.out.print("You'll get wet!");
          //Since only one line of code needs executing, I need not use brackets

    However, it is good convention to use brackets, as whenever an if statement's code block contains more than two lines of code, brackets become necessary.

       boolean isRaining = true;
       if(isRaining)
       {
          System.out.println("You'll get wet!");
          System.out.print("Better wear a jacket!");
          //Now that there are two lines of code, brackets are required
       }

    What is a boolean expression?
    A boolean expression is one that compares two values, and returns either true or false.
    Boolean expressions use relational operators, of which there are 6:
    > Greater than
    < Less than
    >= Greater than OR equal to
    <= Less than OR equal to
    == Equal to
    != NOT equal to

    Notice that to test if one number is equal to another, you must use TWO equals signs.

    For example, let's say you are comparing two integers, x and y. You may write a program like this:
       int x = 10, y = 4;
     
       if(x < y)
       {
          System.out.print(x + " is less than " + y);
       }
     
       if(x == y) //Notice TWO equals signs, means "if x IS EQUAL to y"
       {
          System.out.print(x + " is equal to " + y);
       }
     
       if(x > y)
       {
          System.out.print(x + " is greater than " + y);
       }

    The result of this program would be:
    10 is greater than 4

    The Not (!) Operator
    Java also offers a powerful negation operator to save programmers time and headache. The not operator, which is the exclamation point (!), turns true to false, and false to true.

    Using the not operator is simple: place it before the boolean or boolean expression that is to be negated. See the examples below:
       boolean isRaining = true;
       if(!isRaining) //notice the ! operator BEFORE the boolean, isRaining
       {
          System.out.println("No rain today!");
          System.out.print("Put that jacket away!");
       }
    The if statement above can be read, "if it is NOT (!) raining". To think about this a different way, the code block following the if statement will only execute if isRaining is false. This program would not put out anything, as the isRaining is negated from true to false, so the if statement's code does not execute.
       int num = 2;
       if(!(num > 5)) //notice the ! operator BEFORE the boolean expression
       {
          System.out.println("Your number is not greater than 5...");
       }

    For more on conditional, relational, and other operators, click here.

    The Else Statement
    Along with the use of the if statement comes the else statement. An else statement MUST be preceded by an if statement, and can not contain boolean expressions. Else statements contain blocks of code just like if statements. The block of code that follows an else statement only executes if the boolean or boolean expression of the preceding if statement returns false.

    Else statements can also be combined with if statements so that multiple conditions are tested if an initial test returns false. To use if, else-if, and else, generally follow this pattern:



    if(boolean expression)
    {

    //code here executes if boolean expression is true

    }
    else if(boolean expression)
    {

    //code here executes if boolean expression is true
    //AND the previous boolean expression is false

    }
    else if(boolean expression)
    {

    //code here executes if boolean expression is true
    //AND the previous boolean expression is false

    }
    else
    {

    //This code only executes if none of the previous boolean expressions are true

    }



    So, to save the computer some thinking, I could rewrite my previous program as such:
       int x = 10, y = 4;
     
       if(x < y)
       {
          System.out.print(x + " is less than " + y);
       }
       else if(x == y) //This is checked only if x is not less than y
       {
          System.out.print(x + " is equal to " + y);
       }
       else //This occurs only if x is not less than or equal to y
       {
          System.out.print(x + " is greater than " + y);
       }

    By using the above code instead of three separate if statements, the program takes less time to run. This is because the program only checks the else-if statement if the first if statement returns false, and only performs the else statement's code block if the first two if statements are false. Though in this case the time difference is not noticeable, imagine the scope of the difference over a program that spans thousands of lines. That's a pretty big difference.

    Also, this is important to note: else statements always go to the nearest if statement that does not already have an else statement attached to it. If there is no such if statement, the compiler will become angry with you, and may explode.

    Nesting If Statements
    If statements can also contain other if statements, which is called nesting of if statements. Nested if statements are very useful for outlining decision structures. Here is a quick example of nested if statements...
       boolean isSunny = true;
       boolean isTooHot = true;
       if(isSunny)
       {
          if(isTooHot)
          {
              System.out.println("The sun is out, but it's way to hot to be outside...");
          }
          else
          {
              System.out.println("The sun is out, and the temperature is perfect!");
          }
       }
       else
       {
          System.out.println("It's not sunny...");
       }
    In the above program, there is an if statement inside of an if statement. The program only checks the value of isTooHot if isSunny is true.

    Running Multiple Tests
    If statements also allow for multiple tests to be performed in one clause. This can be done by using conditional operators. The most common conditional operators are:
    && AND - both conditions must be true
    || OR - at least one of the conditions must be true
    ^ XOR - ONLY one of the conditions may be true

    These operators are placed between the two statements they are meant to evaluate.
    boolean isSunny = true;
    boolean isRaining = true;
     
    if(isSunny && isRaining) \\both must be true
    {
       System.out.print("Look for a rainbow!");
    }
    If both booleans, isSunny and isRaining are true, then and only then will the print statement execute.

    If you use && and || in the same statement without parenthesis, the && statement will be checked first. See the statement below:

    true || false && true || false

    Java looks at this statement like this:

    true || (false && true) || false

    So it is reduced...

    true || false || false
    (true || false) || false
    true || false
    true

    However, you can place parenthesis around tests, much like in math, to change the order in which they will be evaluated.

    ((true || false) && true) || false
    (true && true) || false
    true || false
    true

    XOR (^) is an interesting operator. When placed between two booleans or boolean expressions, it will only return true if one of the boolean expressions is true and the other is false. This is useful for situations when you want a program to continue only if a condition exists, while at the same time excluding the existence of another condition. XOR is not too commonly used. A more lengthy way to write an XOR is as such:

    where a and b are booleans,
    if(a && !b || b && !a)
    is the same as
    if(a ^ b)

    The Ternary ? Operator
    Sometimes when you code an if statement, all you are really wanting to change is a single value. For example, you may check if an integer is less than zero, and set the value of a String to "negative" if it is:
    String status;
    int num = -2;
    if(num < 0)
    {
       status = "negative";
    }
    else
    {
       status = "non negative";
    }

    However, that code is kinda bulky for just a single variable's value being changed. Have no fear, ?: is here! The ternary conditional operator ? allows you to perform boolean evaluations and change the value of a variable by these evaluations. That sentence probably sounds like Charlie Brown's parents, so here's the syntax:



    Object o = (booleanExpression ? value_if_true : value_if_false);




    So that previous if statement above rewritten would be simply:
    String status;
    int num = -2;
    status = (num < 0 ? "negative" : "non negative");
    //variable = (booleanExpression ? valueTrue : valueFalse);

    I have found this ? operator extremely useful for shortening code that would have otherwise been bulky.

    The instanceof Keyword
    Sometimes you may want to test if an Object is an instance of a certain class. Perhaps you want to class cast an Object to a String, but first you want to make sure that the Object is a String. There is a simple way to do this: the instanceof keyword. The syntax is as follows:



    variable instanceof Class




    instanceof returns either true or false -- true if the given variable is an instance of the given class, and false otherwise.

    Look at the code below:
    String start = "cake";
    String end;
    if(start instanceof String)
    {
       end = start;
    }
    else
    {
       end = "";
    }
     
    System.out.print(end);

    So, if start (a String) is an instance of the String class (which, obviously, it is), then the value of end will be set as the value of start. Otherwise, end we be set to empty (""). Since start is an instance of String, the output of this program will be "cake".

    For more on instance of, see here (toward the middle of the page).

    If Summary
    If statements allow certain blocks of code to execute only under certain conditions. They can test booleans or boolean expressions, and can even relate multiple booleans and boolean expressions at once using && and ||. Boolean expressions test two values against one another using <, >, <=, >=, ==, and !=. ! is used to negate the value of a boolean or boolean expression. If statements can also be nested within one another when && and || are insufficient.

    The ? operator provides a way to shorten if statements that would only change the value of a single variable and do nothing else.

    The Switch Statement
    If statements are very powerful, but sometimes they can become quite repetitive and annoying to write. Think about a program that performs different actions based on an integer. The code would look something like this:
    int num = 3;
    if(num == 0)
    {
       //code
    }
    else if(num == 1)
    {
       //different code
    }
    else if(num == 2)
    {
       //even more code
    }
    //... and on until, let's say, 5

    Obviously, that program would be rather monotonous to write. The switch statement offers an alternative to situations like the above.

    Writing a Switch
    The switch statement takes one argument that controls the path of execution it will follow. Switch is very useful when you would otherwise be using a list of if statements that all check the value of the same variable. The general syntax of the switch statement is thus:



    Note that "variable" used below has many restrictions. Variable can only be an int, short, byte, char, Enum, String, and a few other special classes that wrap the aforementioned such as Character, Byte, Short, and Integer.

    Also note that brackets are required in a switch statement.

    switch(variable)
    {

    case value:
    //code here
    break;

    case value:
    //code here
    break;

    default:
    //code here
    break;

    }



    I know this is really unclear at the moment; so let's go in depth about each section.

    The Control Value
    Referred to as "variable" above, the control value of a switch statement does as the name implies: controls which path of execution the switch statement will follow. As noted above, this control value can be any of the primitive data types int, short, byte, or char and can also be done with Strings or Enums. Some classes that wrap the primitive data types mentioned before may also be used to control the switch's execution. These classes include Character, Byte, Short, and Integer.

    Important: Strings only work in switch statements since Java 7.

    The Cases
    A switch statement's possible paths of execution are outlined by its cases. Unsurprisingly, cases must be of the same data type or class as the control value. So, if your control value is an integer, your cases must be too (ie, case 8, case 45). If your control value is a String, your cases must follow suit (case "happy", case "sad").

    Cases should be followed by the code that is to execute if the control value is equal to the case value. Blocks of code that follow cases should not be enclosed in brackets. However, after a block of code, the line of code "break;" must be used. Otherwise, the program would continue reading and executing the lines of code that follow, even if they are part of a different case.

    The Default Case
    It is good convention to also place a "default" case in the body of a switch statement. This is done just like with cases, but instead, you mark the start of the default case with "default:". Default cases are useful it you want to execute certain code when none of the previous cases values are matched by the control value. In fact, the default case does exactly that. If, after checking every single case, a program finds no matches between case values and the control value, it then looks to execute the default case.

    An Example
    Below is an example of how to use the switch statement.
    String weatherCondition = "Cloudy";
    switch(weatherCondition.toLowerCase())
    {
     
       //This can also be thought of as a group of if statements
     
       case "sunny": //Or, if(weatherCondition.toLowerCase().equals("sunny"))
          System.out.println("The sun is out! Hooray!");
          break; //Remember the break, this tells the program to stop here!
     
       case "cloudy": //Or, if(weatherCondition.toLowerCase().equals("cloudy"))
          System.out.println("Uh-oh, clouds block the sun! :(");
          break;   //Remember the break, this tells the program to stop here!
     
       case "rainy":
          System.out.println("Better get a jacket, it's wet out!");
          break;   //Remember the break, this tells the program to stop here!
     
       default: //If weatherCondition.toLowerCase() doesn't equal any of the above cases, this executes
          System.out.println("Aw, snap, I don't know what to say about the current weather!");
          break;
     
    }
    By using the switch statement, I avoided the monotony of a chunk of if, else-if statements.

    Another Example
    Sometimes you may want to create a switch statement that does not use break statements to halt its execution. In other words, maybe your control variable doesn't control which path of execution will be followed, but rather the starting point of execution in a list of code. For this example, let's say I want to find which days come after a given day in a week. I could use a switch statement for this, as such:
    ArrayList<String> days = new ArrayList<String>();
    String day = "Monday";
    switch(day.toLowerCase())
    {
       case "sunday": days.add("Monday");
       case "monday": days.add("Tuesday");
       case "tuesday": days.add("Wednesday");
       case "wednesday": days.add("Thursday");
       case "thursday": days.add("Friday");
       case "friday": days.add("Saturday");
       break;
     
    }

    What the above does is finds the starting day, then continues executing all the code listed BELOW the case that represents the starting day. So, in the case of this program, the day is "Monday". Therefore, the ArrayList days would have the days "Tuesday", "Wednesday", "Thursday", "Friday", and "Saturday" added to it, because nothing is telling the program to stop executing. This is called letting a switch statement fall through. For a more detailed example of this, see Oracle's tutorials.

    Switch Summary
    Switch statements offer alternatives to series of if statements that involve different tests upon the same simple variable. The control value of a switch can be int, short, byte, char, Enum, String, and an instance of certain number wrapping classes. Switch statement bodies contain cases that outline the possible paths of execution of the switch based on the value of the control variable. Switch statements should contain default cases that execute code if none of the previous case values are met. Providing an easy way to diverge a program's execution path into a plethora of parts, switch statements can be quite beneficial.

    If and Switch: When to use Which
    Now that if and switch statements have both been explained, it's time to analyze: which is more appropriate in certain situations?

    If and switch seem related to each other in the same manner as while and for. Switch statements work well when critiquing the value of a single variable, and save time and space in these situations, just as for provides a more concise and contained way to write count-controlled loops. Furthermore, switch statements and count-controlled loops fit very well together simply due to the nature of their coding.

    Just as while allows for broader test statements, so does if when compared to switch. When dealing with difficult logic that spans a plethora of variables, if statements are the most appropriate. They allow for multiple tests to be performed as well as logical comparisons of these test values. If statements can also be nested to allow for critically defined and logically understandable paths of execution.

    So, when deciding which statement you should use, simply ask yourself: can I relate all the possible paths of execution to a single variable? If so, then switch is best, as it saves time and is easy to read. If no, then you need to use if, as switch can only handle conditional situations that rely on a single variable.







    Whoo! My first tutorial! I've fact checked with numerous sites and reliable sources (thanks, JavaPF!), so I hope that this information is neither lacking nor incorrect.

    Thanks to JavaPF for looking it over, and to newbie for his advice for additions to the tutorial!

    If you notice any errors in the content or even a little grammar error, please tell me! Thanks!
    Last edited by snowguy13; January 12th, 2012 at 07:46 AM. Reason: Adding Content
    Use highlight tags to help others help you!

    [highlight=Java]Your prettily formatted code goes here[/highlight]

    Using these tags makes your code formatted, and helps everyone answer your questions more easily!




    Wanna hear something funny?

    Me too.

  2. The Following 5 Users Say Thank You to snowguy13 For This Useful Post:

    ChristopherLowe (January 12th, 2012), Gigggas (April 12th, 2012), JavaPF (January 11th, 2012), newbie (January 11th, 2012), OA-OD-JD1 (January 26th, 2012)


  3. #2
    Forum Squatter newbie's Avatar
    Join Date
    Nov 2010
    Location
    North Wales
    Posts
    661
    My Mood
    Stressed
    Thanks
    28
    Thanked 115 Times in 106 Posts
    Blog Entries
    1

    Default Re: IF and SWITCH Statements: How and When to Use Them

    Thanks for contributing Snowguy

    Just a few notes to try and help:
    • Be sure to mention that Switch statements using Strings are only available since Java 7, and will not work will work if users haven't updated.
    • Maybe include an example where switch cases fall through (i.e. without the break)
    • Up to you, but you might want to include XOR into your boolean list (^) but might be a tad excessive.
    • Consider including the ? : if operator into your tutorial (if it helps the goal of your tutorial)



    Please don't take the above as scrutiny, just reminders / tips in-case you wanted them included.
    I'll be sure to remove this post once you've thought over it.

    Thanks.
    Please use [highlight=Java]//code goes here...[/highlight] tags when posting your code

  4. The Following 2 Users Say Thank You to newbie For This Useful Post:

    JavaPF (January 11th, 2012), snowguy13 (January 11th, 2012)

  5. #3
    Member snowguy13's Avatar
    Join Date
    Nov 2011
    Location
    In Hyrule enjoying a chat with Demise and Ganondorf
    Posts
    339
    My Mood
    Happy
    Thanks
    31
    Thanked 48 Times in 42 Posts

    Default Re: IF and SWITCH Statements: How and When to Use Them

    Okay, I have revised my tutorial. Thanks a ton, newbie!
    Last edited by snowguy13; January 11th, 2012 at 12:24 PM.
    Use highlight tags to help others help you!

    [highlight=Java]Your prettily formatted code goes here[/highlight]

    Using these tags makes your code formatted, and helps everyone answer your questions more easily!




    Wanna hear something funny?

    Me too.

Similar Threads

  1. Help with switch statements
    By suxen in forum Loops & Control Statements
    Replies: 4
    Last Post: February 15th, 2011, 03:55 AM
  2. if else statements
    By mozyman in forum What's Wrong With My Code?
    Replies: 4
    Last Post: October 24th, 2010, 08:06 PM
  3. If statements
    By Scottj996 in forum Java Theory & Questions
    Replies: 1
    Last Post: August 16th, 2010, 10:09 AM
  4. need help with JButton and switch statements
    By jjoubert in forum AWT / Java Swing
    Replies: 5
    Last Post: October 28th, 2009, 09:13 AM
  5. Need help with While and For Statements
    By duckman in forum Loops & Control Statements
    Replies: 2
    Last Post: October 20th, 2009, 08:42 PM

Tags for this Thread