Java eLearning Kit For Dummies (2014)

---

After the input is converted, the application uses it to make a choice. The user can input any of the three choices, but there’s actually a hidden fourth choice. The user can also choose not to provide any of the specific input. For example, the user could type 3 instead of c or C. Consequently, the code must check the input up to three times in order to determine the user’s choice.

3. Save the code to disk using the filename UseAMenu01.java.

4. In your command prompt, type javac UseAMenu01.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java UseAMenu01 and press Enter.

The application asks you to choose a letter associated with a color.

6. Type A and press Enter.

The application outputs the expected message.

7. Repeat Steps 5 and 6, but substitute a value of b this time.

The application outputs the expected message again. Notice, however, that it doesn’t matter whether the input is uppercase or lowercase, you still get the expected result.

8. Repeat Steps 5 and 6, but substitute a value of 3 this time.

The application doesn’t output anything, as shown in Figure 6-3. Notice also in Figure 6-3 that the application provides a nice appearance for the menu system. For example, there is an extra line between Options and the list of options. That’s the purpose of the \n escape code shown in the listing. Ending a string with a \n escape code will add an extra line and provide a pleasing appearance to the user.

Figure 6-3:

Providing the right prompt can make a big difference in the usability of your application. For example, if you were to provide a list of valid options for the user of this application, such as Choose A, B, or C, you could make it less likely that the user will make an invalid choice. Even so, users do make invalid choices despite the best prompts, so your application code must also provide robust error handling.

Selecting from Multiple Conditions Using Switch

Just as there’s a shortcut for using two if statements in the if...else statement, there’s a shortcut for using multiple if...else statements to create a menu in the switch statement. The switch statement consists of a condition that looks like this:

switch (variable)

where variable contains a value you want to check against a number of constants. The constants appear as part of a case clause like this:

case value:

where value is a specific constant value you want to check. Finally, the task appears after the case clause and ends with a break clause like this:

task;
break;

You must include the break clause to tell the compiler when the task is finished.

The switch statement makes it possible to create a menu system in a way that’s easy to read and a lot shorter to type. In the following example, you create an application that relies on the switch statement to allow the user to select from one of several options.

Files needed: UseAMenu02.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import java.util.Scanner;
import java.lang.Character;

