[JAVA][Beginning Java 8 Games Development]

Chapter 3 ■ A Java 8 Primer: An Introduction to Java 8 Concepts and Principles
Creating a Java Object: Invoking a Class’s Constructor Method
A Java class can contain a constructor method with the exact same name as the class that can be used to create Java
objects using that class. A constructor method uses its Java class like a blueprint to create an instance of that class in
memory, which creates a Java object. A constructor method will always return a Java object and thus does not use any
of the Java return types that other methods will typically use (void, String, and so on). A constructor method is invoked
by using the Java new keyword, because you are creating a new object.
You can see an example of this in the bootstrap JavaFX code shown in Figure 3-2 (ll. 20, 28, and 30), where new
Button, StackPane, and Scene objects are created, respectively, by using the following object declaration, naming,
and creation Java code structure:
= new
The reason that a Java object is declared in this way, using the class name, the name of the object you are
constructing, the Java new keyword, and the class’s constructor method name (and parameters, if any) in a single
Java statement terminated with a semicolon, is because a Java object is an instance of a Java class.
Let’s take a look at, for example, the Button object creation from line 20 of your current Java code. Here, via the
part of the Java statement on the left-hand side of the equals operator, you are telling the Java language compiler that
you want to create a Button object named btn, using the JavaFX Button class as the object blueprint. This declares the
Button class (object type) and gives it a unique name.
The first part of creating the object is thus called the object declaration. The second part of creating your Java
object is called the object instantiation, and this part of the object creation process, seen on the right-hand side of the
equals operator, involves a constructor method and the Java new keyword.
To instantiate a Java object, you invoke the Java new keyword, in conjunction with an object constructor method
call. Because this takes place on the right-hand side of the equals operator, the result of the object instantiation is
placed in the declared object, which is on the left-hand side of the Java statement. As you will see a bit later in the
chapter, when I discuss operators (see the section “Java Operators: Manipulating Data in the Application”), this is
what an equals operator does, and a useful operator it is.
This completes the process of declaring (class name), naming (object name), creating (using a new keyword),
configuring (using a constructor method), and loading (using the equals operator) your very own custom Java object.
It is important to note that the declaration and instancing parts of this process can be coded using separate lines
of Java code as well. For instance, the Button object instantiation (see Figure 3-2, l. 20) could be coded as follows:
Button btn;
btn = new Button();
This is significant, because coding an object creation in this way allows you to declare an object at the top of your
class, where each of the methods inside the class that use or access these objects can see the object. In Java, unless
declared otherwise, using modifiers, an object or data field is only visible inside the Java programming construct
(class or method) in which it is declared.
If you declare an object inside your class, and therefore outside all the methods contained in the class, then all
the methods in your class can access (use) that object. Similarly, anything declared inside a method is local to that
method and is only visible to other members of that method (Java statements inside the method scope delimiters). If
you wanted to implement this separate object declaration (in the class, outside the methods) and object instantiation
(inside the .start() method) in your current InvinciBagel class, the first few lines of Java code for your InvinciBagel
class would change to look like the following Java programming logic:
public class InvinciBagel extends Application {
Button btn;
@Override
public void start(Stage primaryStage) {
btn = new Button();
www.it-ebooks.info
53