உள்ளமைக்கப்பட்ட உள் வகுப்புகள்

வணக்கம்! இன்று நாம் ஒரு முக்கியமான தலைப்பை எடுத்துக்கொள்வோம் - ஜாவாவில் உள்ளமை வகுப்புகள் எவ்வாறு செயல்படுகின்றன. ஜாவா மற்றொரு வகுப்பிற்குள் வகுப்புகளை உருவாக்க உங்களை அனுமதிக்கிறது:

class OuterClass {
    ...
    static class StaticNestedClass {
        ...
    }
    class InnerClass {
        ...
    }
}

இந்த உள் வகுப்புகள் உள்ளமை என்று அழைக்கப்படுகின்றன. அவை 2 வகைகளாக பிரிக்கப்பட்டுள்ளன:

1. நிலையான அல்லாத உள்ளமை வகுப்புகள். இவை உள் வகுப்புகள் என்றும் அழைக்கப்படுகின்றன.
2. நிலையான உள்ளமை வகுப்புகள்.

இதையொட்டி, உள் வகுப்புகள் இரண்டு தனித்துவமான துணைப்பிரிவுகளைக் கொண்டுள்ளன. உள் வர்க்கம் ஒரு உள் வகுப்பாக இருப்பதைத் தவிர, அதுவும் இருக்கலாம்:

• ஒரு உள்ளூர் வகுப்பு
• ஒரு அநாமதேய வகுப்பு

குழப்பமான? :) பரவாயில்லை. தெளிவுக்காக இங்கே ஒரு வரைபடம் உள்ளது. நீங்கள் திடீரென்று குழப்பமடைந்தால் பாடத்தின் போது மீண்டும் வரவும்! இன்றைய பாடத்தில், உள் வகுப்புகளைப் பற்றி விவாதிப்போம் (நிலையற்ற உள்ளமை வகுப்புகள் என்றும் அழைக்கப்படுகிறது). அவை ஒட்டுமொத்த வரைபடத்தில் சிறப்பாகக் காட்டப்பட்டுள்ளன, எனவே நீங்கள் தொலைந்து போகாதீர்கள் :) வெளிப்படையான கேள்வியுடன் ஆரம்பிக்கலாம்: அவை ஏன் "உள்" வகுப்புகள் என்று அழைக்கப்படுகின்றன? பதில் மிகவும் எளிது: ஏனென்றால் அவை மற்ற வகுப்புகளுக்குள் உருவாக்கப்படுகின்றன. இங்கே ஒரு உதாரணம்:

public class Bicycle {

   private String model;
   private int weight;

   public Bicycle(String model, int weight) {
       this.model = model;
       this.weight = weight;
   }
  
   public void start() {
       System.out.println("Let's go!");
   }

   public class Handlebar {

       public void right() {
           System.out.println("Steer right!");
       }

       public void left() {

           System.out.println("Steer left!");
       }
   }

   public class Seat {
      
       public void up() {

           System.out.println("Seat up!");
       }
      
       public void down() {

           System.out.println("Seat down!");
       }
   }
}

இங்கே எங்களிடம் Bicycleவகுப்பு உள்ளது. இது 2 புலங்கள் மற்றும் 1 முறை: start(). இது ஒரு சாதாரண வகுப்பிலிருந்து வேறுபடுகிறது, அதில் இரண்டு வகுப்புகள் உள்ளன: Handlebarமற்றும் Seat. அவர்களின் குறியீடு வகுப்பிற்குள் எழுதப்பட்டுள்ளது Bicycle. இவை முழு அளவிலான வகுப்புகள்: நீங்கள் பார்க்க முடியும் என, அவை ஒவ்வொன்றும் அதன் சொந்த முறைகளைக் கொண்டுள்ளன. இந்த கட்டத்தில், உங்களுக்கு ஒரு கேள்வி இருக்கலாம்: உலகில் ஏன் ஒரு வகுப்பை மற்றொரு வகுப்பிற்குள் வைக்க வேண்டும்? ஏன் அவர்களை உள் வகுப்புகளாக ஆக்க வேண்டும்? சரி, நமது திட்டத்தில் ஹேண்டில்பார் மற்றும் இருக்கை போன்ற கருத்துக்களுக்கு தனி வகுப்புகள் தேவை என்று வைத்துக்கொள்வோம். நிச்சயமாக, அவற்றை நாம் கூடுகட்ட வேண்டிய அவசியமில்லை! சாதாரண வகுப்புகள் செய்யலாம். உதாரணமாக, இது போன்றது:

public class Handlebar {
   public void right() {
       System.out.println("Steer right!");
   }

   public void left() {

       System.out.println("Steer left");
   }
}

public class Seat {

   public void up() {

       System.out.println("Seat up!");
   }

   public void down() {

       System.out.println("Seat down!");
   }
}

மிக நல்ல கேள்வி! நிச்சயமாக, நாங்கள் தொழில்நுட்பத்தால் வரையறுக்கப்படவில்லை. அதைச் செய்வது நிச்சயமாக ஒரு விருப்பமாகும். இங்கே, முக்கியமான விஷயம் என்னவென்றால், ஒரு குறிப்பிட்ட நிரல் மற்றும் அதன் நோக்கத்தின் கண்ணோட்டத்தில் வகுப்புகளின் சரியான வடிவமைப்பு. உள் வகுப்புகள் என்பது மற்றொரு நிறுவனத்துடன் பிரிக்கமுடியாத வகையில் இணைக்கப்பட்டுள்ள ஒரு பொருளைப் பிரிப்பதாகும். கைப்பிடிகள், இருக்கைகள் மற்றும் பெடல்கள் ஆகியவை மிதிவண்டியின் கூறுகள். மிதிவண்டியில் இருந்து பிரிந்தால், அவை பெரிதாகப் புரியவில்லை. இந்தக் கருத்துக்கள் அனைத்தையும் தனித்தனி பொது வகுப்புகளாக மாற்றியிருந்தால், எங்கள் திட்டத்தில் இது போன்ற குறியீடு இருந்திருக்கும்:

public class Main {

   public static void main(String[] args) {
       Handlebar handlebar = new Handlebar();
       handlebar.right();
   }
}

ம்ம்ம்... இந்த குறியீட்டின் அர்த்தத்தை விளக்குவது கூட கடினம். எங்களிடம் சில தெளிவற்ற கைப்பிடி உள்ளது (அது ஏன் அவசியம்? யோசனை இல்லை, நேர்மையாக இருக்க வேண்டும்). இந்த கைப்பிடி வலது பக்கம் திரும்புகிறது... எல்லாமே சைக்கிள் இல்லாமல்... சில காரணங்களால். கைப்பிடியின் கருத்தை மிதிவண்டியின் கருத்திலிருந்து பிரிப்பதன் மூலம், எங்கள் திட்டத்தில் சில தர்க்கங்களை இழந்தோம். உள் வகுப்பைப் பயன்படுத்தி, குறியீடு மிகவும் வித்தியாசமாகத் தெரிகிறது:

public class Main {

   public static void main(String[] args) {

       Bicycle peugeot = new Bicycle("Peugeot", 120);
       Bicycle.Handlebar handlebar = peugeot.new Handlebar();
       Bicycle.Seat seat = peugeot.new Seat();

       seat.up();
       peugeot.start();
       handlebar.left();
       handlebar.right();
   }
}

கன்சோல் வெளியீடு:

Seat up! 
Let's go! 
Steer left! 
Steer right!

