• $10 Game Dev' Courses - Use code "BREAKTHRU"

    Video courses

The Complete Java Developer Course. Learn Step by Step

The Complete Android & Java Developer Course – Build 21 Apps

Master Android N App Development With Java

In order for our game to dynamically respond to the player’s input, conform to the game’s rules and control the artificial intelligence of characters within the game; our code will need to make decisions. Programming languages achieve this by creating and testing for conditions based upon, the values held by our variables.

About this tutorial

Skill level 1
Time to read: 10 minutes

New Concepts:

  1. Decisions in Java
  2. if…
  3. Logical AND &&
  4. Logical OR ||

Projects related to or that demonstrate these concepts

We want to be able to do things like this:

if the player has no lives left end the game.

	Go back to the main menu screen

if the last alien has been destroyed 

	start the next level.

Note that the above is pseudo code to demonstrate how if works. It is not real Java. We will see real Java code using the if keyword shortly. We will use pseudo code from time to time to help explain things. It will usually be obvious when it is pseudo code but I will point it out when necessary. Also note how the action (e.g. Go back to main menu screen) is indented from the edge of the page? We will use indents allot to make our code more readable and I strongly encourage you to do the same.

Java has the if keyword and it works like this:

if(some condition is true) {

	// do whatever


The if keyword is followed by the opening and closing parentheses (). Inside the parentheses, we have a condition and afterward contained in the opening and closing curly braces {} we have the code that will run if the condition is true. We will deal with the // do whatever part in the next tutorial. For this tutorial, we will look at the most useful possibilities we can use with the Java if keyword to create conditions we can then test to see if they are true. Let’s look at some more operators this time some comparison operators that we can use to check for conditions in our games.

  • Learning java by building Android games

    Learning Java by Building Android Games

    Want to learn Java for Android? Even if you are completely new to either Java, Android, or game programming but are aiming to publish Android games, then this book is for you. This book also acts as a refresher for those who already have experience in Java on other platforms or other object-oriented languages.
    • Setup your own Android game programming environment using Android Studio
    • Control logic, branch your code, and add real decision-making depth to your games
    • Design and use 2d sprite animations, smooth pixel graphics, sound FX, simple collision detection and artificial intelligence (AI)
    • Build around a dozen sample test apps and 4 complete working games!
    Amazon USA
    Amazon UK
    Amazon CA
    Our Store (US only)

    Android Game Programming by Example

    Learn to build exciting Android game projects. Build a simple flappy-bird like game to a multi-environment, tough, retro platformer then an OpenGL ES 2 Asteroids clone, running at hundreds of frames per second .
    • Animate your characters with sprite sheets, add multiple scrolling parallax backgrounds, and implement genuinely tough, playable levels in your games
    • Every single line of code is printed in the book! No need to refer to the code files while trying to follow along. All the code files are also supplied separately so you can refer to them in their completed form and copy/paste them into your project if you like.
    • Implement a multitude of other game features such as pickups, firing weapons, HUD’s, generating and playing sound FX, scenery, level transition, high scores, and more
    Amazon USA
    Amazon UK
    Amazon CA
    Our Store (US Only)

Comparison operators

We can already add ( +), take away ( -), multiply( *), divide ( /), assign ( =), increment ( ++), compare ( ==), and decrement ( --) with operators. Let’s introduce some more super-useful operators, and then we will go straight to actually understanding how to use them in Java. Don’t worry about memorizing every operator given here. Just glance at the list of operators and their explanations and then move quickly on to the next section.

There, we will put some comparison operators to use and they will become much clearer as we see a few examples of what they allow us to do. They are presented here in a list just to make the variety and scope of operators apparent from the start.
== is the equality comparison operator not to be confused with the assignment operator. It tests for equality and is either true or false. We can create and test conditions like this.

if(10 == 9){

	// is obviously false 10 is not equal to 9.


! is the logical NOT operator. Here it is in action.

if(!(10 == 9)){

	// This is true because 10 is NOT 9.
	// This may seem convoluted but we will see
	// this type of comparison can be useful.


!= This is another comparison operator, which tests if something is NOT equal. For example:

if(10 != 9){

	// is true because 10 is not equal to 9.


>: This is another comparison operator, which tests if something is greater than something else. The expression:

if(10 > 9){

	// is of course true.


>=: This operator tests whether one value is greater than or equal to the other, and if either is true, the result is true. For example, the expression:

if(10 >= 9){

	// is true.


Also look at this for further clarification.

if(10 >= 10){ 

	// is also true because 10 equals 10
	// even though 10 is not greater than 10

<=: Like the preceding operator, this operator tests for two conditions but this time, less than or equal to. The expression,

if(10 <= 9){ 

	// is false.


However, both of these conditions are true.

if (10 <= 10){

	// is true because 10 equals 10


if (9 <= 10){

	// is true because 9 less than 10


&&: This operator is known as logical AND. It tests two or more separate parts of an expression and ALL parts must be true in order for the result to be true. Logical AND is usually used in conjunction with the other operators to build more complex tests. The expression:

if((10 > 9) && (10 < 11)){

	// is true because both parts are true.


However, this turns out false:

if((10 > 9) && (10 < 9)){

	// is false because only one part of the expression
	// is true (10 > 9) and the other is false (10 < 9).


|| This operator is called logical OR. It is just like logical AND except that only one of two or more parts of an expression need to be true for the expression to be true. Let’s look at the last example we used but replace the && sign with ||. The expression,

if((10 > 9) || (10 < 9)){

	// is now true because...
	// one part of the expression is true (10 > 9)


And as you might expect, we can use our game’s variables in if statements as well. Here are a few examples. You don’t need to fully understand how the code in the next few samples works just take a look at it and think about how we are controlling our game code with the if statements and their conditions. This is real code from a game.

boolean hitDetected = false;

// Some code that detects
// if the player ship was hit goes here

if(hitDetected) {

	playerLives --;


Now look at how we might check to see if the player had got a new fastest time at the end of a racing game. The variables would have been declared and initialized previously.

//check for new fastest time

if(timeTaken < fastestTime) {

	// the player took less time than the fastest time!!
	// So a new fastest time has been set

	// Now change the the fastest time variable
	// to the new fastest time (timeTaken)
	fastestTime = timeTaken;


The if keyword and all of these operators are virtually useless without a way of properly using them to make real decisions that affect real variables and code. Let’s look at how we can structure our game’s code to get stuff done. Note that almost any code at all can go inside the curly braces {} of a  if statement. In the next tutorial, we will see that we can branch our game code based on the conditions we have just learned to test for. Take a look at how to branch our game code.