Lesson 27Phase 3: Abstraction and design

Inner classes and OOP consolidation

Classes that live inside classes, when nesting helps, and a recap that ties all the object ideas so far together.

By BasithUpdated 26 October 202655 min

inner class
nested class
static nested
anonymous class
consolidation

Every class you have written so far has stood on its own, side by side with the others in the file. That is the usual case, and it stays the usual case. Sometimes, though, a class only makes sense as part of another one: a small helper that nothing else in the program uses. Java lets you write that helper inside the class it serves. This lesson shows the kinds of class you can put inside another, when each one fits, and then steps back to connect the object-oriented ideas you have met so far.

By the end of this lesson

Say why a helper class is sometimes better placed inside the class it serves.
Tell a static nested class apart from an inner class, and build an object of each.
Explain how an inner-class object reaches the fields of the outer object it belongs to.
Write an anonymous class that implements an interface on the spot, and read one that extends a class.
Connect the object-oriented ideas of the course so far into one map.

From before

This lesson leans on everything you have built with objects. You can define a class with fields and make objects, give them methods, build them with constructors, and write an interface that classes promise to implement. Most of all, you know from static and final the difference between what belongs to the class and what belongs to one object. That difference decides almost everything on this page, so keep it close.

A helper that has no life of its own#

Picture a class that holds an address: a street, a city and a postcode. On its own, an address is a perfectly good class. Now suppose the only reason it exists in your program is to be part of a Person. No other code makes an address by itself or cares about an address that does not belong to a person. The address is a detail of the person.

You can still write it as a top-levelclass, one written directly in the file and not inside another class. Nothing forces you to nest it. But then the file says “here is an Address that anyone may use”, when the truth is “this only ever belongs to a Person”. Writing the class inside Person says what is true: the helper sits where it is used, and it is plainly a detail of its host.

Key idea
Nest a class when it is a detail of another class, not something the rest of the program needs to know about. The nesting groups related code and says “this belongs to me”.

Two classic examples you will meet later

A linked list is made of little boxes, each holding one value and a link to the next box. In linked lists you build one from a separate Node class. Java's own LinkedList keeps its node class nested inside, as a private static class, because a node means nothing outside its list. The other classic case is a builder, a helper that collects settings and then builds an object, which you will meet in designing classes well as new Pizza.Builder("large").

For the named kinds on this page it is a choice about tidiness and intent, never a requirement. You can always move a nested class out into its own top-level class and make the program work again. What you lose is the signal. A reader can no longer tell at a glance that the helper belongs to its host, and unrelated code may start depending on it. Nesting exists to make intent visible, the same way private kept the inside of an object to itself in encapsulation.

Two kinds, and the one question that separates them#

When you write a class inside another class, you face one decision, and it is one you already understand from static and final: does this nested class need a connection to a particular object of the outer class, or not?

That single question splits nested classes into two kinds:

A static nested class is marked static. It has no link to any outer object. It lives inside the outer class's braces only for grouping. Think of it as an ordinary class that you filed inside another one for tidiness.
An inner class is a nested class without static. It is tied to one particular object of the outer class. Every inner-class object belongs to an outer object and can use that object's fields directly.

This is the rule from static and final again: a static member belongs to the class itself, while a member without static belongs to one object. A static nested class belongs to the outer class. An inner class belongs to an outer object. Seen that way, the two kinds are one familiar idea used once more, with nothing new to memorize.

Static nested class

Inner class (no static)

Marked with static.

No static keyword.

No link to any outer object.

Tied to one particular outer object.

Cannot use the outer object's instance fields.

Uses the outer object's fields directly.

Built on its own: new Outer.Helper().

Built from an outer object: outer.new Inner().

Like a top-level class, filed inside for tidiness.

Like a part that only exists as part of a whole.

Use it when the helper needs nothing from an outer object.

Use it when the helper needs one outer object's state.

Quick check

A Library class has a nested Loan class. A loan's describe() method prints the library's name, an instance field of Library. Which kind of nested class should Loan be?

A static nested class#

Here is the address as a static nested class. Step through it and watch the order: the address is built first, on its own, with no Person anywhere, and only then handed to the new person.

