Java methods are a way of organizing and compartmentalizing our code. They are quite a deep topic and a full understanding requires knowledge of other Java topics. By the end of the book you will be a method Ninja but for now, a basic introduction will be useful.

Methods have names to identify them from other methods and to help the programmer identify what they do. The methods in the Sub' Hunter game will have names like draw, takeShot, newGame, and printDebuggingText as well as a few more.

Code with a specific purpose can be wrapped inside a method, perhaps like this:

void draw(){
   // Handle all the drawing here
}

The above method called draw could hold all the lines of code that does the drawing for our game. When we set out a method with its code it is called the method definition. The curious looking prefixed void keyword and the postfixes () will be explained in Chapter 4, Structuring Code with Java Methods but for now, you just need to know that all...

As we add the method definitions to the code it shouldn't come as much surprise where each of the methods will go. The draw method will go after the comment about … do all the drawing… and so on.

Add the newGame method definition after the appropriate comment as shown next.

/*
   This code will execute when a new
   game needs to be started. It will
   happen when the app is first started
   and after the player wins a game.
 */
void newGame(){

}

Add the draw method definition after the appropriate comment as highlighted.

/*
   Here we will do all the drawing.
   The grid lines, the HUD,
   the touch indicator and the
   "BOOM" when a sub' is hit
*/
void draw() {

}

Add the onTouchEvent definition after this comment.

/*
   This part of the code will
   handle detecting that the player
   has tapped the screen
 */
@Override
public boolean onTouchEvent(MotionEvent motionEvent) {

}

You have probably noticed that the...

Object-Oriented Programming (OOP) makes it easy to do exceptional things. A simple analogy could be drawn with a machine, perhaps a car. When you step on the accelerator, a whole bunch of things happens under the hood. We don't need to understand about combustion or fuel pumps because a smart engineer has provided an interface for us. In this case, a mechanical interface—the accelerator pedal.

Take the following line of Java code as an example; it will look a little intimidating:

locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER)

However, once you learn that this single line of code searches Space for the available satellites and then communicates with them in orbit around the Earth while retrieving your precise latitude and longitude on the planet, it is easy to begin to glimpse the power and depth of object-oriented programming. Even if that code does look a little bit long and scary, imagine talking to a satellite in...

Packages are grouped collections of classes. If you look at the top of the code that we have written so far, you will see these lines of code.

import android.app.Activity;
import android.os.Bundle;

These lines of code make available the Activity and Bundle classes as well as their methods. Comment out the above two lines like this:

// import android.app.Activity;
// import android.os.Bundle;

Now look at your code and you will see errors in at least three places. The word Activity has an error because Activity is a class which Android Studio no longer is aware of in the following line:

public class SubHunter extends Activity {

The word onCreate also has an error because it is a method from the Activity class and the word Bundle has an error because it is a class which since we commented out the previous two lines Android is no longer aware of. This next line highlights where the errors are.

protected void onCreate(Bundle savedInstanceState) {

Uncomment the two lines of code...

So far, we know that we can define methods with code like this:

void draw(){
   // Handle all the drawing here
}

And we can call/execute methods with code like this:

draw();

We have also alluded to, as well as mentioned in our comments that the onCreate method (provided automatically by Android) will handle the One-time Setup part of the flowchart.

The reason for this is that all Android games (and the vast majority of other Android apps) must have an Activity class as the starting point. Activity is what interacts with the operating system. Without one the operating system cannot run our code. The way that the operating system interacts with and executes our code is through the methods of the Activity class. There are many methods in the Activity class but the one we care about right now is onCreate.

The onCreate method is called by Android itself when the player taps our game's icon on their screen.

The phone screen is still blank, but we have achieved our first output to the logcat window. In addition, we have laid out the entire structure of the Sub' Hunter game. All we need to do now is learn more about Java and then use it to add code to each of the methods.

We learned that Java methods are used to divide up the code into logical sections, each with a name. We don't know the full details of the methods yet but if you understand that you can define methods and then execute them by calling them then you know all you need to make further progress.

We also took a first glimpse at object-oriented programming. It doesn't matter if OOP seems a little baffling at this stage. If you know that we can code a class and create usable objects in our code based on that class, then you know enough to continue.

In the next chapter, we will learn about our games data. How the game "remembers" values like the position of the submarine or the size of the grid. We will...