coderz.py

It is possible to define a class within another class in Java, and these classes are referred to as nested classes. They allow you to logically group classes that are only used in one place, increasing encapsulation and making code more readable and maintainable.

Syntax:

class OuterClass
{
...
    class NestedClass
    {
        ...
    }
}

Note:

• The scope of the enclosing class limits a nested class’s scope. As a result, class NestedClass does not exist independently of class OuterClass in the example above.
• A nested class has access to the members of the class in which it is nested, including private members. The enclosing class can also access the members of the nested class and vice versa.
• The enclosing class is also a member of the nested class.
• A nested class can be declared private, public, protected, or package-private as a member of its enclosing class (default).

Need of Java Nested class:

Users may need to program a class in such a way that it cannot be accessed by any other class. As a result, it would be preferable if you included it in other classes.

It is easier to nest that class inside the outer class if all the class objects are part of the outer object. The outer class can then access all the inner class’s objects.

Types of Nested class:

The following are the two types of nested classes:

• nested static class: Static nested classes are nested classes that are declared static.
• inner class: A non-static nested class is an inner class.

Static Nested Class:

• A static class, also known as a static nested class in Java, is a class that is created inside another class.
• It is unable to access data members and methods that are not static.
• It can be found by looking up the name of the outer class.
• Furthermore, it has access to the outer class’s static data members, including private.
• The non-static (instance) data members or the non-static (nested) class cannot be accessed by the static nested class.

Accessing:

OuterClass.StaticNestedClass

Example:

// Java program to demonstrate accessing
// a static nested class

// outer class
class OuterClass
{
 // static member
 static int outer_x = 10;
 
 // instance(non-static) member
 int outer_y = 20;
 
 // private member
 private static int outer_private = 30;
 
 // static nested class
 static class StaticNestedClass
 {
  void display()
  {
   // can access static member of outer class
   System.out.println("outer_x = " + outer_x);
   
   
   System.out.println("outer_private = " + outer_private);
   
   // The following statement will give compilation error
   // as static nested class cannot directly access non-static members
   // System.out.println("outer_y = " + outer_y);
  
  }
 }
}

// Driver class
public class StaticNestedClassDemo
{
 public static void main(String[] args)
 {
  // accessing a static nested class
  OuterClass.StaticNestedClass nestedObject = new OuterClass.StaticNestedClass();
  
  nestedObject.display();
  
 }
}

Output:

outer_x = 10
outer_private = 30

Inner Class:

To instantiate an inner class, you must first instantiate the outer class. Then, create the inner object within the outer object with this syntax:

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

There are two special kinds of inner classes :

• Local inner classes

• Anonymous inner classes

Example: inner class

class i.e., created inside a method, is called local inner class in java.

// Java program to demonstrate accessing
// a inner class

// outer class
class OuterClass
{
 // static member
 static int outer_x = 10;
 
 // instance(non-static) member
 int outer_y = 20;
 
 // private member
 private int outer_private = 30;
 
 // inner class
 class InnerClass
 {
  void display()
  {
   // can access static member of outer class
   System.out.println("outer_x = " + outer_x);
   
   // can also access non-static member of outer class
   System.out.println("outer_y = " + outer_y);
   
   // can also access a private member of the outer class
   System.out.println("outer_private = " + outer_private);
  
  }
 }
}

// Driver class
public class InnerClassDemo
{
 public static void main(String[] args)
 {
  // accessing an inner class
  OuterClass outerObject = new OuterClass();
  OuterClass.InnerClass innerObject = outerObject.new InnerClass();
  
  innerObject.display();
  
 }
}

Output:

outer_x = 10
outer_y = 20
outer_private = 30

Example: Anonymous class

A class without any name is called an Anonymous class.

// Java program to demonstrate Need for
// Anonymous Inner class

// Interface
interface Age {

 // Defining variables and methods
 int x = 21;
 void getAge();
}

// Class 1
// Helper class implementing methods of Age Interface
class MyClass implements Age {

 // Overriding getAge() method
 @Override public void getAge()
 {
  // Print statement
  System.out.print("Age is " + x);
 }
}

// Class 2
// Main class
// AnonymousDemo
class GFG {
 // Main driver method
 public static void main(String[] args)
 {
  // Class 1 is implementation class of Age interface
  MyClass obj = new MyClass();

  // calling getage() method implemented at Class1
  // inside main() method
  obj.getAge();
 }
}

Output:

Age is 21

Note: also read about the Interface vs Abstract class

Follow Me

If you like my post, please follow me to read my latest post on programming and technology.

https://www.instagram.com/coderz.py/

https://www.facebook.com/coderz.py