Person.java

1public class Main {

2 public static void main(String[] args) {

3 // A static nested class is built on its own, no Person object needed.

4 Person.Address home = new Person.Address("Cairo");

6 Person p = new Person("Aisha", home);

7 System.out.println(p.name + " lives in " + p.address.city);

8 }

9}

11class Person {

12 String name;

13 Address address;

15 Person(String name, Address address) {

16 this.name = name;

17 this.address = address;

18 }

20 // Static nested class: it lives inside Person for tidiness, but it has

21 // no link to any particular Person object. It is just filed here.

22 static class Address {

23 String city;

25 Address(String city) {

26 this.city = city;

27 }

28 }

29}

Prints

›Aisha lives in Cairo

It prints Aisha lives in Cairo. Read the type name carefully: Person.Address. Because Address lives inside Person, its full name starts with its host, the same way a static field is reached as Goblin.count. The static on the class is what lets you write new Person.Address("Cairo") with no Person object in sight. In the memory view the address is an ordinary object of its own, and the person simply points at it.

An inner class#

Now the other kind. An inner class is tied to an outer object, so it can read that object's fields without being handed them. Below, a BankAccount has an inner Statementclass. A statement only makes sense for one particular account, and it reaches straight into that account's owner and balance.

BankAccount.java

1public class Main {

2 public static void main(String[] args) {

3 BankAccount acc = new BankAccount("Aisha", 500.0);

5 // An inner class is built FROM an outer object: acc.new Statement().

6 // The statement is bound to this one account.

7 BankAccount.Statement s = acc.new Statement();

8 s.print();

9 }

10}

12class BankAccount {

13 String owner;

14 double balance;

16 BankAccount(String owner, double balance) {

17 this.owner = owner;

18 this.balance = balance;

19 }

21 // Inner class (no static): each Statement belongs to one BankAccount and

22 // can read that account's fields, owner and balance, directly.

23 class Statement {

24 void print() {

25 System.out.println("Statement for " + owner + ": balance is " + balance);

26 }

27 }

28}

Prints

›Statement for Aisha: balance is 500.0

It prints Statement for Aisha: balance is 500.0. Look at print(). It says owner and balancewith no dot in front, just like an ordinary method reading its own object's fields. Those fields do not belong to the Statement, though. In the memory view the statement has no fields of its own, only a BankAccount.this row with an arrow to the account. The fields belong to the BankAccount this statement was made from. Reaching into the outer object is the whole point of an inner class, and it is why you build one as acc.new Statement(): the statement needs to know which account it belongs to.

So does a statement remember the balance it saw when it was made? Decide before you run this one.

Predict the outputLiveBalance.java

1public class Main {

2 public static void main(String[] args) {

3 BankAccount acc = new BankAccount("Aisha", 500.0);

4 BankAccount.Statement s = acc.new Statement();

6 acc.balance = 750.0;

7 s.print();

8 }

9}

11class BankAccount {

12 String owner;

13 double balance;

15 BankAccount(String owner, double balance) {

16 this.owner = owner;

17 this.balance = balance;

18 }

20 class Statement {

21 void print() {

22 System.out.println("Statement for " + owner + ": balance is " + balance);

23 }

24 }

25}

The balance changes after the statement is made. What does s.print() show?

It prints Statement for Aisha: balance is 750.0. The statement never copied the balance. It holds a link to the account, and print()reads the account's balance at the moment it runs, so it sees the new value.

An inner-class object holds a hidden reference back to the outer object it belongs to. That hidden link is how print() can say balanceand mean “the balance of the account I belong to”. To set up the link, Java needs to know which outer object you mean at the moment you build the inner one, and acc.new Statement() says exactly that: build a Statement attached to acc. Leave the account out, as in new BankAccount.Statement() written in main, and javac refuses with an enclosing instance that contains BankAccount.Statement is required. A static nested class has no such link, which is why it can be built with a plain new Person.Address(...)and cannot see any outer object's fields.