இப்போது நாம் பார்ப்பது திடீரென்று புரிகிறது! :) நாங்கள் ஒரு சைக்கிள் பொருளை உருவாக்கினோம். நாங்கள் இரண்டு சைக்கிள் "சப்ஜெக்ட்களை" உருவாக்கினோம் - ஒரு கைப்பிடி மற்றும் இருக்கை. நாங்கள் வசதிக்காக இருக்கையை உயர்த்திவிட்டு வெளியேறினோம்: தேவைக்கேற்ப பெடலிங் மற்றும் ஸ்டீயரிங்! :) நமக்குத் தேவையான முறைகள் பொருத்தமான பொருள்களில் அழைக்கப்படுகின்றன. இது எல்லாம் எளிமையானது மற்றும் வசதியானது. இந்த எடுத்துக்காட்டில், ஹேண்டில்பார் மற்றும் இருக்கையை பிரிப்பது என்காப்சுலேஷனை மேம்படுத்துகிறது (மிதிவண்டி பாகங்கள் பற்றிய தரவை தொடர்புடைய வகுப்பிற்குள் மறைக்கிறோம்) மேலும் விரிவான சுருக்கத்தை உருவாக்குவோம். இப்போது வேறு ஒரு சூழ்நிலையைப் பார்ப்போம். பைக் கடை மற்றும் பைக்குகளுக்கான உதிரி பாகங்களை உருவகப்படுத்தும் ஒரு திட்டத்தை உருவாக்க விரும்புகிறோம் என்று வைத்துக்கொள்வோம். இந்த சூழ்நிலையில், எங்கள் முந்தைய தீர்வு வேலை செய்யாது. ஒரு பைக் கடையில், ஒவ்வொரு சைக்கிள் பகுதியும் ஒரு மிதிவண்டியிலிருந்து பிரிக்கப்பட்டாலும் கூட அர்த்தமுள்ளதாக இருக்கும். எடுத்துக்காட்டாக, "ஒரு வாடிக்கையாளருக்கு பெடல்களை விற்பது", "புதிய இருக்கையை வாங்குதல்" போன்ற முறைகள் நமக்குத் தேவைப்படும். இங்கு உள் வகுப்புகளைப் பயன்படுத்துவது தவறு - எங்கள் புதிய திட்டத்தில் உள்ள ஒவ்வொரு சைக்கிள் பகுதிக்கும் அதன் அர்த்தம் இருக்கும். அதன் சொந்த: இது ஒரு மிதிவண்டியின் கருத்தாக்கத்திலிருந்து பிரிக்கப்படலாம். நீங்கள் உள் வகுப்புகளைப் பயன்படுத்த வேண்டுமா அல்லது அனைத்து நிறுவனங்களையும் தனித்தனி வகுப்புகளாக ஒழுங்கமைக்க வேண்டுமா என்று நீங்கள் யோசிக்கிறீர்கள் என்றால், இது துல்லியமாக நீங்கள் கவனம் செலுத்த வேண்டும். பொருள்-சார்ந்த நிரலாக்கமானது நிஜ உலக நிறுவனங்களை மாதிரியாக்குவதை எளிதாக்குகிறது. உள் வகுப்புகளைப் பயன்படுத்தலாமா என்பதைத் தீர்மானிக்கும்போது இது உங்கள் வழிகாட்டும் கொள்கையாக இருக்கலாம். ஒரு உண்மையான கடையில், உதிரி பாகங்கள் மிதிவண்டிகளிலிருந்து தனித்தனியாக உள்ளன - இது பரவாயில்லை. ஒரு நிரலை வடிவமைக்கும்போது அதுவும் சரி என்று அர்த்தம். சரி, "தத்துவத்தை" கண்டுபிடித்துவிட்டோம் :) இப்போது உள் வகுப்புகளின் முக்கியமான "தொழில்நுட்ப" அம்சங்களைப் பற்றி அறிந்து கொள்வோம். நீங்கள் நிச்சயமாக நினைவில் வைத்து புரிந்து கொள்ள வேண்டியது இங்கே:

1. ஒரு உள் வர்க்கத்தின் ஒரு பொருள் வெளிப்புற வர்க்கத்தின் பொருள் இல்லாமல் இருக்க முடியாது.

   இது அர்த்தமுள்ளதாக இருக்கிறது: அதனால்தான் நாங்கள் எங்கள் திட்டத்தில் உள் வகுப்புகளை உருவாக்கினோம் - இதனால் நாங்கள் அனாதையான கைப்பிடிகள் மற்றும் இருக்கைகளுடன் முடிவடைந்து விடக்கூடாது Seat.Handlebar

   இந்த குறியீடு தொகுக்கப்படவில்லை:

   
   public static void main(String[] args) {
   
      Handlebar handlebar = new Handlebar();
   }
   

   இதிலிருந்து மற்றொரு முக்கியமான அம்சம் பின்வருமாறு:

