[JAVA][Beginning Java 8 Games Development]

Chapter 3 ■ A Java 8 Primer: An Introduction to Java 8 Concepts and Principles
A nested class uses what is commonly referred to in Java as dot notation to reference the nested class “off of”
its master, or parent, containing class. For instance, MasterClass.NestedClass would be the referencing format that
would be used to reference a nested class via its master class (containing class) name, using generic class type names
here. If you created an InvinciBagel SplashScreen nested class to draw the splash screen for your Java game, it would
be referenced in your Java code as InvinciBagel.SplashScreen, using this Java 8 dot notation syntax.
Let’s take a look at, for example, the JavaFX Application class, which contains a Parameters nested class. This
nested class encapsulates, or contains, the parameters that you can set for your JavaFX application. Thus, this
Application.Parameters nested class would be a part of the same javafx.application package as your Application
class and would be referenced as javafx.application.Application.Parameters, if you were using an import statement.
Similarly, the constructor method would be written as Application.Parameters(), because the constructor
method must have the exact same naming schema as the class that it is contained in. Unless you are writing code for
other developers, which is when nested classes are most often used (such as the JavaFX Application class or the many
nested utility or constant provider classes which you will find in the Android OS), you are far more likely to utilize
non-static nested classes (commonly referred to as Java inner classes).
A nested class can be declared by using the Java static keyword. A Java keyword is also sometimes called a Java
modifier. Therefore, if you were to do an InvinciBagel.SplashScreen nested class, the InvinciBagel class and its
SplashScreen nested class declaration (Java 8 programming structure) would look something like this:
public class InvinciBagel extends Application {
static class SplashScreen {
// The Java code that creates and displays your splashscreen is in here
}
}
It is important to note if you use, for example, import javafx.application.Application.Parameters to import
a nested class, you can reference that nested class within your class, using just the Parameters class name, rather than
the full class name path that shows your class’s code how to travel through a parent class to its nested class via the
Application.Parameter (ClassName.NestedClassName) dot notation syntax reference.
As you will see many times throughout this book, Java methods can also be accessed using the dot notation. So,
instead of using ClassName.NestedClassName.MethodName, you could, if you had used the import statement to
import this nested class, simply use NestedClassName.MethodName. This is because the Java import statement has
already been used to establish the full reference path to this nested class, through its containing class, and so you do
not have to provide this full path reference for the compiler to know what code construct you are referring to!
Next, let’s take a look at nonstatic nested classes, which are usually referred to as Java inner classes.
Inner Classes: Different Types of Nonstatic Nested Classes
Java inner classes are also nested classes, but they are not declared using the static keyword modifier before the class
keyword and class name, which is why they are called nonstatic nested classes. Thus, any class declaration that is
inside another class that does not use the static (keyword) modifier would be termed an inner class in Java. There are
three types of inner classes in Java: member class, local class, and anonymous class. In this section, you will discover
what the differences are between these inner classes, as well as how they are implemented .
Like nested classes, member classes are defined within the body of the containing (parent) class. You can
declare a member class anywhere within the body of the containing class. You would declare a member class if you
wanted to access data fields (variables or constants) and methods belonging to the containing class without having to
provide a path (via dot notation) to the data field or method (ClassName.DataField or ClassName.Method).
A member class can be thought of as a nested class that does not use the Java static modifier keyword.
Whereas a nested class is referenced through its containing, or top-level, class, using a dot notation path to the
static nested class, a member class, because it is not static, is instance specific, meaning that objects (instances)
created via that class can be different from each other (an object is a unique instance of a class), whereas a static
50
www.it-ebooks.info