CITS2210 Object-Oriented Programming Topic 10 Java: Nested and Inner Classes Summary: Nested and inner classes allow classes do be defined within other classes, and even within bodies of methods. They enable certain styles of programming that are awkward otherwise. 1
What are nested and inner classes? A nested class is a class defined inside another class. public class OuterClass { class NestedClass { Nested class declarations can appear in classes and interfaces along with the more standard variable declarations and method declarations. Like other declarations, they can have modifiers like public, static, etc. A non-static nested class is called an inner class. You can always write separate classes instead of using nested classes, but they are still useful for the following reasons. They allow helper classes to be logically grouped with a main class. They allow improved encapsulation since nested classes can access private variables, and can be private themselves. They allow code to be better organized, with related code appearing in one place. 2
Static nested classes Static nested classes are attached to the outer class. They can only access static variables and methods from the outerclass directly. As such, static nested classes can usually be easily moved to become top-level classes the nesting is only used for organization. Static nested classes are can be accessed via the outer class, just like static methods and class variables (assuming that they are not private). public class Outer { public static class StaticNested { Outer.StaticNested nested = new Outer.StaticNested(); 3
Inner classes Inner classes are attached to a particular instance of the outer class. So, each instance of the inner class is also attached to this instance of the outer class. To create instances of an inner class you need an instance of the outer class so that you can use new with the inner class in that instance. Instances of inner classes can directly access all the methods and instance variables of the enclosing class for the instance they are attached to. public class Outer { private int instancevar; public class Inner { public int getouter() { return instancevar; Outer outer = new outer(); Outer.Inner inner = outer.new Inner(); int i = inner.getouter; 4
Extended example of an inner class public class DataStructure { private final static int SIZE = 15; private int[] arrayofints = new int[size]; public DataStructure() { for (int i = 0; i < SIZE; i++) { arrayofints[i] = i; //fill the array public void printeven() { //print out values of even indices of the array private class InnerEvenIterator { private int next = 0; // Begin at the start of the array. public boolean hasnext() { return (next <= SIZE - 1); public int getnext() { int retvalue = arrayofints[next]; next += 2; return retvalue; public static void main(string s[]) { DataStructure ds = new DataStructure(); InnerEvenIterator iterator = ds.new InnerEvenIterator(); while (iterator.hasnext()) { System.out.println(iterator.getNext() + " "); 5
Local and anonymous classes Sometimes an inner class is created specifically to be used in one particular place. In these cases, it makes sense to define the class where it is used rather than separately as a part of the outer class. A local class is an inner class that is defined a method body. An anonymous class is a class that is defined at the exact point where it is used, i.e., where an instance of the class is created. Local classes may be used many times within the the method where they are defined, while anonymous classes are only used once. interface IntRunnable { int run(); public class AnonEx { public static int callrun(intrunnable runnable) { runnable.run(); public static void main(string argv[]) { callrun(new IntRunnable() { // Anonymous class public int run() { return 3 * 5; ); // Close class then call to callrun 6
What use are anonymous classes? Anonymous classes turn out to be particularly useful when creating complex objects from a collection of simpler ones, each with their own methods. It is also often useful for glue code. These styles of programming largely borrow from functional programming, and are generally referred to as higher order. Increasingly this style is influencing object-oriented programming. C# in particular has been highly influenced. 7