Inner Classes

Agenda
1. Introduction.
2. Normal or Regular inner classes
o Accessing inner class code from

static area of outer class

o Accessing inner class code from

instance area of outer class

o Accessing inner class code from

outside of outer class

o The applicable modifiers for outer

& inner classes

o Nesting of Inner classes

3. Method Local inner classes

4. Anonymous inner classes
o Anonymous inner class that extends

a class
o Anonymous Inner Class that

implements an interface
o Anonymous Inner Class that define
 inside method arguments
o Difference between general class

and anonymous inner classes

o Explain the application areas of

anonymous inner classes ?

5. Static nested classes
o Compression between normal or

regular class and static nested

class ?
6. Various possible combinations of nested
class & interfaces
o class inside a class

o interface inside a class

o interface inside a interface

o class inside a interface

7. Conclusions

Introduction
 Sometimes we can declare a class inside
another class such type of classes are
called inner classes.
Diagram:
  Sun people introduced inner classes in
1.1 version as part of "EventHandling"
to resolve GUI bugs.
 But because of powerful features and
benefits of inner classes slowly the
programmers starts using in regular
coding also.
 Without existing one type of object if
there is no chance of existing another
type of object then we should go for
inner classes.
Example:

Without existing University object there is no

chance of existing Department object hence
we have to define Department class inside
University class.

Example1:
Example 2:

Without existing Bank object there is no

chance of existing Account object hence we
have to define Account class inside Bank
class.

Example:

Example 3:
Without existing Map object there is no
chance of existing Entry object hence Entry
interface is define inside Map interface.
Map is a collection of key-value pairs, each
key-value pair is called an Entry.

Example:

Diagram:
Note : Without existing Outer class Object
there is no chance of existing Inner class
Object.
Note: The relationship between outer class
and inner class is not IS-A relationship
and it is Has-A relationship.
Based on the purpose and position of
declaration all inner classes are divided into 4
types.
They are:
1. Normal or Regular inner classes
2. Method Local inner classes
3. Anonymous inner classes
4. Static nested classes.
1. Normal (or) Regular inner class:
If we are declaring any named class inside
another class directly without static modifier
such type of inner classes are called normal
or regular inner classes.

Example:
class Outer
{
class Inner
{
}
}
Output:

Example:
class Outer
{
class Inner
 {
}
public static void main(String[]
args)
{
System.out.println("outer
class main method");
}
}
Output:

 Inside inner class we can't declare static

members. Hence it is not possible to
declare main() method and we can't
invoke inner class directly from the
command prompt.
Example:
class Outer
{
class Inner
{
public static void
main(String[] args)
{

System.out.println("inner class
main method");
}
}
}
Output:
E:\scjp>javac Outer.java
Outer.java:5: inner classes cannot
have static declarations
public static void
main(String[] args)

Accessing inner class code from static area

of outer class:

Example:
class Outer
{
class Inner
{
public void methodOne(){

System.out.println("inner class
method");
}
}
public static void main(String[]
args)
{
 }
}

Accessing inner class code from instance

area of outer class:

Example:
class Outer
{
class Inner
{
public void methodOne()
{

System.out.println("inner class
method");
}
}
public void methodTwo()
{
Inner i=new Inner();
i.methodOne();
}
public static void main(String[]
args)
{
Outer o=new Outer();
o.methodTwo();
}
}
Output:
E:\scjp>javac Outer.java
E:\scjp>java Outer
Inner class method

Accessing inner class code from outside of

outer class:

Example:
class Outer
{
class Inner
{
public void methodOne()
{

System.out.println("inner class
method");
}
}
}
class Test
{
public static void main(String[]
args)
{
new Outer().new
Inner().methodOne();
}
}
Output:
Inner class method

 From inner class we can access all

members of outer class (both static and
non-static, private and non private
methods and variables) directly.
Example:
class Outer
{
int x=10;
static int y=20;
class Inner{
public void methodOne()
{

System.out.println(x);//10
 System.out.println(y);//20
}
}
public static void main(String[]
args)
{
new Outer().new
Inner().methodOne();
}
}

