Nested Classes explained

Quite often, we come across the term “Nested Class” in Java. It is a very common interview topic as well. So in this

blog post, I will be explaining what a nested class is in Java.

What is a Nested Class?

As the word suggests, a nested Java class is a class which lies within another Java class.  Consider the following code snippet:

class OuterClass{class NestedClass{}}

 

The class NestedClass is like any other member of the OuterClass. It has access to other members that is methods and variables of the OuterClass even if a member is a private member. On compiling this code snippet, the compiler creates two class files. One will be the OuterClass.class and the other will be the OuterClass$NestedClass.class.  If you have more than one nested class, the compiler creates a separate class file for each one. However, each of them will be prefixed with the name of the enclosing class and the $ sign.

Why do we need nested classes?

The following are some reasons where you will need Nested classes:

  1. Logical grouping of classes – If a class is useful to only one class, then it is logical to embed it in that class and keep the two together.
  2. More readable and maintainable code – Nesting small classes within top level classes places the code closer to where it is used.
  3. Increased Encapsulation – Wrapping together data & code that operates on the data together as a single unit is referred to as encapsulation. So by including a class within another class, we are wrapping together the code that operates on the data into a single unit.

Static Nested Classes

A nested class can be a static or non-static class. As you probably know, a static variable is the same for all objects of a class. Static nested classes also belong to the class and not to any one instance of the class. They belong to the class that encloses them and not its objects.

public class OuterClass {private int outerField;private static int staticOuterField;static class StaticNestedClass{private int nestedField;public void nestedMethod(){System.out.println("Value of outerField is "+outerField); //causes compilation errorSystem.out.println("Value of staticOuterField "+staticOuterField);System.out.println("Value of nestedField is "+nestedField);}}public static void main(String[] args) {OuterClass.StaticNestedClass object = new OuterClass.StaticNestedClass();object.nestedMethod();}}

Here, we have declared an outer class called OuterClass and a static nested class called StaticNestedClass. The OuterClass has two fields, outerField which is an instance field and staticOuterField which is a static field. The NestedClass has a field called nestedField and a method called nestedMethod. The nestedMethod has Sysout statements which print the values of all 3 fields. Since the NestedClass is static, it cannot access the non static field in the OuterClass. so there is a compilation error at the line where the non static field is accessed by the NestedClass.

A static nested class cannot access the enclosing class members directly. It first needs to create an instance of the outer class and then use that instance to access the outer class members. In the main method, an object of the NestedClass is created using the following syntax:

OuterClass.StaticNestedClass object = new OuterClass.StaticNestedClass();

 

Inner Classes

Non-static nested classes are called Inner classes. Consider the following code snippet:

public class OuterClass {private int outerField;private static int staticOuterField;class InnerClass{private int innerField;// private static nestedField;//causes compilation error;public void innerMethod(){System.out.println("Value of outerField is "+outerField);System.out.println("Value of staticOuterField "+staticOuterField);System.out.println("Value of innerField is "+innerField);}}public static void main(String[] args) {OuterClass outerObject = new OuterClass();OuterClass.InnerClass innerObject = outerObject.new InnerClass();innerObject.innerMethod();}}

In the code snippet above, the class InnerClass is an inner class. As opposed to static nested classes, an inner class belongs to instances of the enclosing class. As with instance methods and variables, an inner class has direct access to an objects methods and fields. Also, because an inner class is associated with an instance, it cannot define any static members itself.   Objects that are instances of an inner class exist within an instance of the outer class. To instantiate an inner class, you must first instantiate the outer class.  So in the main method, we have written the following code:

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

 

Types of Inner Classes

There are two types of inner classes, Local and anonymous classes.

Local Classes

Local classes are declared within a block of code and are visible only within that block.  So if you have an inner class within a method it is known as a local class. Typically, a local class is defined within a method but it can also be defined within a static block or even the constructor of a class.

Consider the following code snippet:

public class OuterClass{public void OuterMethod(){class LocalClass{}}}

Some important points to note about local classes:

  • Since local classes are inner classes, they can access all the members of the containing class. In addition, they can also access any local variables or method parameters that are in the scope of the local method definition and declared as final.
  • A local class is visible only within the block that defines it, it can never be used outside the block
  • Local classes cannot be declared public,protected,private or static. These modifiers are for members of classes, they are not allowed with local variable declarations or local class declarations.
Anonymous classes

An anonymous class is a local class without a name. So you can declare a local class within the body of a method without naming it. Anonymous inner class always extend a class or implement an interface.  Consider the following code snippet:

public abstract class Animal {abstract void speak();}public class AnimalDemo {public static void main(String[] args) {Animal dog = new Animal(){void speak(){System.out.println("woof woof");}};dog.speak();}}

So here we have an abstract class called Animal. It has an abstract method called speak. We have another class called AnimalDemo. In the main method we are creating a new Animal object called Dog and providing the implementation for the speak method there itself. So, instead of creating a separate class called Dog that extends the Animal class, we are creating an Anonymous inner class for Dog. Similarly, Anonymous inner classes can be created by implementing an interface too.

Comments

Post a Comment

Popular posts from this blog

How to use logging in SpringBoot with code samples

Image
In this article, we will learn how to use logging in SpringBoot. Introduction There are several Java logging frameworks like logback, log4j, and so on. Spring Boot supports out-of-the-box support for logback. Let us learn how to use logging in SpringBoot with logback. Step 1 – Create a New Maven Project Create a new Maven project. (Refer to  this  blog post). This will create a project in Eclipse as follows:   Step 2 – Add the Spring Boot Dependencies Add the spring-boot-starter-web dependency to the pom.xml . So, the pom.xml should look as follows: <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.learnjava</groupId> <artifactId>learnjava-springboot-logging-example</artifactId> <version>0.0.1-SNAPSHOT&
Read more

Python While Loop with code samples

Much like a Java while loop, you can use a Python while loop to repeatedly execute a block of code as long as a condition is true. In this article, we will learn more about the Python while loop. Python While loop Syntax A while loop in Python has the following syntax: while <condition>: loop body The while keyword is followed by a condition. If the condition evaluates to true, the body of the loop is executed. Once the body of the loop is completed, the condition is checked again and this is repeated until the condition evaluates to false at which point the loop is exited. While loop Sample Code The following code demonstrates how you can use the while loop: num=10counter=1total=0while counter<=num: total += counter counter+=1print("sum of first 10 numbers is",total) This code adds the numbers from 1 to 10 and prints the sum. It uses a while loop to iterate from 1 to 10. The while loop checks the condition counter <= num and if so adds the current value of count
Read more

How to convert a List to a Set

In this blog post ,I will be showing you how you can convert a List to a Set. Consider the following code snippet: public class ListToSetDemo {public static void main(String[] args) {List<Integer> list = Arrays.asList(5,3,11,15,9);//Method 1Set<Integer> set = new HashSet<Integer>(list);System.out.println("Set is "+set);//method 2Set<Integer> set2 = new HashSet<Integer>();set2.addAll(list);System.out.println("Set is "+set2);}} This code demonstrates two ways to convert a List to a Set. Method 1 Here, we are creating a new HashSet . We are invoking the constructor that accepts a Collection object. Here, we are passing in the input list to this constructor.   Method 2 Here again, we are creating a new HashSet . However, we are using the default constructor. We are then invoking the addAll method and passing in the input list.   When you run this code, it will print the following output: Set is [3, 5, 9, 11, 15]Set is [3, 5, 9, 11, 15] No
Read more