Sometimes the inner class has a field with the same name as a field of the outer class. Inside the inner class, the plain name then means the inner object's own field, because the closest one wins. To reach the outer object's field, write the outer class's name, a dot and this: Team.this.bonusmeans “the bonus of the team this player belongs to”. On its own, Team.this is that team object, so a player can even hand its team back.

SameNames.java

1public class Main {

2 public static void main(String[] args) {

3 Team lions = new Team("Lions");

4 Team.Player ada = lions.new Player("Ada");

5 System.out.println(ada.describe());

6 System.out.println(ada.team() == lions);

7 }

8}

10class Team {

11 String name;

12 int bonus = 10;

14 Team(String name) {

15 this.name = name;

16 }

18 class Player {

19 String name;

20 int bonus = 1;

22 Player(String name) {

23 this.name = name;

24 }

26 String describe() {

27 // name and bonus alone mean this player's own fields.

28 // Team.this.name and Team.this.bonus reach the team's.

29 return name + " (bonus " + bonus + ") plays for "

30 + Team.this.name + " (bonus " + Team.this.bonus + ")";

31 }

33 Team team() {

34 return Team.this;

35 }

36 }

37}

Prints

›Ada (bonus 1) plays for Lions (bonus 10)

›true

It prints Ada (bonus 1) plays for Lions (bonus 10) and then true. In the memory view, the player object has a Team.this row next to its own fields. That row is the hidden link, drawn as an arrow to the team the player was made from.

In real code you will rarely write acc.new Statement() yourself. Usually the outer class has a method that makes its inner objects, such as Statement statement() { return new Statement(); }. Inside an instance method of BankAccount, a plain new Statement() is attached to this account automatically. The exercise below uses that pattern.

A simple rule for choosing

Start with static. If the nested class never touches an outer object's instance fields, make it a static nested class; it is simpler and carries no hidden link. Drop the staticonly when the helper really needs to reach into one outer object's state.

ExerciseTeams.java

Each Player belongs to one Team, so Player is an inner class, made by the team's sign method. Finish it: the constructor should add one to the size of the team the player joins, and badge() should return the player's name followed by plays for the and the team's name.

1public class Main {
2    public static void main(String[] args) {
3        Team falcons = new Team("Falcons");
4        Team hawks = new Team("Hawks");
5 
6        Team.Player ana = falcons.sign("Ana");
7        Team.Player ben = falcons.sign("Ben");
8        Team.Player cleo = hawks.sign("Cleo");
9 
10        System.out.println(ana.badge());
11        System.out.println(ben.badge());
12        System.out.println(cleo.badge());
13        System.out.println(falcons.name + " squad size: " + falcons.size);
14        System.out.println(hawks.name + " squad size: " + hawks.size);
15    }
16}
17 
18class Team {
19    String name;
20    int size = 0;
21 
22    Team(String name) {
23        this.name = name;
24    }
25 
26    Player sign(String playerName) {
27        return new Player(playerName);
28    }
29 
30    class Player {
31        String playerName;
32 
33        Player(String playerName) {
34            this.playerName = playerName;
35            // TODO: add one to the size of the team this player joins
36        }
37 
38        String badge() {
39            return playerName; // TODO: add " plays for the " and the team's name
40        }
41    }
42}

public class Main {
    public static void main(String[] args) {
        Team falcons = new Team("Falcons");
        Team hawks = new Team("Hawks");

Team.Player ana = falcons.sign("Ana");
        Team.Player ben = falcons.sign("Ben");
        Team.Player cleo = hawks.sign("Cleo");

System.out.println(ana.badge());
        System.out.println(ben.badge());
        System.out.println(cleo.badge());
        System.out.println(falcons.name + " squad size: " + falcons.size);
        System.out.println(hawks.name + " squad size: " + hawks.size);
    }
}

class Team {
    String name;
    int size = 0;

Team(String name) {
        this.name = name;
    }

Player sign(String playerName) {
        return new Player(playerName);
    }

class Player {
        String playerName;

Player(String playerName) {
            this.playerName = playerName;
            // TODO: add one to the size of the team this player joins
        }

String badge() {
            return playerName; // TODO: add " plays for the " and the team's name
        }
    }
}