 Within the inner class "this" always

refers current inner class object. To refer
current outer class object we have to use
"outer class name.this".
Example:
class Outer
{
int x=10;
class Inner
{
int x=100;
public void methodOne()
{
int x=1000;

System.out.println(x);//1000

System.out.println(this.x);//100

System.out.println(Outer.this.x);//10
}
}
public static void main(String[]
args)
{
new Outer().new
Inner().methodOne();
}
}

The applicable modifiers for outer

classes are:
1. public
2. default
3. final
4. abstract
5. strictfp
But for the inner classes in addition to this
the following modifiers also allowed.

Diagram:
Nesting of Inner classes :

We can declare an inner class inside another

inner class

Diagram:
Method local inner classes:
 Sometimes we can declare a class inside
a method such type of inner classes are
 called method local inner classes.
 The main objective of method local
inner class is to define method specific
repeatedly required functionality.
 Method Local inner classes are best
suitable to meet nested method
requirement.
 We can access method local inner class
only within the method where we
declared it. That is from outside of the
method we can't access. As the scope of
method local inner classes is very less,
this type of inner classes are most rarely
used type of inner classes.
Example:
class Test
{
public void methodOne()
{
class Inner
{
public void sum(int
i,int j)
{

System.out.println("The sum:"+
(i+j));
}
}
Inner i=new Inner();
i.sum(10,20);
;;;;;;;;;;;;;
 i.sum(100,200);
;;;;;;;;;;;;;;;
i.sum(1000,2000);
;;;;;;;;;;;;;;;;;
}
public static void main(String[]
args)
{
new Test().methodOne();
}
}
Output:
The sum: 30
The sum: 300
The sum: 3000

 If we are declaring inner class inside

instance method then we can access both
static and non static members of outer
class directly.
 But if we are declaring inner class inside
static method then we can access only
static members of outer class directly
and we can't access instance members
directly.
Example:
class Test
{
int x=10;
static int y=20;
public void methodOne()
{
class Inner
{
 public void methodTwo()
{

System.out.println(x);//10

System.out.println(y);//20
}
}
Inner i=new Inner();
i.methodTwo();
}
public static void main(String[]
args)
{
new Test().methodOne();
}
}

 If we declare methodOne() method as

static then we will get compile time
error saying "non-static variable x
cannot be referenced from a static
context".
 From method local inner class we can't
access local variables of the method in
which we declared it. But if that local
variable is declared as final then we
won't get any compile time error.
Example:
class Test
{
int x=10;
public void methodOne()
{
 int y=20;
class Inner
{
public void methodTwo()
{

System.out.println(x);//10

System.out.println(y); //C.E:
local variable y
is
accessed from within inner class;
needs
to be declared final.
}
}
Inner i=new Inner();
i.methodTwo();
}
public static void main(String[]
args)
{
new Test().methodOne();
}
}