2. உள் வகுப்பின் ஒரு பொருளுக்கு வெளி வகுப்பின் மாறிகளை அணுகலாம்.

   int seatPostDiameterஎடுத்துக்காட்டாக, ஒரு மாறியை (சீட்போஸ்டின் விட்டத்தைக் குறிக்கும்) வகுப்பில் சேர்ப்போம் Bicycle.

   பின்னர் உள் வகுப்பில், இருக்கை பண்புகளைக் காண்பிக்கும் Seatஒரு முறையை உருவாக்கலாம் :displaySeatProperties()

   
   public class Bicycle {
   
      private String model;
      private int weight;
   
      private int seatPostDiameter;
   
      public Bicycle(String model, int weight, int seatPostDiameter) {
          this.model = model;
          this.weight = weight;
          this.seatPostDiameter = seatPostDiameter;
   
      }
   
      public void start() {
          System.out.println("Let's go!");
      }
   
      public class Seat {
   
          public void up() {
   
              System.out.println("Seat up!");
          }
   
          public void down() {
   
              System.out.println("Seat down!");
          }
   
          public void displaySeatProperties() {
   
              System.out.println("Seat properties: seatpost diameter = " + Bicycle.this.seatPostDiameter);
          }
      }
   }
   

   இப்போது இந்த தகவலை எங்கள் நிரலில் காண்பிக்கலாம்:

   
   public class Main {
   
      public static void main(String[] args) {
   
          Bicycle bicycle = new Bicycle("Peugeot", 120, 40);
          Bicycle.Seat seat = bicycle.new Seat();
   
          seat.displaySeatProperties();
      }
   }
   

   கன்சோல் வெளியீடு:

   
   Seat properties: seatpost diameter = 40
   

   குறிப்பு:புதிய மாறி மிகவும் கடுமையான அணுகல் மாற்றியமைப்புடன் ( ) அறிவிக்கப்படுகிறது private. இன்னும் உள் வகுப்புக்கு அணுகல் உள்ளது!

3. ஒரு உள் வர்க்கத்தின் ஒரு பொருளை வெளிப்புற வர்க்கத்தின் நிலையான முறையில் உருவாக்க முடியாது.

   உள் வகுப்புகள் எவ்வாறு ஒழுங்கமைக்கப்படுகின்றன என்பதற்கான குறிப்பிட்ட அம்சங்களால் இது விளக்கப்படுகிறது. ஒரு உள் வகுப்பில் அளவுருக்கள் கொண்ட கன்ஸ்ட்ரக்டர்கள் அல்லது இயல்புநிலை கட்டமைப்பாளர் இருக்கலாம். ஆனால் பொருட்படுத்தாமல், நாம் ஒரு உள் வகுப்பின் பொருளை உருவாக்கும்போது, ​​​​வெளி வகுப்பின் பொருளைப் பற்றிய குறிப்பு கண்ணுக்குத் தெரியாமல் உள் வகுப்பின் உருவாக்கப்பட்ட பொருளுக்கு அனுப்பப்படுகிறது. எல்லாவற்றிற்கும் மேலாக, அத்தகைய ஒரு பொருள் குறிப்பு இருப்பது ஒரு முழுமையான தேவை. இல்லையெனில், உள் வகுப்பின் பொருட்களை நாம் உருவாக்க முடியாது.

   ஆனால் வெளி வர்க்கத்தின் ஒரு முறை நிலையானது என்றால், நமக்கு வெளி வர்க்கம் என்ற பொருள் இல்லாமல் இருக்கலாம்! மேலும் இது உள் வர்க்கம் எவ்வாறு செயல்படுகிறது என்பதற்கான தர்க்கத்தை மீறுவதாகும். இந்த சூழ்நிலையில், கம்பைலர் ஒரு பிழையை உருவாக்கும்:

   
   public static Seat createSeat() {
     
      // Bicycle.this cannot be referenced from a static context
      return new Seat();
   }
   

4. ஒரு உள் வகுப்பில் நிலையான மாறிகள் மற்றும் முறைகள் இருக்க முடியாது.

   தர்க்கம் ஒன்றுதான்: நிலையான முறைகள் மற்றும் மாறிகள் இருக்கும் மற்றும் ஒரு பொருள் இல்லாத நிலையில் கூட அழைக்கப்படலாம் அல்லது குறிப்பிடப்படலாம்.

   ஆனால் வெளி வகுப்பின் பொருள் இல்லாமல், உள் வகுப்பை அணுக முடியாது.

   தெளிவான முரண்பாடு! அதனால்தான் நிலையான மாறிகள் மற்றும் முறைகள் உள் வகுப்புகளில் அனுமதிக்கப்படுவதில்லை.

   நீங்கள் அவற்றை உருவாக்க முயற்சித்தால் கம்பைலர் பிழையை உருவாக்கும்:

   
   public class Bicycle {
   
      private int weight;
   
   
      public class Seat {
         
          // An inner class cannot have static declarations
          public static void displaySeatProperties() {
   
              System.out.println("Seat properties: seatpost diameter = " + Bicycle.this.seatPostDiameter);
          }
      }
   }
   