public class UseAMenu02
{
public static void main(String[] args)
{
// Create the scanner.
Scanner GetChoice = new Scanner(System.in);

// Obtain input from the user.
System.out.println("Options\n");
System.out.println("A. Yellow");
System.out.println("B. Orange");
System.out.println("C. Green\n");
System.out.print("Choose your favorite color: ");
char Choice = GetChoice.findInLine(".").charAt(0);

// Convert the input to uppercase.
Choice = Character.toUpperCase(Choice);

// Choose the right color based on a switch

// statement.
switch (Choice)
{
case 'A':
System.out.println("Your favorite color is
Yellow!");
break;
case 'B':
System.out.println("Your favorite color is
Orange!");
break;
case 'C':
System.out.println("Your favorite color is
Green!");
break;
}
}
}

This application begins precisely like the UseAMenu01 application does by displaying a menu of selections and asking the user to select one. In addition, it ensures that the input is converted to uppercase as needed. The switch statement compares Choice to three case clauses; A, B, and C. When Choice equals one of these constants, the application performs the task associated with that case statement and stops when it sees the break clause.

3. Save the code to disk using the filename UseAMenu02.java.

4. In your command prompt, type javac UseAMenu02.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java UseAMenu02 and press Enter.

The application will ask you to choose a color.

6. Type A and press Enter.

The application outputs the expected message.

7. Repeat Steps 5 and 6, but substitute a value of b this time.

The application outputs the expected message again.

8. Repeat Steps 5 and 6, but substitute a value of 3 this time.

The application doesn’t output anything, as shown in Figure 6-4.

Figure 6-4:

9. Compare Figure 6-3 with Figure 6-4.

Notice that both versions of the application behave precisely the same.

Executing a Default Task

The UseAMenu01 and UseAMenu02 applications suffer from a particular problem. When the user types an unexpected letter, number, or symbol, the application simply ends and doesn’t display anything. This response is better than allowing the application to crash, but it hardly tells the user what went wrong. In this case, you need a default action to help the user understand what’s wrong. Default tasks make it possible for the application to do something, even when the user doesn’t provide the expected input. In the following exercise, you create a new version of UseAMenu02 and add a default task to it.

Files needed: UseAMenu03.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import java.util.Scanner;
import java.lang.Character;

public class UseAMenu03
{
public static void main(String[] args)
{
// Create the scanner.
Scanner GetChoice = new Scanner(System.in);

// Obtain input from the user.
System.out.println("Options\n");
System.out.println("A. Yellow");
System.out.println("B. Orange");
System.out.println("C. Green\n");
System.out.print("Choose your favorite color: ");
char Choice = GetChoice.findInLine(".").charAt(0);

// Convert the input to uppercase.
Choice = Character.toUpperCase(Choice);

// Choose the right color based on a switch

// statement.
switch (Choice)
{
case 'A':
System.out.println("Your favorite color is
Yellow!");
break;
case 'B':
System.out.println("Your favorite color is
Orange!");
break;
case 'C':
System.out.println("Your favorite color is
Green!");
break;
default:
System.out.println(
"Type A, B, or C to select a color.");
break;
}
}
}

This application begins precisely like the UseAMenu02 application does by displaying a menu of selections and asking the user to select one. In addition, it ensures that the input is converted to uppercase as needed. The switch statement compares Choice with three case clauses: A, B, and C. When Choice equals one of these constants, the application performs the task associated with that case statement and stops when it sees the break clause.

Notice especially the default: clause of the switch statement. If the user doesn’t make an appropriate choice, the code selects this option. In other words, the default: clause provides a form of error trapping. In this case, the application outputs a helpful message that reminds the user of the valid choices for the application.

3. Save the code to disk using the filename UseAMenu03.java.

4. In your command prompt, type javac UseAMenu03.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java UseAMenu03 and press Enter.

The application asks you to choose a color.

6. Type A and press Enter.

The application outputs the expected message.

7. Repeat Steps 5 and 6, but substitute a value of b this time.

The application outputs the expected message again.

8. Repeat Steps 5 and 6, but substitute a value of 3 this time.

Notice that the application now outputs a helpful message to the user, as shown in Figure 6-5.

Figure 6-5:

Displaying Boolean Values

This is the first chapter where you’ve really used Boolean values for their intended purpose — as decision making tools. However, you’ll still find a need to display Boolean values from time to time. Most people understand true or false, but they don’t find using true or false natural. Unfortunately, Java doesn’t provide the means for displaying Boolean values in other ways, such as outputting yes or no, words the user will understand. In the following exercise, you construct a simple method for displaying Boolean values in human-readable terms, such as yes and no.

Files needed: DisplayBoolean.java

1. Open the editor or IDE that you’ve chosen to use for this book.

2. Type the following code into the editor screen.

// Import the required API classes.
import java.lang.String;

public class DisplayBoolean
{
public static void main(String[] args)
{
// Define a Boolean value.
boolean BoolVar = true;

// Change the Boolean value into a string.
String BoolString = BoolAsString(BoolVar, "Yes", "No");

// Display the result.
System.out.println("The answer is " +
BoolString + ".");
}

public static String BoolAsString(boolean BoolValue,
String TrueString, String FalseString)
{
return BoolValue ? TrueString : FalseString;
}
}

This application creates a simple boolean named BoolVar and sets it to true. It then creates a String value named BoolString that holds a human-readable version of the BoolVar value and displays this String on screen.

The secret to this example is the BoolAsString() method, which accepts three arguments as input and returns a String value.

· BoolValue: The Boolean value that you want to convert to a string.

· TrueString: The string you want output when BoolValue is true.

· FalseString: The string you want output when BoolValue is false.

The example returns the appropriate value based on a conditional statement. You initially saw conditional statements described in the “Performing a conditional evaluation” section of Chapter 5. This example presents a practical use for a conditional statement.

3. Save the code to disk using the filename DisplayBoolean.java.

4. In your command prompt, type javac DisplayBoolean.java and press Enter.

The compiler compiles your application and creates a .class file from it.

5. Type java DisplayBoolean and press Enter.

The application outputs a human readable string that matches the BoolVar value, as shown in Figure 6-6.

Figure 6-6:

Change the value of BoolVar to false. Compile and run the application. You should see the output change to match the new value of BoolVar. Try using other TrueString and FalseString values as well.

Summing Up

Here are the key points you learned about in this chapter:

· A conditional statement consists of a condition and a task. When the condition is true, the application performs the task.

· The condition portion of a conditional statement is also called an expression.

· Every conditional task could be performed by using a simple if statement, but using other conditional statement forms makes your application less prone to errors and also reduces the amount of typing you perform.

· The if…else statement lets your application choose between two courses of action depending on whether the expression you provide is true or false.

· Use the switch statement to allow the user to choose from a list of items.

· Rely on the default clause to provide a default action for your application when the user doesn’t provide useful input.

Try-it-yourself lab

For more practice with the features covered in this chapter, try the following exercise on your own:

1. Open the UseAMenu03 application.

2. Add a series of additional colors to the menu.

You want to change the menu to include additional System.out.println("Letter. Color"); entries. Make sure each entry has a unique letter associated with it.

3. Make the new menu entries functional by modifying the switch statement to accommodate them.

Each new color requires three lines of code similar to the code shown here:

case 'A':
System.out.println("Your favorite color is Yellow!");
break;

4. Change the default clause so that it provides the additional letters needed for the colors you added.

5. Compile the application.

6. Run the application.

7. Try each of the new menu entries.

Do the new menu entries work as you anticipated? If not, why not?

8. Try typing letters, numbers, or other symbols that don’t appear on the menu.

Does the default action still work as anticipated?

Know this tech talk

· bug: An error in the application code that causes your application to behave in a way that you didn’t anticipate.

· conditional statement: A programming construct that consists of a condition (expression) and a task. When the condition is true, the application performs the task.

· expression: A mathematical description of the condition that you want the application to check. An expression normally includes a logical operator and always provides a Boolean output.

· nesting: The act of combining multiple levels of statement into a single super statement. The application executes upper levels of the statement first and then drills down into lower levels. Use nesting to make complex decisions where one decision affects several others.