What Is Inner Class In Java In Simple Mean – Advantages and Use

In this tutorial, we will talk about What Is Inner Class In Java. This is a continuation of the previous topic, entitled Exceptions In Java.

A Inner Class In Java, also called a nested class, is a class that is declared within another class or interface.

In addition, the inner classes can access the private members of the outer classes.

What Is Inner Class In Java?

The Inner Classes In Java are those that are defined inside of other classes or interfaces that were primarily introduced. Since Java is entirely object-oriented, inner classes help to make the language more realistic.

Use Of Inner Class In Java?

A Java Inner Class or nested class is a class that is declared inside the class or interface.

We use inner classes to put classes and interfaces together in a way that makes them easier to read and maintain. Also, it can access all the members of the outer class, including private data members and methods.

What Are The Advantages Of Java Inner Classes?

The following listed below are 3 advantages of Java inner class.

  • Keeping code clean and easy to read.
  • Accessing the private methods of the outer class adds a new dimension and brings it closer to the real world.
  • Improving the code module.

Static Inner Class In Java

A Static Inner Class In Java is a class that is created inside another class. It can’t access data members and methods that aren’t static. It can be accessed by using the outer class name.

  • It can access both public and private static data members of the outer class.
  • The static nested class can’t access (instance) data members that are not static.

What is the difference between inner class and anonymous class in Java?

A local inner class is a class that is declared inside of a method. An anonymous class, on the other hand, is declared when an instance is made. So the anonymous class is made as the program runs.

How Do Inner Classes Work In Java?

A Java inner class is defined inside the body of another class. An inner class in Java can be declared private, public, protected, or with default access, but an outer class can only be public or have default access. In Java, there are two kinds of classes that are nested inside other classes.

What Is Meant By An Inner Class?

A class that is declared entirely inside the body of another class or interface is called an inner class or nested class. It’s not the same as a subclass.

What Is Purpose Of Inner Class?

The purpose of Inner class In Java are a way for Java to keep things safe. We know that the access modifier private can’t be attached to a class, but if the class is a member of another class, the inner class can be made private. And this is also how you get to a class’s private members.

Without further ado, I will further explain on What Is Inner Class In Java with some basic examples in order for you to easily understand the topic.

What Are The 4 Types Of Inner Classes In Java

The following listed below are the 4 types of inner classes in Java.

  • Nested inner class
  • Method local inner classes
  • Static nested classes
  • Anonymous inner classes

Let’s talk about each of the above types in detail along with a clean Java program, which is important at every step because it gets harder as we go.

Nested Inner Class In Java

The Nested Inner Class In Java is part of the class that contains it. Even if they are marked as private, non-static inner classes can access other members of the outer class. Static nested classes can’t access other members of the class that contains them.

It can get to any private instance variable of the outer class. Like any other instance variable, we can set the access modifier to private, protected, public, or default. Like a class, an interface can also be nested and can have access specifiers.

Example

// program created by Glenn
// 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("Sample program In a nested class method");
		}
	}
}

// Class 2
// Main class
public 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();
	}
}

Output

Sample program In a nested class method

In order for you to test your Java code provided in this lesson, you must test the code in your code editor. But if you wish to run this code online, we also have an online compiler in Java for you to test your java code for free.

We also provide a Java Online Compiler for every code below. Just scroll down so that you can easily test or execute the source code.

Note : We can’t have a static method in a nested inner class because an inner class is implicitly connected to an object of its outer class, so it can’t define any static methods for itself. For example, the following program does not compile.

Example

// program by Glenn
// 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("Sample inside outerMethod");
	}

	// Class 2
	// Inner class
 public class Inner {

		// Main driver method
		public static void main(String[] args)
		{

			// Display message for better readability
			System.out.println("Sample inside inner class Method");
		}
	}
}

Output

Error: Could not find or load main class Inner
Caused by: java.lang.ClassNotFoundException: Inner

Method Local Inner Class In Java

The Method Local Inner Class In Java can only be used inside the method where they are defined.

An inner class can be declared inside a method of an outer class, as shown in the example below, where Inner is an inner class inside outerMethod ().

Example

