{"id":5238,"date":"2021-03-23T15:38:41","date_gmt":"2021-03-23T15:38:41","guid":{"rendered":"https:\/\/ded9.com\/?p=5238"},"modified":"2025-10-25T07:00:53","modified_gmt":"2025-10-25T07:00:53","slug":"nested-and-inner-classes-in-java","status":"publish","type":"post","link":"https:\/\/ded9.com\/de\/nested-and-inner-classes-in-java\/","title":{"rendered":"Nested and Inner Classes in Java: Explained Clearly"},"content":{"rendered":"

In this tutorial, you will learn how to work with Inner and Nested classes<\/a> in Java. <\/span><\/span><\/span>In Java<\/a>, you can define one class in another.\u00a0This class is known as the Nested class.<\/span><\/p>\n

\n
class OuterClass {\r\n\r\n\/\/\u2026\r\n\r\nclass NestedClass {\r\n\r\n\/\/\u2026\r\n\r\n}\r\n\r\n}<\/pre>\n<\/div>\n
You can create two types of nested classes in Java.<\/p>\n
\"You<\/p>\n
    \n
  • Non-static nested class (Inner class)<\/li>\n
  • Static nested class<\/li>\n<\/ul>\n
    Let’s look at non-static nested courses first.<\/p>\n
    Non-static nested class<\/span><\/h2>\n
    A non-static nested class is a class in another class with access to the enclosed class (outer class) members\u2014commonly known as the inner class.<\/p>\n
    There is an internal class inside the outer class (to define an inner class, you must first define an outer class).<\/p>\n
    For example, you can define internal classes in Java.<\/p>\n
    Example 1: Internal class<\/strong><\/h3>\n
    \n
      \n
    1. class CPU {<\/li>\n
    2. double price;<\/li>\n
    3. class Processor {<\/li>\n
    4. double cores;<\/li>\n
    5. String manufacturer;<\/li>\n
    6. double getCache () {<\/li>\n
    7. return 4.3;<\/li>\n
    8. }<\/li>\n
    9. }<\/li>\n
    10. protected class RAM {<\/li>\n
    11. double memory;<\/li>\n
    12. String manufacturer;<\/li>\n
    13. double getClockSpeed \u200b\u200b() {<\/li>\n
    14. return 5.5;<\/li>\n
    15. }<\/li>\n
    16. }<\/li>\n
    17. }<\/li>\n
    18. public class Main {<\/li>\n
    19. public static void main (String [] args) {<\/li>\n
    20. CPU cpu = new CPU ();<\/li>\n
    21. CPU.Processor processor = cpu.new Processor ();<\/li>\n
    22. CPU.RAM ram = cpu.new RAM ();<\/li>\n
    23. System.out.println (\u201cProcessor Cache =\u201d + processor.getCache ());<\/li>\n
    24. System.out.println (\u201cRam Clock speed =\u201d + ram.getClockSpeed \u200b\u200b());<\/li>\n
    25. }<\/li>\n
    26. }<\/li>\n<\/ol>\n<\/blockquote>\n
      Output<\/h4>\n
      \n
      Processor Cache = 4.3<\/p>\n
      Ram Clock speed = 5.5<\/p>\n<\/blockquote>\n
      In the above program, the CPU class has two internal classes, Processor and RAM. Since the RAM class is internal, you can set it to protected.<\/p>\n
      In the Main class, the CPU instance is created first.\u00a0The Operator instance (Dot) is used to create the Processor<\/span>.<\/p>\n
      Access to external class members in the internal class<\/span><\/h2>\n
      As we discussed, internal classes can access members of the outer class, which is possible using this keyword.<\/p>\n
      Example 2: Access to members<\/strong><\/h3>\n
      \n
        \n
      1. public class Car {<\/li>\n
      2. String carName;<\/li>\n
      3. String carType;<\/li>\n
      4. public Car (String name, String type) {<\/li>\n
      5. this.carName = name;<\/li>\n
      6. this.carType = type;<\/li>\n
      7. }<\/li>\n
      8. private String getCarName () {<\/li>\n
      9. return this.carName;<\/li>\n
      10. }<\/li>\n
      11. class Engine {<\/li>\n
      12. String engineType;<\/li>\n
      13. void setEngine () {<\/li>\n
      14. \/\/ Accessing carType property of Car<\/li>\n
      15. if (Car.this.carType.equals (\u201c4WD\u201d)) {<\/li>\n
      16. \/\/ Invoking method getCarName () of Car<\/li>\n
      17. if (Car.this.getCarName (). equals (\u201cCrysler\u201d)) {<\/li>\n
      18. this.engineType = \u201cBigger\u201d;<\/li>\n
      19. } else {<\/li>\n
      20. this.engineType = \u201cSmaller\u201d;<\/li>\n
      21. }<\/li>\n
      22. } else {<\/li>\n
      23. this.engineType = \u201cBigger\u201d;<\/li>\n
      24. }<\/li>\n
      25. }<\/li>\n
      26. String getEngineType () {<\/li>\n
      27. return this.engineType;<\/li>\n
      28. }<\/li>\n
      29. }<\/li>\n
      30. }<\/li>\n
      31. public class CarMain {<\/li>\n
      32. public static void main (String [] args) {<\/li>\n
      33. Car car1 = new Car (\u201cMazda\u201d, \u201c8WD\u201d);<\/li>\n
      34. Car.Engine engine = car1.new Engine ();<\/li>\n
      35. engine.setEngine ();<\/li>\n
      36. System.out.println (\u201cEngine Type for 8WD =\u201d + engine.getEngineType ());<\/li>\n
      37. Car car2 = new Car (\u201cCrysler\u201d, \u201c4WD\u201d);<\/li>\n
      38. Car.Engine c2engine = car2.new Engine ();<\/li>\n
      39. c2engine.setEngine ();<\/li>\n
      40. System.out.println (\u201cEngine Type for 4WD =\u201d + c2engine.getEngineType ());<\/li>\n
      41. }<\/li>\n
      42. }<\/li>\n<\/ol>\n<\/blockquote>\n
        Output<\/h4>\n
        \n
        Engine Type for 8WD = Bigger<\/p>\n
        Engine Type for 4WD = Smaller<\/p>\n<\/blockquote>\n
        In the above program, in the internal class of Engine, we used the keyword this to access the carType variable of the external class Car:<\/p>\n
        \n
        Car.this.carType.equals (\u201c4WD)<\/pre>\n<\/div>\n
        This is possible even if carType is a private member of the Car class.<\/p>\n
        You can also see that we have used a Car. This is to access the Car members. If you use this instead of Car. this, you only have access to members of the Engine class.<\/p>\n
        Similarly, we used this keyword to access the getCarName () of the Car class:<\/p>\n
        \n
        Car.this.getCarName (). Equals (\u201cCrysler\u201d)<\/pre>\n<\/div>\n
        Here, the getCarName () method is a private method of the class Car.<\/p>\n
        Static internal class<\/span><\/h2>\n
        In Java, you can define a static nested class.<\/p>\n
        Unlike the inner class, the static nested class cannot access the variables that are members of the outer class because the static nested class does not need to create an instance of the outer class.\u00a0Hence, there is no external class reference with OuterClass.this.<\/p>\n
        So, you can create an instance of a static nested class like this:<\/p>\n
        \n
        OuterClass.InnerClass obj = new OuterClass.InnerClass ();<\/pre>\n<\/div>\n
        Example 3: Static internal class<\/strong><\/h3>\n
        \n
          \n
        1. Public class MotherBoard {<\/li>\n
        2. String model;<\/li>\n
        3. public MotherBoard (String model) {<\/li>\n
        4. this.model = model;<\/li>\n
        5. }<\/li>\n
        6. static class USB {<\/li>\n
        7. int usb2 = 2;<\/li>\n
        8. int usb3 = 1;<\/li>\n
        9. int getTotalPorts () {<\/li>\n
        10. return usb2 + usb3;<\/li>\n
        11. }<\/li>\n
        12. }<\/li>\n
        13. }<\/li>\n
        14. public class Main {<\/li>\n
        15. public static void main (String [] args) {<\/li>\n
        16. MotherBoard.USB usb = new MotherBoard.USB ();<\/li>\n
        17. System.out.println (\u201cTotal Ports =\u201d + usb.getTotalPorts ());<\/li>\n
        18. }<\/li>\n
        19. }<\/li>\n<\/ol>\n<\/blockquote>\n
          Output<\/h4>\n
          \n
          Total Ports = 3<\/p>\n<\/blockquote>\n
          We defined the internal static USB class using the static keyword in the above program.<\/p>\n
          In the Main class, you can also see a direct instance of USB from the MotherBoard with the operator.\u00a0<\/strong>We defined (dot) without creating a sample of the Motherboard.<\/p>\n
          \n
          MotherBoard.USB usb = new MotherBoard.USB ();<\/pre>\n<\/div>\n
          Let’s see what happens if we try to reach out to outside class members:<\/p>\n
          Example 4: Access to external class members in a static internal class<\/strong><\/h3>\n
          \n
            \n
          1. String model;<\/li>\n
          2. public MotherBoard (String model) {<\/li>\n
          3. this.model = model;<\/li>\n
          4. }<\/li>\n
          5. static class USB {<\/li>\n
          6. int usb2 = 2;<\/li>\n
          7. int usb3 = 1;<\/li>\n
          8. int getTotalPorts () {<\/li>\n
          9. if (MotherBoard.this.model.equals (\u201cMSI\u201d)) {<\/li>\n
          10. return 4;<\/li>\n
          11. }<\/li>\n
          12. else {<\/li>\n
          13. return usb2 + usb3;<\/li>\n
          14. }<\/li>\n
          15. }<\/li>\n
          16. }<\/li>\n
          17. }<\/li>\n
          18. public class Main {<\/li>\n
          19. public static void main (String [] args) {<\/li>\n
          20. MotherBoard.USB usb = new MotherBoard.USB ();<\/li>\n
          21. System.out.println (\u201cTotal Ports =\u201d + usb.getTotalPorts ());<\/li>\n
          22. }<\/li>\n
          23. }<\/li>\n<\/ol>\n<\/blockquote>\n
            Output<\/h3>\n
            \n
            error: non-static variable this cannot be referenced from a static context<\/p>\n<\/blockquote>\n
            Key points to remember<\/strong><\/p>\n
              \n
            • Java treats the internal class as a regular member, just like the methods and variables defined within a class.<\/li>\n
            • Because the internal class is a member of the external class, you can apply any access level regulator, such as private and protected, to the internal class, which is impossible in regular courses.<\/li>\n
            • Since the nested class is a member of the externally enclosed class, you can use the operator.\u00a0<\/strong>(Dot) Use to access the nested class and its parameters.<\/li>\n
            • Using a nested class makes the code more readable and provides better encapsulation.<\/li>\n
            • Non-static nested classes (internal classes) have access to other members of the external\/enclosed class, even if they are private.<\/li>\n<\/ul>\n
              FAQ<\/h2>\n
              \n
              \n
              \n
              What is the difference between a static nested class and a non-static inner class in Java?<\/h3>\n
              \n\n
              A static nested class is declared with the static keyword inside another class and does not hold a reference to an instance of the outer class, so it cannot directly access non-static members of the outer class. A non-static nested class (also called an inner class) is tied to a specific instance of the outer class and can access its instance members, including private ones.<\/p>\n\n<\/div>\n<\/div>\n
              \n
              Why would I use nested or inner classes instead of separate top-level classes?<\/h3>\n
              \n\n
              Because they allow you to logically group classes that are only used in one place, increase encapsulation (you can hide the helper class from outside), and make code more readable and maintainable by placing the related class inside its \u201chost\u201d class.<\/p>\n\n<\/div>\n<\/div>\n
              \n
              How do you create and instantiate an inner class in Java?<\/h3>\n
              \n\n
              First instantiate the outer class, then use that instance to create the inner class, for example: OuterClass outer = new OuterClass(); OuterClass.InnerClass inner = outer.new InnerClass(); For a static nested class you can instantiate directly: OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();<\/p>\n\n<\/div>\n<\/div>\n<\/div>\n<\/div><\/div>\n","protected":false},"excerpt":{"rendered":"
              In this tutorial, you will learn how to work with Inner and Nested classes in Java. In Java, you can define one class in another.\u00a0This class is known as the Nested class. class OuterClass { \/\/\u2026 class NestedClass { \/\/\u2026 } } You can create two types of nested classes in Java. Non-static nested class […]<\/p>\n","protected":false},"author":6,"featured_media":5239,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[11513],"tags":[840],"class_list":["post-5238","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java-2","tag-java"],"acf":[],"amp_enabled":true,"_links":{"self":[{"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/posts\/5238","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/users\/6"}],"replies":[{"embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/comments?post=5238"}],"version-history":[{"count":6,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/posts\/5238\/revisions"}],"predecessor-version":[{"id":263837,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/posts\/5238\/revisions\/263837"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/media\/5239"}],"wp:attachment":[{"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/media?parent=5238"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/categories?post=5238"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ded9.com\/de\/wp-json\/wp\/v2\/tags?post=5238"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}