![\"Java](\"https:\/\/data-flair.training\/blogs\/wp-content\/uploads\/sites\/2\/2018\/02\/Java-Inner-Class-df.jpg\")
<\/a><\/p>\nInner Classes in Java<\/h3>\n
Inner classes in Java are the classes that are defined inside the scope of another class. Inner classes are also called nested classes. This helps in easy documentation and better maintenance of the code.<\/p>\n
Need for Java Inner Classes<\/h3>\n
Sometimes you will need to program a class in such a way that no other class can access it. Hence, it would be better if you enclose it within other classes.<\/p>\n
If all the class objects are a part of the outer object, then it is easier to nest that class inside the outer class. That way, all the outer classes can access all the objects of the inner class.<\/p>\n
Syntax of inner class in Java:<\/strong><\/p>\n There are 4 types of inner classes in Java:<\/strong><\/p>\n 1. Nested Inner class As the name suggests, this type of inner class involves the nesting of a class inside another class. The inner class can access the private variables of the outer class.<\/p>\n We can modify access to the inner class by using access modifier keywords such as private, protected, and default. Similarly, access specifiers can help nest interfaces inside one another.<\/p>\n Java program to illustrate the usage of a nested inner class:<\/strong><\/p>\n Output<\/strong><\/p>\n One thing to remember is that even though we can have nested static classes, we cannot have methods that are static inside the nested classes. Because all the methods of the nested class are implicitly connected to the object of its outer enclosing class. Hence, they cannot declare any static methods for themselves.<\/p>\n Java program to illustrate the static method in the nested class:<\/strong><\/p>\n Output<\/strong><\/p>\n a. Static nested classes in java<\/strong><\/p>\n If you declare the inner class to be static, then you can access the class without having to create an object of the outer class. However, the static class will not have access to members of the outer class. We can access the elements of the outer class from the inner class.<\/p>\n Java program to illustrate the use of static nested classes:<\/strong><\/p>\n Output<\/strong><\/p>\n Up until now, we have seen classes coded inside other classes. In the case of method local inner classes, the outer class method contains the inner class.<\/p>\n These classes are defined in the method of the outer class. A class defined under the method can access all the variables of the outer class as well as the method and the members of other methods, too, irrespective of the access modifier.<\/p>\n However, the inner class cannot use the variables of the outer class if they are not declared as final values. This rule was prevalent until JDK 1.7. After that, inner classes can access non-final local variables.<\/p>\n Java program to illustrate the use of Method Local Inner Classes:<\/strong><\/p>\n Output<\/strong><\/p>\n Note: <\/em><\/strong>If you are using JDK 1.7 or below, removing the final keyword will give you an error like this:<\/em><\/strong><\/p>\n The code inside the inner class is trying to access the local variable named site. The error will be rectified if you declare the variable as final.<\/p>\n As the name suggests, these inner classes have no name at all. The definition of the classes is written outside the scope of the outer class. These classes are useful when we have to design an interface or overload a method. It saves us the effort of having to nest the class.<\/p>\n These classes are used when we need to define extended characteristics of the class or interfaces without creating another class or interface.<\/p>\n They are of two types.<\/strong><\/p>\n 1.<\/strong> Subclass of the specified type. In this method, the anonymous class is put inside a subclass of the outer class. The subclass serves the function as illustrated below.<\/p>\n Java program to illustrate the use of a subclass of a specified type:<\/strong><\/p>\n Output<\/strong><\/p>\n The anonymous class can extend a class or implement an interface at a time. We learned about extending a class using anonymous classes in the previous example.<\/p>\n Here in this example, we will see interface implementation by anonymous classes. Anonymous classes can also implement interfaces, as shown below.<\/p>\n Java program to illustrate the use of anonymous classes to implement interfaces:<\/strong><\/p>\n Output<\/strong><\/p>\n Inner classes offer a variety of use cases that enhance code organization, modularity, and readability. Here are some common scenarios where inner classes prove beneficial:<\/p>\n 1. Helper Classes:<\/strong> Inner classes can encapsulate helper methods specific to the outer class, promoting better code organization and reducing clutter within the main class definition.<\/p>\n 2. Event Listeners:<\/strong> When designing graphical user interfaces (GUIs) in Java, inner classes are frequently used to implement event listeners. These listeners can be tailored to handle specific events within the outer class.<\/p>\n 3. Anonymous Classes for Callbacks:<\/strong> Anonymous inner classes excel at defining callback methods without the need for creating separate named classes. This is particularly useful for concise implementation of functionalities like button clicks or data retrieval callbacks.<\/p>\n While inner classes offer numerous advantages, it’s essential to employ them judiciously to maintain code quality. Here are some best practices to keep in mind:<\/p>\n 1. Favor Meaningful Names:<\/strong> Unless anonymous classes are strictly necessary, strive to assign descriptive names to your inner classes. This enhances code readability and comprehension for both you and other developers.<\/p>\n 2. Minimize Inner Class Scope:<\/strong> Limit the scope of inner classes whenever possible. This helps prevent unnecessary access to outer class members and promotes better encapsulation.<\/p>\n 3. Consider Alternatives:<\/strong> Inner classes shouldn’t be the default choice for every situation. If a class doesn’t have a strong dependency on the outer class, consider making it a separate top-level class for improved reusability.<\/p>\n We learned about the different types of inner classes and their functions in programming. Inner classes are effective while designing interfaces and classes with intricate definitions. It also helps in organizing similar classes together.<\/p>\n","protected":false},"excerpt":{"rendered":" Earlier we learned about classes and objects. These are an integral part of programming in Java. However, it is very important to know that classes, just like loops, are nested, i.e one class definition...<\/p>\n","protected":false},"author":5,"featured_media":84333,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[32],"tags":[6723,6724,7544,9037,13779,13780,15072],"class_list":["post-7179","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-inner-class-in-java","tag-inner-classes-in-java","tag-java-inner-class","tag-nested-inner-class-in-java","tag-static-inner-class","tag-static-inner-class-in-java","tag-types-of-java-inner-class"],"yoast_head":"\npublic class OuterCLass {\r\n \/\/outer code\r\n public class innerClass {\r\n \/\/Inner class code\r\n }\r\n}<\/pre>\n
\n2. Method local inner classes
\n3. Anonymous inner classes
\n4. Static nested classes<\/p>\nNested inner class in Java<\/h4>\n
package com.dataflair.innerclass;\r\nclass OuterClass {\r\n public class InnerClass {\r\n public void print() {\r\n System.out.println(\"I am printing from the inner class!\");\r\n\r\n }\r\n }\r\n}\r\n\r\npublic class NestedInnerClass {\r\n public static void main(String[] args) {\r\n OuterClass.InnerClass in =new OuterClass().new InnerClass(); in .print();\r\n }\r\n\r\n}<\/pre>\npackage com.dataflair.innerclass;\r\nclass OuterClass {\r\n public class InnerClass {\r\n static public void print() {\r\n System.out.println(\"I am printing from inner class!\");\r\n\r\n }\r\n }\r\n}\r\n\r\npublic class StaticInnerClassMethod {\r\n public static void main(String[] args) {\r\n OuterClass.InnerClass in =new OuterClass().new InnerClass(); in .print();\r\n }\r\n\r\n}<\/pre>\n
\nstatic public void print()
\n^
\nModifier ‘static’ is only allowed in constant variable declarations
\n1 error<\/div>\npackage com.dataflair.innerclass;\r\nclass OuterClass {\r\n public static class InnerClass {\r\n public void print() {\r\n System.out.println(\"I am printing from a static inner class!\");\r\n\r\n }\r\n }\r\n}\r\n\r\npublic class StaticInnerClass {\r\n public static void main(String[] args) {\r\n OuterClass.InnerClass in =new OuterClass.InnerClass(); in .print();\r\n }\r\n\r\n}<\/pre>\n2. Method Local Inner Classes in Java<\/h4>\n
package com.dataflair.innerclass;\r\nclass OuterClass {\r\n void outerClassMethod() {\r\n final String site = \"Data-Flair.training\";\r\n System.out.println(\"Hey I am inside outerClassMethod\");\r\n class InnerClass {\r\n void innerClassMethod() {\r\n System.out.println(\"I am studying Java at \" + site);\r\n }\r\n }\r\n InnerClass in =new InnerClass(); in .innerClassMethod();\r\n }\r\n}\r\n\r\npublic class MainClass {\r\n public static void main(String[] args) {\r\n OuterClass out = new OuterClass();\r\n out.outerClassMethod();\r\n }\r\n\r\n}<\/pre>\n
\nI am studying Java at Data-Flair.training<\/div>\n3. Anonymous Inner Classes in Java<\/h4>\n
\n2.<\/strong> The implementer of the specified interface.<\/p>\n1. Subclass of the specified type<\/h5>\n
class OuterClass {\r\n void print() {\r\n System.out.println(\"I am in the print method of superclass\");\r\n }\r\n}\r\nclass AnonymousClass {\r\n\r\n \/\/ An anonymous class with OuterClass as base class \r\n \/\/start of the anonymous class.\r\n static OuterClass out = new OuterClass() {\r\n void print() {\r\n super.print();\r\n System.out.println(\"I am in Anonymous class\");\r\n }\r\n };\r\n public static void main(String[] args) {\r\n out.print();\r\n }\r\n}<\/pre>\n
\nI am in Anonymous class<\/div>\n2. The implementer of the specified Interface<\/h5>\n
package com.dataflar.innerclass;\r\ninterface Anonym {\r\n void print();\r\n}\r\nclass AnonymousClass {\r\n\r\n \/\/ An anonymous class with OuterClass as base class \r\n \/\/start of the anonymous class.\r\n static Anonym an = new Anonym() {\r\n public void print() {\r\n System.out.println(\"I am an implementation of interface Anonym\");\r\n }\r\n };\r\n public static void main(String[] args) {\r\n an.print();\r\n }\r\n}<\/pre>\nWhere Inner Classes Shine<\/h3>\n
Best Practices for Inner Classes<\/h3>\n
Summary<\/h3>\n