// program created by Glenn
// 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("sample 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("sample inside innerMethod");
			}
		}

		// Creating object of inner class
		Inner y = new Inner();

		// Calling over method defined inside it
		y.innerMethod();
	}
}

// Class 3
// Main class
public class PIES {

	// 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();
	}
}

Output

sample inside outerMethod
sample inside innerMethod

Method Local inner classes can’t use a local variable of the outer method until that local variable isn’t declared as final. For instance, the code below causes a compiler error.

Note : “x” is not final in outerMethod(), but it is tried to be accessed by innerMethod().

Example

class Outer {
void outerMethod() {
	int x = 100;
	System.out.println("inside outerMethod");
	class Inner {
		void innerMethod() {
			System.out.println("x = "+x);
		}
	}
	Inner y = new Inner();
	y.innerMethod();
}
}
public class MethodLocalVariableDemo {
public static void main(String[] args) {
	Outer x=new Outer();
	x.outerMethod();
}
}

Output

sample inside outerMethod
x = 100

But the code below compiles and runs correctly (Note that x is final this time).

Example

// program created by Glenn
class Outer {
void outerMethod() {
	final int x=100;
	System.out.println("sample inside outerMethod");
	class Inner {
		void innerMethod() {
			System.out.println("x = "+x);
		}
	}
	Inner y = new Inner();
	y.innerMethod();
}
}
public class MethodLocalVariableDemo {
	public static void main(String[] args){
	Outer x = new Outer();
	x.outerMethod();
	}
}

Output

sample inside outerMethod
x = 100

The main reason we need to declare a local variable as final is that it lives on the stack until the method is on the stack. However, the object of the inner class might still live on the heap.

Methods in inner classes can’t be marked as private, protected, static, or transient. However, they can be marked as abstract or final, but not both at the same time.

Static Nested Classes In Java

In Java, a static nested class is a class that is created inside of another class. It can’t get to data members and methods that are not static.

You can get to it by using the outer class name. It can get to private static data members of the outer class.

In addition, Static nested classes are not technically inner classes. They are like a static member of the outer class.

Example

// program created by Glenn
// 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("sample inside outerMethod");
	}

	// Class 2
	// Static inner class
	static class Inner {

		public static void display()
		{

			// Print statement
			System.out.println("sample inside inner class Method");

			// Calling method inside main() method
			outerMethod();
		}
	}
}

// Class 3
// Main class
public class PIES {

	// Main driver method
	public static void main(String args[])
	{

		Outer.Inner obj = new Outer.Inner();

		// Calling method via above instance created
		obj.display();
	}
}

Output

sample inside inner class Method
sample inside outerMethod

Anonymous Inner Classes In Java

The Anonymous Inner Class In Java is a nested class that doesn’t have a name. A class with no name must be set up inside of another class. So, this type of class is also called an anonymous inner class.

Anonymous inner classes are those that are declared without a name. They are made in two different ways.

  • As a subclass of the type that was specified,
  • As an implementer of the given interface,

The syntax of an anonymous class expression is the same as calling a constructor, except that the class definition is in a block of code.

Syntax

// sample created by Glenn
// Test can be interface,abstract/concrete class
Test t = new Test(){
// data members and methods
public void test_method(){
……..
……..
}
};

Example

// 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 Glenn I will show method of super class");
	}
}

// Class 2
// Main class
public class PIES {

	// 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'm a Writer and Computer programmer");
		}
	};

	// Method 2
	// Main driver method
	public static void main(String[] args)
	{
		// Calling show() method inside main() method
		d.show();
	}
}

Output

i am Glenn I will show method of super class
I’m a Writer and Computer programmer

Output Explanation

In the code above, we create an object of an inner class that isn’t named, but it implements the interface named Hello.

One interface alone may be implemented at a time by any anonymous inner class. At any one time, it can either implement an interface or extend a class.

Summary

In summary, you have learned about What Is Inner Class In Java. This tutorial has covered the following topics: Use Of Inner Class, Use Of Inner Class, Advantages Of Java Inner Classes, Static Inner Class, difference between inner class and anonymous class, How Do Inner Classes Work, Purpose Of Inner Class and 4 Types Of Inner Classes. I use NetBeans IDE to test all the source code given in the lesson.

I hope this lesson has helped you learn What Is Inner Class In Java.


Leave a Comment