Anonymous classes: a one-off class with no name#

There is a third shape, and you will see it in real code often. Sometimes you need a class exactly once, in one place, and giving it a name and a block of its own feels like ceremony. Java lets you define such a class and build an object of it in a single expression, with no name at all. That is an anonymous class.

The typical use is a callback: a small piece of behavior you hand to some other code so that it can call you back later. Think “when the button is clicked, run this”. The “this” is a tiny one-off object whose only job is to carry that one method. A whole named class for it would hide the intent; an anonymous class puts the behavior right where it is used.

Greeter.java

1public class Main {

2 public static void main(String[] args) {

3 // An anonymous class: this defines a one-off subclass of Greeter AND

4 // builds an object of it, all in one expression. It has no name.

5 Greeter g = new Greeter() {

6 void greet() {

7 System.out.println("Hello from a class with no name");

8 }

9 };

10 g.greet();

11 }

12}

14class Greeter {

15 void greet() {

16 System.out.println("a plain greeting");

17 }

18}

Prints

›Hello from a class with no name

It prints Hello from a class with no name. Read the shape slowly. new Greeter() { ... } does more than build a Greeter. The block of braces right after the parentheses is a new class body, written on the spot, that extends Greeter and overrides greet(). There is no class Something extends Greeter line anywhere, because the class never gets a name. Note the semicolon after the closing brace: the whole thing is one expression inside an ordinary variable declaration.

Quick check

What does Greeter g = new Greeter() { void greet() { ... } }; create?

Implementing an interface on the spot#

The more common use is with an interface. You cannot write new ClickHandler() on its own, because an interface is only a promise: javac says ClickHandler is abstract; cannot be instantiated. Add a body that keeps the promise, though, and you get an object of a nameless class that implements the interface. Here a button stores whatever handler it is given and calls it when pressed:

Button.java

1public class Main {

2 public static void main(String[] args) {

3 String name = "Sana";

5 Button ok = new Button("OK");

6 ok.onClick(new ClickHandler() {

7 public void handle(String label) {

8 System.out.println(name + " pressed " + label);

9 }

10 });

11 ok.press();

12 }

13}

15interface ClickHandler {

16 void handle(String label);

17}

19class Button {

20 String label;

21 ClickHandler handler;

23 Button(String label) {

24 this.label = label;

25 }

27 void onClick(ClickHandler h) {

28 handler = h;

29 }

31 void press() {

32 handler.handle(label);

33 }

34}

Prints

›Sana pressed OK

It prints Sana pressed OK. The anonymous class is written right inside the call to onClick, as its argument. Its handle method is public because interface methods are public, as you saw in interface vs abstract class. Step through it and notice the order: nothing is printed when the handler is handed over. It runs only later, when press() calls it back.

The handler also uses name, a local variable of main. An anonymous class may read the local variables around it, with one condition: they must never change after they get their value. Java calls such a variable effectively final: it is not marked final, but it could be. Give name a second value and the program no longer compiles:

Rename.java (does not compile)

read along

1public class Main {

2 public static void main(String[] args) {

3 String name = "Sana";

4 name = "Ravi";

6 ClickHandler h = new ClickHandler() {

7 public void handle(String label) {

8 // error: local variables referenced from an inner class must be final or effectively final

9 System.out.println(name + " pressed " + label);

10 }

11 };

12 h.handle("OK");

13 }

14}

16interface ClickHandler {

17 void handle(String label);

18}

Put the lines in orderCountdown.java

Put the lines in order so that the program builds a Countdown with an anonymous class and then runs it, printing 3, 2, 1 and Go! on separate lines.

Tap a line, then tap where it should go. Or use the arrows.

The next lesson shortens this

An anonymous class that implements an interface with a single method is so common that Java has a much shorter way to write it: the lambda. The whole handler above shrinks to label -> System.out.println(name + " pressed " + label). Lambdas, and the single-method interfaces they implement, are the subject of enums, lambdas and functional interfaces, right after this lesson. A lambda follows the same rule about local variables.