 If we declared y as final then we won't

get any compile time error.
 Consider the following declaration.
class Test
{
int i=10;
static int j=20;
public void methodOne()
{
int k=30;
 final int l=40;
class Inner
{
public void methodTwo()
{

System.out.println(i);

System.out.println(j); //-->line
1

System.out.println(k);

System.out.println(l);
}
}
Inner i=new Inner();
i.methodTwo();
}
public static void main(String[]
args)
{
new Test().methodOne();
}
}

At line 1 which of the following variables

we can access ?

If we declare methodOne() method as

static then which variables we can access
at line 1 ?
  If we declare methodTwo() as static then
we will get compile time error because
we can't declare static members inside
inner classes.
 The only applicable modifiers for
method local inner classes are:
1. final
2. abstract
3. strictfp
 By mistake if we are declaring any other
modifier we will get compile time error.
Anonymous inner classes:
 Sometimes we can declare inner class
without name such type of inner classes
are called anonymous inner classes.
 The main objective of anonymous inner
classes is "just for instant use".
 There are 3 types of anonymous inner
classes
1. Anonymous inner class that extends
a class.
2. Anonymous inner class that
implements an interface.
 3. Anonymous inner class that defined
inside method arguments.

Anonymous inner class that extends a

class:
class PopCorn
{
public void taste()
{
System.out.println("spicy");
}
}
class Test
{
public static void main(String[]
args)
{
PopCorn p=new PopCorn()
{
public void taste()
{

System.out.println("salty");
}
};
p.taste();//salty
PopCorn p1=new PopCorn()
p1.taste();//spicy
}
}
Analysis:
1. PopCorn p=new PopCorn();
We are just creating a PopCorn object.
2. PopCorn p=new PopCorn()
 3. {
4. };
5. We are creating child class without
name for the PopCorn class and for that
child class we are creating an object
with Parent PopCorn reference.
6. PopCorn p=new PopCorn()
7. {
8. public void taste()
9. {
10.
System.out.println("salty");
11. }
12. };
13.
1. We are creating child class for PopCorn
without name.
2. We are overriding taste() method.
3. We are creating object for that child
class with parent reference.
Note: Inside Anonymous inner classes we
can take or declare new methods but outside
of anonymous inner classes we can't call
these methods directly because we are
depending on parent reference.[parent
reference can be used to hold child class
object but by using that reference we can't
call child specific methods]. These methods
just for internal purpose only.
Example 1:
class PopCorn
{
public void taste()
{
System.out.println("spicy");
}
}
class Test
{
public static void main(String[]
args)
{
PopCorn p=new PopCorn()
{
public void taste()
{

methodOne();//valid call(internal
purpose)

System.out.println("salty");
}
public void methodOne()
{

System.out.println("child
specific method");
}
};
//p.methodOne();//here we
can not call(outside inner class)
p.taste();//salty
PopCorn p1=new PopCorn();
p1.taste();//spicy
}
}
Output:
Child specific method
Salty
Spicy
Example 2:
class Test
{
public static void main(String[]
args)
{
Thread t=new Thread()
{
public void run()
{
for(int
i=0;i<10;i++)
{

System.out.println("child
thread");
}
}
};
t.start();
for(int i=0;i<10;i++)
{

System.out.println("main
thread");
}
}
}

Anonymous Inner Class that implements

an interface:

Example:
class InnerClassesDemo
{
public static void main(String[]
args)
{
Runnable r=new
Runnable() //here we are not creating
for
Runnable
interface, we are creating
implements
class object.
{
public void run()
{
for(int
i=0;i<10;i++)
{

System.out.println("Child
thread");
}
}
};
Thread t=new Thread(r);
t.start();
for(int i=0;i<10;i++)
{

System.out.println("Main
thread");
}
}
}

Anonymous Inner Class that define inside

method arguments:
Example:
class Test
{
public static void main(String[]
args)
{
new Thread(
new Runnable()
{
public void run()
{
for(int
i=0;i<10;i++)
{

System.out.println("child
thread");
}
}
}).start();
for(int i=0;i<10;i++)
{

System.out.println("main
thread");
}
}
}
Output:

 This output belongs to example 2,

anonymous inner class that implements
an interface example and anonymous
inner class that define inside method
 arguments example.
Main thread
Main thread
Main thread
Main thread
Main thread
Main thread
Main thread
Main thread
Main thread
Main thread
Child thread
Child thread
Child thread
Child thread
Child thread
Child thread
Child thread
Child thread
Child thread
Child thread

Difference between general class and

anonymous inner classes:

General Class Anonymous Inner Class

1) A general class can 1) Ofcource anonymous inner
extends only one class at a class also can extends only one
time. class at a time.
2) A general class can 2) But anonymous inner class
implement any no. Of can implement only one
interfaces at a time. interface at a time.
3) A general class can 3) But anonymous inner class
extends a class and can can extends a class or can
implement an interface implements an interface but not
simultaneously. both simultaneously.
4) In normal Java class we 4) But in anonymous inner class
can write constructor we can't write constructor
because we know name of because anonymous inner class
the class. not having any name.
Explain the application areas of
anonymous inner classes ?
anonymous inner classes are best suitable to
define call back functions in GUI
components
import java.awt.*;
import java.awt.event.*;

public class AnonymousInnerClassDemo {

public static void main(String
args[]) {
Frame f=new Frame();

f.addWindowListener(new
WindowAdaptor(){
public void
windowClosing(WindowEvent e) {
System.exit(0);
}
});

f.add(new Label("Anonymous Inner

class Demo !!!"));
f.setSize(500,500);
 f.setVisible(true);
}
}

Without Anonumous Inner class :

class GUI extends JFrame implements

ActionListener {
JButton b1,b2,b3,b4;
-----------------
public void
actionPerformed(ActionEvent e) {
if(e.getSource()==b1) {
//perform b1 specific
functionality
}
else if(e.getSource==b2){
//perform b2 specific
functionality
}

---------------------

}
----------------

With Anonumous Inner class :

class GUI extends JFrame {

JButton b1,b2,b3,b4 ;
--------------------
 b1.addActionListener(new
ActionListener() {
public void
actionPerformed(ActionEvent e) {
//perform b1 specific functionality
}
});

b2.addActionListener(new
ActionListener() {
public void
actionPerformed(ActionEvent e) {
//perform b2 specific functionality
}
});

---------
}

Static nested classes:

 Sometimes we can declare inner classes
with static modifier such type of inner
classes are called static nested classes.
 In the case of normal or regular inner
classes without existing outer class
object there is no chance of existing
inner class object.
i.e., inner class object is always strongly
associated with outer class object.
  But in the case of static nested class
without existing outer class object there
may be a chance of existing static nested
class object.
i.e., static nested class object is not
strongly associated with outer class
object.
Example:
class Test
{
static class Nested
{
public void methodOne()
{

System.out.println("nested class
method");
}
}
public static void main(String[]
args)
{
Test.Nested t=new
Test.Nested();
t.methodOne();
}
}

 Inside static nested classes we can

declare static members including main()
method also. Hence it is possible to
invoke static nested class directly from
 the command prompt.
Example:
class Test
{
static class Nested
{
public static void
main(String[] args)
{

System.out.println("nested class
main method");
}
}
public static void main(String[]
args)
{
System.out.println("outer
class main method");
}
}
Output:
E:\SCJP>javac Test.java
E:\SCJP>java Test
Outer class main method
E:\SCJP>java Test$Nested
Nested class main method

 From the normal inner class we can

access both static and non static
members of outer class but from static
nested class we can access only static
members of outer class.
Example:
class Test
{
int x=10;
static int y=20;
static class Nested
{
public void methodOne()
{

System.out.println(x);//C.E:non-
static variable x
cannot
be referenced from a static context
System.out.println(y);
}
}
}

Compression between normal or

regular class and static nested class ?
Normal /regular inner class Static nested class
1) Without existing outer 1) Without existing outer class
class object there is no object there may be a chance
chance of existing inner class of existing static nested class
object. That is inner class object. That is static nested
object is always associated class object is not associated
with outer class object. with outer class object.
2) Inside normal or regular
2) Inside static nested class we
inner class we can't declare
can declare static members.
static members.
3) Inside normal inner class 3) Inside static nested class we
we can't declare main()
can declare main() method and
method and hence we can't
hence we can invoke static
invoke regular inner class
nested class directly from the
directly from the command
command prompt.
prompt.
4) From the normal or
regular inner class we can 4) From static nested class we
access both static and non can access only static members
static members of outer class of outer class directly.
directly.

Various possible combinations of nested

class & interfaces :
1. class inside a class :
 We can declare a class inside another
class
 Without existing one type of object, if
there is no chance of existing another
type of object, then we should go for
clas inside a class
class University {
class Department {
}
}
Without existing University object, there is
no chance of existing Department object. i.e.,
Department object is always associated with
University
2. interface inside a class :
We can declare interface inside a class
class X {
interface Y {
}
}
Inside class if we required multiple
implements of an interface and these
implementations of relevant to a perticular
class, then we should declare interface inside
a class.
class VehicleType {
interface Vehicle {
public int getNoOfWheels();
}

class Bus implements Vehicle {

public int getNoOfWheels() {
return 6;
}
}

class Auto implements Vehicle {

public int getNoOfWheels() {
return 3;
}
}

}
3. interface inside a interface :
We can declare an interface inside another
interface.
interface Map {
interface Entry {
public Object getKey();
public Object getValue();
public Object getValue(Object
new );
}
}
Nested interfaces are always public,static
whether we are declaring or not. Hence we
can implements inner inteface directly with
out implementing outer interface.
interface Outer {
public void methodOne();
interface Inner {
public void methodTwo();
}
}

class Test implements Outer.Inner {

public void methodTwo() {
System.out.println("Inner interface
method");
}
public static void main(String
args[]) {
Test t=new Test();
t.methodTwo();
}
}
Whenever we are implementing Outer
interface , it is not required to implement
Inner interfaces.
class Test implements Outer {
public void methodOne() {
System.out.println("Outer interface
method ");
}
public static void main(String
args[]) {
Test t=new Test();
t.methodOne();
}

}
i.e., Both Outer and Inner interfaces we can
implement independently.
4. class inside a interface :
We can declare a class inside interface. If a
class functionality is closely associated with
the use interface then it is highly
recommended to declare class inside
interface
Example:

interface EmailServer {
public void sendEmail(EmailDetails
e);

class EmailDetails {
String from;
String to;
String subject;
 }
}
In the above example Emaildetails
functionality is required for EmailService and
we are not using anyware else . Hence we
can declare EmailDetails class inside
EmailService interface .

We can also declare a class inside interface to

provide default implementation for that
interface.
Example :

interface Vehicle {
public int getNoOfWheels();

class DefaultVehicle implements

Vehicle {
public int getNoOfWheels() {
return 3;
}
}
}

class Bus implements Vehicle {

public int getNoOfWheels() {
return 6;
}
}

class Test {
public static void main(String
args[]) {
Bus b=new Bus();
System.out.println(b.getNoOfWheels());

Vehicle.DefaultVehicle d=new
Vehicle.DefaultVehicle();

System.out.println(d.getNoOfWheels());
}
}
In the above example DefaultVehicle in the
default implementation of Vehicle interface
where as Bus customized implementation of
Vehicle interface.
The class which is declared inside interface is
always static ,hence we can create object
directly without having outer interface type
object.
Conclusions :
1. We can declare anything inside any
thing with respect to classes and
interfaces.

2. Nesting interfaces are always public,

static whether we are declaring or not.
3. class which is declared inside interface
is always public,static whether we are
 declaring or not.

BACK