[JAVA][Beginning Java 8 Games Development]

Chapter 3 ■ A Java 8 Primer: An Introduction to Java 8 Concepts and Principles
In this version the lifeIndex and hitsIndex variables at the top are initialized to 0, the default value for an
integer, so you do not have to use lifeIndex = 0 or hitsIndex = 0 in the code. The Java programming language
accommodates method overloading, so if you use an InvinciBagel bert = new InvinciBagel(900, "W"); method
call to instantiate the InvinciBagel object, the correct constructor method will be used to create the object. The
InvinciBagel object named bert would have a lifeIndex of 900 units of life and no hits on its life, would be facing
West, and would not be currently moving.
You can have as many (overloaded) constructor methods as you like, so long as they are each 100 percent unique.
This means that overloaded constructors must have different parameter list configurations, including parameter list
length (the number of parameters) and parameter list types (order of data types). As you can see, it is the parameter
list (length, data types, order) that allows a Java compiler to differentiate overloaded methods from one another.
Java Variables and Constants: Values in Data Fields
The next level down (progressing from API, to package, to class, to method, to the actual data values that are being
operated on in Java classes and methods) is the data field. Data values are held inside something called a variable; if
you fix, or make permanent, the data, it is called a constant. A constant is a special type of variable (which I will cover
in the next section), because declaring a constant correctly is a bit more involved (advanced) than declaring a Java
variable.
In the Java lingo, variables declared at the top of a class are called member variables, fields, or data fields,
although all variables and constants can be considered data fields, at a fundamental level. A variable declared inside a
method or other lower-level Java programming structure declared inside a class or method, is called a local variable,
because it can only be seen locally, inside the programming constructs delimited by curly braces. Finally, variables
declared inside a parameter list area of a method declaration or method call are, not surprisingly, called parameters.
A variable is a data field that holds an attribute of your Java object or software that can (and will) change over
the course of time. As you might imagine, this is especially important for game programming. The simplest form of
variable declaration can be achieved by using a Java data type keyword, along with the name that you want to use for
the variable in your Java program logic. In the previous section, using the constructor method, you declared an integer
variable named hitsIndex to hold the damage, or hits, that your InvinciBagel object will sustain during game play. You
defined the variable data type, and named it, using the following Java variable declaration programming statement:
int hitsIndex; // This could also be coded as: int hitsIndex = 0; (the default Integer is Zero)
As you also saw in that section, you can initialize your variable to a starting value, using an equals operator, along
with a data value that matches up with the data type declared: for example:
String facingDirection = "E";
This Java statement declares a String data type variable and names it facingDirection, on the left side of the
equals operator, and then sets the declared variable to a value of “E,” which signifies the direction East, or right. This
is similar to how an object is declared and instantiated, except that the Java new keyword and constructor method
are replaced by the data value itself, because now a variable (data field) is being declared instead of an object being
created. You will learn about the different data types (I have already covered Integer, String, and Object) later in
chapter (see the section “Java Data Types: Defining Data in Applications”).
You can also use Java modifier keywords with variable declarations, which I will do in the next section, when I
show you how to declare an immutable variable, also known as a constant, which is fixed, or locked, in memory and
which cannot be altered.
Now that I am almost finished going from the largest Java constructs to the smallest (data fields), I will start to
cover topics that apply to all levels (classes, methods, variables) of Java. These concepts will generally increase in
complexity as you progress to the end of this Java 8 primer chapter.
www.it-ebooks.info
55