[JAVA][Beginning Java 8 Games Development]

Chapter 3 ■ A Java 8 Primer: An Introduction to Java 8 Concepts and Principles
of the .start() method, showing how the method holds the programming logic that creates a basic “Hello World!”
application. The programming logic inside the method uses Java programming statements to create a Stage object
and a Scene object, place a button on the screen in a StackPane object, and define event-handling logic, such that
when the button is clicked, the bootstrap Java code writes the “Hello World!” text to your NetBeans IDE output area.
The method declaration starts with an access modifier keyword, either public, protected, private, or package
private (which is designated by not using any access control modifier at all). As you can see in the figure, the .start()
method has been declared, using the public access control modifier.
After this access control modifier, you will need to declare the method’s return type. This is the type of data that
the method will return after it is called, or invoked. Because the .start() method performs setup operations but does
not return a specific type of value, it uses the void return type, which signifies that the method performs tasks but does
not return any resulting data to the calling entity. In this case, the calling entity is the JavaFX Application class, as the
.start() method is one of the key methods (the others being the .stop() and .init() methods) provided by that class to
control the life cycle stages of a JavaFX application.
Next, you will supply the method name, which, by convention (programming rules), should start with a
lowercase letter (or word, preferably a verb), with any subsequent (internal) words (nouns or adjectives) starting
with a capital letter. For instance, a method to display the splash screen would be named .showSplashScreen() or
.displaySplashScreen() and because it does something but does not return a value, would be declared using
this code:
public void displaySplashScreen() { Java code to display splashscreen goes in here }
If you need to pass parameters, which are named data values that have to be operated on within the body of the
method (the part inside the curly braces), these go inside the parentheses that are attached to the method name. In
Figure 3-2 the .start() method for your bootstrap “HelloWorld!” JavaFX application receives a Stage object, named
primaryStage, using the following Java method declaration syntax:
public void start(Stage primaryStage) { bootstrap Java code to start Application goes in here }
You can provide as many parameters as you like, using the data type and parameter name pairs, with each pair
separated by a comma. Methods can also have no parameters, in which case the parameter parentheses are empty,
with the opening and closing parentheses right next to each other, for example, .start(), and .stop().
The programming logic that defines your method will be contained in the body of the method, which, as
discussed previously, is inside the curly braces that define the beginning and the end of the method. The Java
programming logic that is inside methods can include variable declarations, program logic statements, and iterative
control structures (loops), all of which you will be leveraging to create your Java game.
Before moving on, let’s focus on one other Java concept that applies to methods, namely, overloading Java
methods. Overloading a Java method means using the same method name, but different parameter list configurations.
What this means is that, if you have defined more than one method with the same name, Java can figure out which of
your (overloaded) methods to use by looking at the parameters that are being passed into the method being called
and then using that parameter list to discern which of the methods (that have the same name) to use by matching the
parameter list data types and names and the order in which they appear. Of course, your parameter list configurations
must all be unique for this Java method overloading feature to work correctly.
You will be learning how to use and how to code Java methods over the course of this book, beginning in Chapter 4,
so I am not going to spend too much time on them here, other than to define what they are and the basic rules for how
they are declared, and used, inside Java classes.
One specialized kind of method that I am going to cover in detail, however, is the constructor method. This is a
type of method that can be used to create objects. Java objects are the foundation of OOP, so you will be taking a look
at constructor methods next, as it is important to do so before learning about the Java object itself, which you will
study later in the chapter (see the section “Java Objects: Virtual Reality, Using Java Constructs“).
52
www.it-ebooks.info