5. உள் வகுப்பின் ஒரு பொருளை உருவாக்கும் போது, ​​அதன் அணுகல் மாற்றி முக்கியமானது.

   ஒரு உள் வகுப்பை நிலையான அணுகல் மாற்றிகள் மூலம் குறிக்கலாம்: public, private, protected, மற்றும் package private.

   இது ஏன் முக்கியம்?

   இது எங்கள் திட்டத்தில் உள் வகுப்பின் நிகழ்வுகளை எங்கு உருவாக்கலாம் என்பதைப் பாதிக்கிறது.

   எங்கள் Seatவகுப்பு என அறிவிக்கப்பட்டால் , வேறு எந்த வகுப்பிலும் பொருட்களை publicஉருவாக்கலாம் . Seatவெளி வர்க்கத்தின் ஒரு பொருளும் இருக்க வேண்டும் என்பதே ஒரே தேவை.

   மூலம், நாங்கள் இதை ஏற்கனவே இங்கே செய்துள்ளோம்:

   
   public class Main {
   
      public static void main(String[] args) {
   
          Bicycle peugeot = new Bicycle("Peugeot", 120);
          Bicycle.Handlebar handlebar = peugeot.new Handlebar();
          Bicycle.Seat seat = peugeot.new Seat();
   
          seat.up();
          peugeot.start();
          handlebar.left();
          handlebar.right();
      }
   }
   

   Handlebarவகுப்பிலிருந்து உள் வகுப்பிற்கான அணுகலை நாங்கள் எளிதாகப் பெற்றோம் Main.

   உள் வகுப்பை என அறிவித்தால் private, வெளிப்புற வகுப்பிற்குள் மட்டுமே பொருட்களை உருவாக்க முடியும்.

   Seatநாம் இனி "வெளியில்" ஒரு பொருளை உருவாக்க முடியாது :

   
   private class Seat {
   
      // Methods
   }
   
   public class Main {
   
      public static void main(String[] args) {
   
          Bicycle bicycle = new Bicycle("Peugeot", 120, 40);
   
          // Bicycle.Seat has private access in Bicycle
          Bicycle.Seat seat = bicycle.new Seat();
      }
   }
   

   உங்களுக்கு ஏற்கனவே லாஜிக் புரிந்திருக்கும் :)

6. உள் வகுப்புகளுக்கான அணுகல் மாற்றிகள் சாதாரண மாறிகளைப் போலவே செயல்படுகின்றன.

   மாற்றியமைப்பானது protectedதுணைப்பிரிவுகள் மற்றும் ஒரே தொகுப்பில் உள்ள வகுப்புகளில் உள்ள நிகழ்வு மாறிக்கான அணுகலை வழங்குகிறது.

   protectedஉள் வகுப்புகளுக்கும் வேலை செய்கிறது. protectedஉள் வகுப்பின் பொருட்களை நாம் உருவாக்கலாம் :

   • வெளி வகுப்பில்;
   • அதன் துணைப்பிரிவுகளில்;
   • ஒரே தொகுப்பில் இருக்கும் வகுப்புகளில்.

   உள் வகுப்பில் அணுகல் மாற்றி ( ) இல்லையென்றால் package private, உள் வகுப்பின் பொருள்களை உருவாக்கலாம்:

   • வெளி வகுப்பில்;
   • ஒரே தொகுப்பில் இருக்கும் வகுப்புகளில்.

   நீங்கள் மாற்றியமைப்பவர்களை நீண்ட காலமாக அறிந்திருக்கிறீர்கள், எனவே இங்கு எந்த பிரச்சனையும் இல்லை.

இப்போதைக்கு அவ்வளவுதான் :) ஆனால் தளர்ச்சி அடையாதே! உள் வகுப்புகள் என்பது மிகவும் விரிவான தலைப்பு, அடுத்த பாடத்தில் தொடர்ந்து ஆராய்வோம். இப்போது நீங்கள் எங்கள் பாடத்தின் உள் வகுப்புகள் பற்றிய பாடத்தின் நினைவைப் புதுப்பிக்கலாம் . அடுத்த முறை, நிலையான உள்ளமை வகுப்புகளைப் பற்றி பேசலாம்.