நிலையான வகுப்புகள்

1. உள் வகுப்புகள்

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

ஜாவாவில், வகுப்புகளுக்குள் வகுப்புகளை அறிவிக்க நீங்கள் முழுமையாக அனுமதிக்கப்படுவீர்கள். மேலும் வகுப்புகளுக்குள் இருக்கும் வகுப்புகளுக்குள் இருக்கும் வகுப்புகள் கூட. எல்லாம் மிகவும் எளிமையானதாக தோன்றுகிறது:

class OuterClass
{
   variables of the class
   methods of the class

   class NestedClass
   {
      variables of the class
      methods of the class
   }
}

நாம் ஒரு வகுப்பிற்குள் மற்றொரு வகுப்பை அறிவிக்கிறோம். அவ்வளவு எளிமையானது.

உதாரணமாக:

public class Solution
{
   static ArrayList<Point> points = new ArrayList<Point>();

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;
      points.add(point);
   }

   static class Point
   {
      int x;
      int y;
   }
}

உள்ளமைக்கப்பட்ட வகுப்புகள் நிலையான அல்லது நிலையானதாக இருக்கலாம். நிலையான உள்ளமை வகுப்புகள் வெறுமனே நிலையான உள்ளமை வகுப்புகள் என்று அழைக்கப்படுகின்றன . நிலையான அல்லாத உள்ளமை வகுப்புகள் உள் வகுப்புகள் ( உள் வகுப்புகள் ) என்று அழைக்கப்படுகின்றன.

2. நிலையான வகுப்புகள்

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

வகுப்பின் பெயர்

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

OuterClass.InnerClass

எடுத்துக்காட்டுகள்:

com.codegym.Solution

Point

com.codegym.Solution.Point

java.util.Map

Entry

java.util.Map.Entry

java.util.Files

DirectoryStream

java.util.Files.DirectoryStream

java.nio.WindowsPath

Closeable

java.nio.WindowsPath.Closeable

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

JDK இல் உள்ள உள்ளமைக்கப்பட்ட வகுப்பின் ஒரு பொதுவான உதாரணம் வகுப்பின் Entryஉள்ளே இருக்கும் Mapவகுப்பாகும். ஒரு பொருளில் சேமிக்கப்பட்ட விசை-மதிப்பு ஜோடிகளின் தொகுப்பைப் பெற விரும்பினால் HashMap, முறையைப் பயன்படுத்தவும் entrySet(), இது a .Set<Map.Entry>

இது ஒரு வெளிப்புற வகுப்பு மற்றும் உள்ளமைக்கப்பட்ட வகுப்பின் எடுத்துக்காட்டு என்பதை நினைவில் கொள்க .Map.Entry

ஒரு பொருளை உருவாக்குதல்

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

OuterClass.NestedClass name = new OuterClass.NestedClass();

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

நிலையான முறைகளை அழைக்கிறது

நிலையான வகுப்பில் நிலையான முறைகள் இருந்தால், அவற்றை சாதாரண வகுப்புகளின் நிலையான முறைகளைப் போலவே அணுகலாம் (ஆனால் வகுப்பின் பெயர் இரண்டு பகுதிகளைக் கொண்டிருக்கும்).

OuterClass.NestedClass.staticMethod();

நிலையான மாறிகளை அணுகுகிறது

உள்ளமைக்கப்பட்ட வகுப்பின் பொது நிலையான மாறிகளை அணுகுவதும் எளிதானது:

OuterParent.NestedClass.nameOfStaticVariable

3. நிலையான வகுப்புகளின் அம்சங்கள்

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

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

உதாரணமாக:

public class Solution
{
   static ArrayList<Point> points;

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;
      points = new ArrayList<Point>();
      points.add(point);
   }

   static class Point
   {
      int x;
      int y;
   }
}

public class Solution
{
   static ArrayList<Point> points;

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;
      points = new ArrayList<Point>();
      points.add(point);
   }
}

class Point
{
   int x;
   int y;
}

நீங்கள் சில நிலையான உள்ளமைக்கப்பட்ட வகுப்பை எடுத்து அதன் வெளிப்புற வகுப்பிற்கு வெளியே நகர்த்தினால், மாற்றப்படும் ஒரே விஷயம் என்னவென்றால், புதிய வகுப்பானது அதன் முந்தைய வெளிப்புற வகுப்பின் மாறிகள் மற்றும் முறைகளை அணுக முடியாது .private static

உதாரணமாக:

public class Solution
{
   private static ArrayList<Point> points;

   static class Point
   {
      int x;
      int y;

      public static void main(String[] args)
      {
         Point point = new Point();
         point.x = 100;
         point.y = 200;

         // This will work
         points = new ArrayList<Point>();
         points.add(point);
      }
   }
}

public class Solution
{
   private static ArrayList<Point> points;
}

class Point
{
   int x;
   int y;

   public static void main(String[] args)
   {
      Point point = new Point();
      point.x = 100;
      point.y = 200;

      // This will generate an error
      points = new ArrayList<Point>();
      points.add(point);
   }
}

mainசாதாரண Pointவகுப்பில் உள்ள முறை வகுப்பின் மாறியை அணுக முடியாது !private static pointsSolution

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

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