[JAVA][Beginning Java 8 Games Development]

Chapter 3 ■ A Java 8 Primer: An Introduction to Java 8 Concepts and Principles
(fixed) nested class will only have one version, which does not change. For instance, a private inner class can only be
used by a parent class that contains it. The SplashScreen inner class coded as a private class would look something
like this:
public class InvinciBagel extends Application {
private class SplashScreen {
// The Java code that creates and displays your splashscreen is in here
}
}
Because this class is declared as private, it is for your own application usage (the containing class’s usage,
specifically). Thus, this would not be a utility or constant class for use by other classes, applications, or developers.
You can also declare your inner class without using the private access modifier keyword, which would look like the
following Java programming construct:
public class InvinciBagel extends Application {
class SplashScreen {
// The Java code that creates and displays your splashscreen is in here
}
}
This level of access control is called package or package private and is the default level of access control
applied to any class, interface, method, or data field that is declared without using one of the other Java access control
modifier keywords (public, protected, private). This type of inner class can be accessed not only by the top-level,
or containing, class, but also by any other class member of the package that contains that class. This is because the
containing class is declared public, and the inner class is declared package private. If you want an inner class to be
available outside the package, you declare it to be public, using the following Java code structure:
public class InvinciBagel extends Application {
public class SplashScreen {
// The Java code that creates and displays your splashscreen is in here
}
}
You can also declare an inner class protected, meaning that it can only be accessed by any subclasses of the
parent class. If you declare a class inside a lower-level Java programming structure that is not a class, such as a method
or an iteration control structure (commonly called a loop), it would technically be referred to as a local class. A local
class is only visible inside that block of code; thus, it does not allow (or make sense to use) class modifiers, such as
static, public, protected, or private. A local class is used like a local variable, except that it is a complex Java coding
construct rather than a simple a data field value that is used locally.
Finally, there is a type of inner class called an anonymous class. An anonymous class is a local class that has not
been given a class name. You are likely to encounter anonymous classes far more often than you are local classes.
This is because programmers often do not name their local classes (making them anonymous classes); the logic local
classes contain is only used locally, to their declaration, and so these classes do not really need to have a name—they
are only referenced internally to that block of Java code.
Java Methods: Core Java Function Code Constructs
Inside classes, you generally have methods and the data fields (variables or constants) that these methods use.
Because we are going from outside to inside, or top-level structures to lower-level structures, I will cover methods
next. Methods are sometimes called functions in other programming languages. Figure 3-2 provides an example
www.it-ebooks.info
51