Our first look at Java

So what about all that code that Android Studio generated when we created our new project earlier? This is the code that will bring our game menu to life. Let's take a closer look. The very first line of code in the editor window is this:

package com.packtpub.mathgamechapter2;

This line of code defines the package that we named when we first created the project. As the book progresses, we will write more complex code that spans more than one file. All the code files we create will need the package they belong to, clearly defined like the previous line of code, at the top. The code doesn't actually do anything in our game. Notice also that the line ends with a semicolon (;). This is a part of the Java syntax and it denotes the end of a line of code. Remove a semicolon and you will get an error because Android Studio tries to make sense of two lines together. Try it if you like.

To see the next four lines of code, you might need to click on the small + icon to reveal them. Android Studio tries to be helpful by simplifying our view of the code. Notice that there are several little - icons as well down the side of the editor window. You can expand and collapse them to suit yourself without affecting the functionality of the program. This is shown in the following screenshot:

Once you have expanded the code, you will see these four lines:

import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem; 

Notice that all the preceding lines start with the word import. This is an instruction to include other packages in our game, not just our own. This is very significant because it makes available to us all of the hard work of other programmers, the Android development team in this case. It is precisely these imports that give us the ability to use the methods we discussed earlier, and allow us to interact with the Android life cycle phases. Notice again that all the lines end with a semicolon (;).

The next line introduces a fundamental building block of Java known as a class. Classes are something that we will continually expand our knowledge and understanding of throughout the book. For now, take a look at this line of code, then we will discuss it in detail:

public class MainActivity extends ActionBarActivity {

Word by word, here is what is going on. The preceding line is saying: make me a new public class called MainActivity and base it upon (extends) ActionBarActivity.

You might remember that MainActivity is the name we chose while creating this project. ActionBarActivity is the code (known as a class) written by the Android development team that enables us to put our Java into Android.

If you have a keen eye, you might notice there is no semicolon at the end of this line. There is, however, an opening curly brace ({). This is because MainActivity encompasses the rest of the code. In effect, everything is part of our MainActivity class, which is built based on the ActionBarActivity class/code. If you scroll down to the bottom of the editor window, you will see a closing curly brace (}). This denotes the end of our class called MainActivity.

So, it is the ActionBarActivity class that contains the methods that enable us to interact with the Android life cycle. Actually, there are a number of different classes that enable us to do this and in a moment, we will change from using ActionBarActivity to a more appropriate class that also does all the things just mentioned.

Moving on with the code, let's look at what the code that is contained within our class actually does.

Here is the code chunk directly after the crucial line we have just been discussing:

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

Hopefully, some of this code will start to make sense now and tie in with what we have already discussed. Although the precise syntax will still feel a little alien, we can continue learning Java as long as we are aware of what is happening.

The first thing we notice in the preceding code is the word @override. Remember when we said that all the methods that interact with the Android life cycle were implemented by default and we can pick and choose if and when to override them? This is what we are doing here with the onCreate method.

The @override word says that the method that follows next is being overridden. The protected void onCreate(Bundle savedInstanceState) { line contains the method we are overriding. You might be able to guess that the action starts with the opening { at the end of the line in question and ends with the closing } three lines later.

The somewhat odd-looking protected void before the method name onCreate and (Bundle savedInstanceState) after the method name are unimportant at this time because they are handled for us. It is to do with the data that travels between various parts of our program. We just need to know that what happens here will take place in the creating phase of the Android lifecycle. The rest will become clear in Chapter 4, Discovering Loops and Methods. Let's move on to the line:

super.onCreate(savedInstanceState);

Here, the super keyword is referencing the code in the original onCreate method, which is still there even though we can't see it. The code is saying: even though I am overriding you, I want you to set things up, just like you normally do first. Then, after onCreate has done loads of work that we don't see and don't need to see, the method continues and we actually get to do something ourselves with this line of code:

setContentView(R.layout.activity_main);

Here we are telling Android to set the main content view (our users screen), which is the cool game menu we created earlier. To be specific, we are stating it is an R or resource in the layout folder and the file is called activity_main.

package com.packtpub.mathgamechapter2.mathgamechapter2;

import android.support.v7.app.ActionBarActivity;
import android.os.Bundle;


public class MainActivity extends ActionBarActivity {

    @Override
    protected void onCreate(Bundle savedInstancePhase) {
        super.onCreate(savedInstancePhase);
        setContentView(R.layout.activity_main);
    }

}