In Java, inner class refers to the class that is declared inside class or interface which were mainly introduced, to sum up, same logically relatable classes as Java is object-oriented so bringing it closer to the real world. Now geeks you must be wondering why they were introduced?
There are certain advantages associated with inner classes are as follows:
- Making code clean and readable.
- Private methods of the outer class can be accessed, so bringing a new dimension and making it closer to the real world.
- Optimizing the code module.
We do use them often as we go advance in java object-oriented programming where we want certain operations to be performed, granting access to limited classes and many more which will be clear as we do discuss and implement all types of inner classes in Java.
Types of Inner Classes
There are basically four types of inner classes in java.
- Nested Inner Class
- Method Local Inner Classes
- Static Nested Classes
- Anonymous Inner Classes
Let us discuss each of the above following types sequentially in-depth alongside a clean java program which is very crucial at every step as it becomes quite tricky as we adhere forwards.
Type 1: Nested Inner Class
It can access any private instance variable of the outer class. Like any other instance variable, we can have access modifier private, protected, public, and default modifier. Like class, an interface can also be nested and can have access specifiers.
Example 1A
Java
// Java Program to Demonstrate Nested classÂ
// Class 1
// Helper classes
class Outer {
// Class 2
// Simple nested inner class
class Inner {
// show() method of inner class
public void show()
{
// Print statement
System.out.println("In a nested class method");
}
}
}
// Class 2
// Main class
class Main {
// Main driver method
public static void main(String[] args)
{
// Note how inner class object is created inside
// main()
Outer.Inner in = new Outer().new Inner();
// Calling show() method over above object created
in.show();
}
}
OutputIn a nested class method
Note: We can not have a static method in a nested inner class because an inner class is implicitly associated with an object of its outer class so it cannot define any static method for itself. For example, the following program doesn’t compile. But Since JAVA Version 16 we can have static members in our inner class also.
Example 1B
Java
// Java Program to Demonstrate Nested classÂ
// Where Error is thrown
// Class 1
// Outer class
class Outer {
// Method defined inside outer class
void outerMethod()
{
// Print statement
System.out.println("inside outerMethod");
}
// Class 2
// Inner class
class Inner {
// Main driver method
public static void main(String[] args)
{
// Display message for better readability
System.out.println("inside inner class Method");
}
}
}
Output:

An interface can also be nested and nested interfaces have some interesting properties. We will be covering nested interfaces in the next post.
Type 2: Method Local Inner Classes
Inner class can be declared within a method of an outer class which we will be illustrating in the below example where Inner is an inner class in outerMethod().
Example 1
Java
// Java Program to Illustrate Inner class can be
// declared within a method of outer class
// Class 1
// Outer class
class Outer {
// Method inside outer class
void outerMethod()
{
// Print statement
System.out.println("inside outerMethod");
// Class 2
// Inner class
// It is local to outerMethod()
class Inner {
// Method defined inside inner class
void innerMethod()
{
// Print statement whenever inner class is
// called
System.out.println("inside innerMethod");
}
}
// Creating object of inner class
Inner y = new Inner();
// Calling over method defined inside it
y.innerMethod();
}
}
// Class 3
// Main class
class GFG {
// Main driver method
public static void main(String[] args)
{
// Creating object of outer class inside main()
// method
Outer x = new Outer();
// Calling over the same method
// as we did for inner class above
x.outerMethod();
}
}
Outputinside outerMethod
inside innerMethod
Method Local inner classes can’t use a local variable of the outer method until that local variable is not declared as final. For example, the following code generates a compiler error.
Note: “x” is not final in outerMethod() and innerMethod() tries to access it.
Example 2
Java
class Outer {
void outerMethod() {
int x = 98;
System.out.println("inside outerMethod");
class Inner {
void innerMethod() {
System.out.println("x= "+x);
}
}
Inner y = new Inner();
y.innerMethod();
}
}
class MethodLocalVariableDemo {
public static void main(String[] args) {
Outer x=new Outer();
x.outerMethod();
}
}
Outputinside outerMethod
x= 98
Note: Local inner class cannot access non-final local variable till JDK 1.7. Since JDK 1.8, it is possible to access the non-final local variable in method local inner class.
But the following code compiles and runs fine (Note that x is final this time)
Example 3
Java
class Outer {
void outerMethod() {
final int x=98;
System.out.println("inside outerMethod");
class Inner {
void innerMethod() {
System.out.println("x = "+x);
}
}
Inner y = new Inner();
y.innerMethod();
}
}
class MethodLocalVariableDemo {
public static void main(String[] args){
Outer x = new Outer();
x.outerMethod();
}
}
Outputinside outerMethod
x = 98
The main reason we need to declare a local variable as a final is that the local variable lives on the stack till the method is on the stack but there might be a case the object of the inner class still lives on the heap.
Method local inner class can’t be marked as private, protected, static, and transient but can be marked as abstract and final, but not both at the same time.
Type 3: Static Nested Classes
Static nested classes are not technically inner classes. They are like a static member of outer class.
Example
Java
// Java Program to Illustrate Static Nested Classes
// Importing required classes
import java.util.*;
// Class 1
// Outer class
class Outer {
// Method
private static void outerMethod()
{
// Print statement
System.out.println("inside outerMethod");
}
// Class 2
// Static inner class
static class Inner {
public static void display()
{
// Print statement
System.out.println("inside inner class Method");
// Calling method inside main() method
outerMethod();
}
}
}
// Class 3
// Main class
class GFG {
// Main driver method
public static void main(String args[])
{
// Calling method static display method rather than an instance of that class.
Outer.Inner.display();
}
}
Outputinside inner class Method
inside outerMethod
Type 4: Anonymous Inner Classes
Anonymous inner classes are declared without any name at all. They are created in two ways.
- As a subclass of the specified type
- As an implementer of the specified interface
Way 1: As a subclass of the specified type
Example:
Java
// Java Program to Illustrate Anonymous Inner classes
// Declaration Without any Name
// As a subclass of the specified type
// Importing required classes
import java.util.*;
// Class 1
// Helper class
class Demo {
// Method of helper class
void show()
{
// Print statement
System.out.println(
"i am in show method of super class");
}
}
// Class 2
// Main class
class Flavor1Demo {
// An anonymous class with Demo as base class
static Demo d = new Demo() {
// Method 1
// show() method
void show()
{
// Calling method show() via super keyword
// which refers to parent class
super.show();
// Print statement
System.out.println("i am in Flavor1Demo class");
}
};
// Method 2
// Main driver method
public static void main(String[] args)
{
// Calling show() method inside main() method
d.show();
}
}
Outputi am in show method of super class
i am in Flavor1Demo class
In the above code, we have two classes Demo and Flavor1Demo. Here demo act as a super-class and the anonymous class acts as a subclass, both classes have a method show(). In anonymous class show() method is overridden.
Way 2: As an implementer of the specified interface
Example:
Java
// Java Program to Illustrate Anonymous Inner Classes
// Declaration Without Any Name
// As an implementer of Specified interface
// Interface
interface Hello {
// Method defined inside interface
void show();
}
// Main class
class GFG {
// Class implementing interface
static Hello h = new Hello() {
// Method 1
// show() method inside main class
public void show()
{
// Print statement
System.out.println("i am in anonymous class");
}
};
// Method 2
// Main driver method
public static void main(String[] args)
{
// Calling show() method inside main() method
h.show();
}
}
Outputi am in anonymous class
Output explanation:
In the above code, we create an object of anonymous inner class but this anonymous inner class is an implementer of the interface Hello. Any anonymous inner class can implement only one interface at one time. It can either extend a class or implement an interface at a time.
Explanation
In Java, an inner class is a class that is defined inside another class. An inner class can access the members of the outer class, including private members, and it can be used to implement callbacks and event handlers. There are four types of inner classes in Java:
Member Inner Class: It is a non-static class that is defined at the member level of a class. It has access to all the members of the outer class, including private members.
Local Inner Class: It is a class that is defined inside a method or a block of code. It has access to the final variables of the method or block in which it is defined.
Anonymous Inner Class: It is a class that is defined inline and has no name. It is used to implement interfaces or extend classes without creating a separate class.
Static Nested Class: It is a static class that is defined inside another class. It does not have access to the non-static members of the outer class.
Inner classes have several advantages:
Encapsulation: Inner classes can be used to encapsulate implementation details of a class, making the code more modular and maintainable.
Access Control: Inner classes can access private members of the outer class, allowing for more precise control over the visibility of members.
Callbacks and Event Handlers: Inner classes can be used to implement callbacks and event handlers, making it easier to handle events in graphical user interfaces.
Code Organization: Inner classes can be used to organize code by grouping related classes together.
Program
Java
public class OuterClass {
private int outerVar;
public OuterClass(int var) {
outerVar = var;
}
public void outerMethod() {
System.out.println("This is an outer method");
}
// Inner class
public class InnerClass {
private int innerVar;
public InnerClass(int var) {
innerVar = var;
}
public void innerMethod() {
System.out.println("This is an inner method");
}
public void accessOuterVar() {
System.out.println("Outer variable from inner class: " + outerVar);
}
}
public static void main(String[] args) {
// Create an instance of the outer class
OuterClass outer = new OuterClass(10);
// Create an instance of the inner class
OuterClass.InnerClass inner = outer.new InnerClass(20);
// Access the inner class methods
inner.innerMethod();
inner.accessOuterVar();
}
}
OutputThis is an inner method
Outer variable from inner class: 10
In this example, we have an outer class OuterClass that has an inner class InnerClass. The inner class has its own methods and variables, and it can also access the outer class’s methods and variables.
To create an instance of the inner class, we first create an instance of the outer class, and then use it to create the inner class. We can then access the inner class’s methods and also the outer class’s methods and variables using the inner class’s instance.
The benefits of using inner classes in Java are:
Encapsulation: Inner classes can access private variables and methods of the outer class. This helps to achieve encapsulation and improves code readability.
Code Organization: Inner classes allow you to group related code together in one place. This makes your code easier to understand and maintain.
Better Access Control: Inner classes can be declared as private, which means that they can only be accessed within the outer class. This provides better access control and improves code security.
Callbacks: Inner classes are often used for implementing callbacks in event-driven programming. They provide a convenient way to define and implement a callback function within the context of the outer class.
Polymorphism: Inner classes can be used to implement polymorphism. You can define a class hierarchy within the outer class and then create objects of the inner classes that implement the different subclasses.
Reduced Code Complexity: Inner classes can reduce the complexity of your code by encapsulating complex logic and data structures within the context of the outer class.
Overall, the use of inner classes can lead to more modular, maintainable, and flexible code.
Similar Reads
Classes and Objects in Java
In Java, classes and objects are basic concepts of Object Oriented Programming (OOPs) that are used to represent real-world concepts and entities. The class represents a group of objects having similar properties and behavior, or in other words, we can say that a class is a blueprint for objects, wh
12 min read
Understanding Classes and Objects in Java
The term Object-Oriented explains the concept of organizing the software as a combination of different types of objects that incorporate both data and behavior. Hence, Object-oriented programming(OOPs) is a programming model, that simplifies software development and maintenance by providing some rul
10 min read
Inner Class in Java
In Java, inner class refers to the class that is declared inside class or interface which were mainly introduced, to sum up, same logically relatable classes as Java is object-oriented so bringing it closer to the real world. Now geeks you must be wondering why they were introduced? There are certai
11 min read
Anonymous Inner Class in Java
Nested Classes in Java is prerequisite required before adhering forward to grasp about anonymous Inner class. It is an inner class without a name and for which only a single object is created. An anonymous inner class can be useful when making an instance of an object with certain "extras" such as o
7 min read
Nested Classes in Java
In Java, it is possible to define a class within another class, such classes are known as nested classes. They enable you to logically group classes that are only used in one place, thus this increases the use of encapsulation and creates more readable and maintainable code. The scope of a nested cl
5 min read
Java.util.Objects class in Java
Java 7 has come up with a new class Objects that have 9 static utility methods for operating on objects. These utilities include null-safe methods for computing the hash code of an object, returning a string for an object, and comparing two objects. Using Objects class methods, one can smartly handl
7 min read
Different Ways to Create Objects in Java
Java is an object-oriented programming language where objects are instances of classes. Creating objects is one of the most fundamental concepts in Java. In Java, a class provides a blueprint for creating objects. Most of the time, we use the new keyword to create objects but Java also offers severa
5 min read
How are Java Objects Stored in Memory?
In Java, all objects are dynamically stored in the Heap memory while references to those objects are stored in the stack. Objects are created with the help of "new" keyword and are allocated in the heap memory. However, declaring a variable of a class type does not create an object it only creates r
5 min read
Passing and Returning Objects in Java
Although Java is strictly passed by value, the precise effect differs between whether a primitive type or a reference type is passed. When we pass a primitive type to a method, it is passed by value. But when we pass an object to a method, the situation changes dramatically, because objects are pass
6 min read
Java Lambda Expressions
Lambda expressions in Java, introduced in Java SE 8. It represents the instances of functional interfaces (interfaces with a single abstract method). They provide a concise way to express instances of single-method interfaces using a block of code. Key Functionalities of Lambda ExpressionLambda Expr
6 min read