Anywhere a library wants you to supply a small behavior and call it back later: sorting with your own way of comparing (comparing and sorting), reacting to a button press in a desktop app (JavaFX events), or running a timer. Before lambdas arrived in Java 8, every one of those was written as an anonymous class, and you will still find plenty of them in older code and in examples online. Recognizing the shape, new Something() { ... } with methods inside, means you can read that code now.

You can also declare a named class inside a method. It is called a local class, and, like a local variable, it can be used only inside that method. It suits a small type that one method needs for a moment:

Pairs.java

1public class Main {

2 public static void main(String[] args) {

3 String joiner = " & ";

5 class Pair {

6 String left;

7 String right;

9 Pair(String left, String right) {

10 this.left = left;

11 this.right = right;

12 }

14 String joined() {

15 return left + joiner + right;

16 }

17 }

19 Pair a = new Pair("salt", "pepper");

20 Pair b = new Pair("fish", "chips");

21 System.out.println(a.joined());

22 System.out.println(b.joined());

23 }

24}

Prints

›salt & pepper

›fish & chips

It prints salt & pepper and fish & chips. Look at joined(): it uses joiner, a local variable of main. A local class can read the variables of the method around it, as long as they never change after they are set. That is the same effectively final rule as for anonymous classes, and for a good reason: an anonymous class is a local class with no name. Outside main, the name Pair means nothing.

Consolidation: the object ideas so far, in one map#

You now have the core tools for building programs out of objects. The rest of this phase, enums, records and sealed types, builds on these same tools, so this is a good moment to stop adding and connect. Below is one map that ties together everything from the first object you made to the keywords of the last few lessons.

The foundation: class and object

Everything starts with one move. Bundle the data that belongs together with the actions that work on it, and describe that bundle once as a class. From the class you build many objects with new, each holding its own state. A class gives its objects behavior through methods, and a constructor makes sure every object starts out in a valid state. See why objects and creating classes and objects.

The four big ideas

On that foundation stand the four ideas that object-oriented programming is built from. Each one solves a clear problem.

Encapsulationhides an object's insides so that outside code cannot put it into a nonsense state. Mark fields private and offer controlled methods. Access modifiers and encapsulation.
Inheritance lets one class build on another, the is-a relationship, so shared code lives in a parent and every child reuses it. Inheritance, plus the overriding and super that let a child replace or extend what it inherits.
Polymorphism lets one parent-typed variable drive different behavior for each object, so a single loop over an Animal[] can make each animal speak in its own voice. Polymorphism.
Abstraction hides detail behind a clean shape, either through an abstract class that shares code while it demands a contract, or through an interface that is mostly a contract with no code of its own.

Key idea
Encapsulation, inheritance, polymorphism and abstraction share one purpose: to let you build a large program out of small parts, each of which knows its own job and can be reused.

The shaping keywords

Around those four ideas sit the keywords that shape how classes relate and what they promise. They are precise tools for expressing the four ideas above.

Tool

What it gives you

abstract class or method

An unfinished base that cannot be built, with blanks that subclasses must fill. Abstract classes.

interface with implements

A contract of can-do behavior that a class promises to keep, and a class can keep many. Interfaces.

Choosing between the two

is-a and shared state point to an abstract class; can-do and many capabilities point to an interface. Interface vs abstract class.

static

A member that belongs to the class, not to any one object, and is shared by all. Static and final.

final

A variable that cannot be reassigned, a method that cannot be overridden, or a class that cannot be extended. Static and final.

Nested and inner classes

A helper class placed inside the class it serves: static when it needs no outer object, inner when it does, anonymous when it is needed once.

Quick check

A program decides what sound each animal makes with a long if/else chain that checks what kind of animal it has. Every new animal means editing the chain. Which idea removes the chain?

A small recap you can run

Here is one small program that uses several of these ideas at once. Shape is an abstract base with shared code; Circle and Square are concrete subclasses; one array typed by the parent drives polymorphic calls; and a static counter, owned by the class instead of any object, counts how many shapes were made. Press Run and step through it.

Main.java

