[JAVA][Beginning Java 8 Games Development]

Chapter 3 ■ A Java 8 Primer: An Introduction to Java 8 Concepts and Principles
(I). Let’s say these states are held in a data field called ibState, of the type char, which holds a single character. The
switch-case code construct for using these game-piece state indicators to call the correct method, once a hit has
occurred, would be:
switch(ibState) {
// Evaluate ibState char and execute case code blocks accordingly
case 'F' :
deathLogicFlying(); // Java method controlling death sequence if InvinciBagel flying
break;
case 'J' :
deathLogicJumping(); // Java method controlling death sequence if InvinciBagel jumping
break;
case 'R' :
deathLogicRunning(); // Java method controlling death sequence if InvinciBagel running
break;
default :
deathLogicIdle(); // Java method controlling death sequence if InvinciBagel is idle
This switch-case logic construct evaluates the ibState char variable inside the evaluation portion of the switch()
statement (note that this is a Java method) and then provides a case logic block for each of the game-piece states
(flying, jumping, running) and a default logic block for the idle state (which is a logical way to set this up).
Because a game piece cannot be idle, running, flying, and jumping at the same time, you need to use the break
keyword to make each of the branches of this decision tree unique (exclusive).
The switch-case decision-making construct is generally considered more efficient, and faster, than the if-else
decision-making structure, which can use just the if keyword for simple evaluations, like this:
if(expression = true) {
programming statement one;
programming statement two;
}
You can also add an else keyword to make this decision-making structure evaluate statements that would need to
execute if the boolean variable (true or false condition) evaluates to false rather than true, which makes this structure
more powerful (and useful). This general programming construct would then look like this:
if(expression = true) {
programming statement one;
programming statement two;
} else { // Execute this code block if (expression = false)
programming statement one;
programming statement two;
}
In addition, you can nest if-else structures, thereby creating if{}-{else if}-{else if}-else{} structures. If these
structures get nested too deeply, then you would want to switch (no pun intended) over to the switch-case structure,
which will become more and more efficient, relative to a nested if-case structure, the deeper the if-else nesting goes.
For example, the switch-case statement that you coded earlier for the InvinciBagel game, if translated into a nested
if-else decision-making construct, would look like the following Java programming structure:
if(ibState = 'F') {
deathLogicFlying();
} else if(ibState = 'J') {
deathLogicJumping();
67