Inner class and its 4 types with example
When a class defined inside another class known as inner class.
public class OuterClass {
class InnerClass {
}
}
When to use Inner Classes?
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, University consists of several colleges, without existing University there is no chance of colleges hence we have to declare college class inside University class.
// Outer Class
public class University {
// Inner Class
class College {
}
}
See another example.
Map is group of key value pair and each key value pair is called Entry. Without existing Map object there is no chance of Entry object, hence Interface Entry is defined inside Map Interface.
// Outer Interface
public interface Map<K, V> {
// Inner Interface
interface Entry<K, V> {
}
}
Without existing outer class, there is no chance of existing inner class object.
Outer and inner class is Has-A Relationship. (Composition or Aggregation)
There are four types of inner classes in Java.
- Regular or Nested inner class
- Method Local inner class
- Anonymous inner class
- Static nested class
1. Regular or Nested inner class
If there is any named class directly inside another class, without static modifier such types of inner classes called Regular or Nested inner class.
// Outer Class
public class OuterClass {
// Inner Class
class InnerClass {
}
}
When we compile OuterClass.java it creates two class file named
- OuterClass.class
- OuterClass$InnerClass.class
Inside inner class we can not declare any Static members.
Note : In Regular inner classes, without an outer class object existing, there can not be any inner class object.
Learn how to call inner class methods:
How we can access inner class members? | How to access inner class code from static area of outer class?
- First we have to create outer class object.
- After create inner class object using outer object reference. lets see example for better understanding.
Example 1 : Calling inner class method from outer class
class OuterClass {
class InnerClass {
public void innerClassMethod() {
System.out.println("Inner class");
}
}
public static void main(String[] args) {
OuterClass obj1 = new OuterClass();
OuterClass.InnerClass obj2 = obj1.new InnerClass();
obj2.innerClassMethod();
}
}
Output :
Inner class
We can also create inner class object in 1 line.
new OuterClass().new InnerClass().innerClassMethod();
2. Method Local inner class
When any class declared inside method, it is called as Method local inner class.
What is need of method local inner class?
The main purpose of method local inner class is to define method specific repeatedly required functionality.
Method local inner class are best suitable to meet nested method requirement.
We can access method local inner classes only within a method where we declared, outside of method we can not access. because of less scope method local inner class are rarely used.
Example 2 : Method local inner class
public class MethodLocalInnerClass {
public void outerMethod() {
class Inner {
public void multiply(int a, int b) {
System.out.println("Multiplication is : "+ a*b);
}
}
Inner obj = new Inner();
// Call multiply method repeatedly
obj.multiply(2, 2);
obj.multiply(4, 4);
obj.multiply(5, 2);
obj.multiply(6, 3);
}
public static void main(String[] args) {
MethodLocalInnerClass obj = new MethodLocalInnerClass();
obj.outerMethod();
}
}
Output :
Multiplication is : 4
Multiplication is : 16
Multiplication is : 10
Multiplication is : 18
We can declare method local inner class inside both instance and static method.
- If we declare inner class inside instance method then from method local inner class we can access both static and non static members of outer class directly.
- If we declare inner class inside static method then we can access only static members of outer class directly from that method local inner class.
Lets see example.
Example 3 : Accessing static and non static members of outer class from instance method inside method local inner class
public class MethodLocalInnerClass {
int a = 10;
static int b = 20;
public void outerMethod() {
class Inner {
public void innerClassMethod() {
System.out.println(a);
System.out.println(b);
}
}
Inner obj = new Inner();
obj.innerClassMethod();
}
public static void main(String[] args) {
MethodLocalInnerClass obj = new MethodLocalInnerClass();
obj.outerMethod();
}
}
Output :
10
20
So you can see we can directly access both static and non static members from instance method, but if we declare outerMethod() as static then we get following compile time error. because a variable is non static and outerMethod() is static.
Unresolved compilation problem:
Cannot make a static reference to the non-static field a
From method local inner class, we can not access local variables of methods in which we declare inner class.
If local variable declare as final then we can access.
Points to remember :
- We can not declare static method inside local method inner class. (As in above code we can not declare innerClassMethod() as static).
3. Anonymous inner class
When any inner class is declare without name, it is called as Anonymous inner class.
In simple term, Anonymous inner class means name less inner class.
The main purpose of Anonymous inner class is just for instant use or one time use.
Based on declaration and behavior there are 3 types of inner classes.
- Anonymous inner class that extends a class
- Anonymous inner class that implements interface
- Anonymous inner class that defined inside arguments
Learn more about Anonymous inner class in details :
4. Static nested class
When any inner class declared with static modifier, such types of inner classes are called static nested classes.
In normal or regular inner class, without existing outer class object there is no chance of existing inner class object. So there is inner class is strongly associate with outer class object.
But in static nested class, without existing outer class object there may be chance of existing nested class object. hence, static nested class object is not strongly associated with outer class object. Lets see simple example for better understanding.
Example 4 : Static nested class example (access static class inside outer class)
class Outer {
static class StaticNested {
public void method() {
System.out.println("Static nested class");
}
}
public static void main(String[] args) {
StaticNested obj = new StaticNested();
obj.method();
}
}
Output :
Static nested class
If we want to access static class outside of outer class then we have to write something like this :
Outer.StaticNested = new Outer.StaticNested();
In regular inner class, we can not declare static members but in static nested class we can declare static members including main method.
Happy Learning... Happy Coding...
Other articles :
Comments
Post a Comment