1public class Main {

3 public static void main(String[] args) {

4 Shape[] shapes = new Shape[2];

5 shapes[0] = new Circle(2.0);

6 shapes[1] = new Square(3.0);

8 int i = 0;

9 while (i < shapes.length) {

10 shapes[i].describe();

11 i = i + 1;

12 }

14 System.out.println("shapes made: " + Shape.count);

15 }

16}

18abstract class Shape {

19 static int count = 0;

20 String name;

22 Shape(String name) {

23 this.name = name;

24 count = count + 1;

25 }

27 abstract double area();

29 void describe() {

30 System.out.println(name + " has area " + area());

31 }

32}

34class Circle extends Shape {

35 double radius;

36 Circle(double r) {

37 super("Circle");

38 radius = r;

39 }

40 double area() {

41 return 3.14 * radius * radius;

42 }

43}

45class Square extends Shape {

46 double side;

47 Square(double s) {

48 super("Square");

49 side = s;

50 }

51 double area() {

52 return side * side;

53 }

54}

Prints

›Circle has area 12.56

›Square has area 9.0

›shapes made: 2

Trace what prints. The first shape is a Circle of radius 2.0, so its area is 3.14 * 2.0 * 2.0, which is 12.56: the line reads Circle has area 12.56. The second is a Square of side 3.0, area 9.0: Square has area 9.0. Two shapes were constructed, so the shared static counter reads 2: shapes made: 2. In one short program you can see an abstract base that demands a method, inheritance with super(...), polymorphic calls through an array, and a static member that belongs to the class.

How to keep this map in your head

Remember the problems more than the definitions. Loose related variables led to objects. Exposed data led to encapsulation. Copied code led to inheritance. A pile of if checks on type led to polymorphism. Each keyword exists to solve a problem you can feel, and when you remember the problem, the tool comes back with it.

Try it

Answer each one in your head or on paper first, then open the answer.

In one sentence each, when would you reach for a static nested class, and when for an inner class?

In the BankAccount example, print() says owner and balance with no dot in front. Whose fields are those, and how can the inner class see them?

What is an anonymous class, in one sentence, and what is it commonly used for?

In the button example, the anonymous ClickHandler prints name, a local variable of main. Why is that allowed, and what one-line change to main would stop it compiling?

Name the four big ideas of object-oriented programming, and for each give the problem it solves.

In the runnable recap, why does shapes made: print 2 instead of being stored separately on each shape? Tie your answer to a keyword.

Open in playground

Practice

Work through these on your own. Each one builds on this page.

Take the runnable recap program and extend it. Add a third concrete subclass, Triangle, with fields base and height and an area() of 0.5 * base * height. Add it to the array, run the program, and check that both its area line and the final shapes made: count change as you expect.

Design a Playlist class that contains a nested Song type holding a title and a length in seconds. Decide whether Song should be a static nested class or an inner class, and write one or two sentences justifying the choice. Then write it, make a playlist with three songs, and print the total length.

Rewrite the inner Statement class as a static nested class whose constructor takes the account, so that it is built as new BankAccount.Statement(acc). What has to change inside print(), and why? Run both versions and compare.

Write a single page of notes, in your own words, that walks from “loose related variables” all the way to “interfaces and abstract classes”, naming the problem that pushed you from each idea to the next. Use no Java; this is the map in plain sentences.

Find one anonymous class in real code online (search for “Java anonymous class button listener” or similar). Copy the new Something() { ... } shape into your notes and label, in your own words, which interface or class it implements or extends, which method it overrides, and what behavior it supplies.

Short guides on this topic

Quick answers to what people search for about it, with code to run.

Anonymous Inner Class in Java, with ExamplesAn anonymous inner class is a class with no name, written and used in one expression. How to write one, when it fits, and how it compares with a lambda.8 min

Spotted a mistake, or a part that did not make sense? Report it by email

Inner classes and OOP consolidation

A helper that has no life of its own#

Two kinds, and the one question that separates them#

A static nested class#

An inner class#

Anonymous classes: a one-off class with no name#

Implementing an interface on the spot#

Consolidation: the object ideas so far, in one map#

The foundation: class and object

The four big ideas

The shaping keywords

A small recap you can run

Try it

Practice

Further reading#

Short guides on this topic