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

1. நிலையான முறைகள்

நிலையான மாறிகள் கூடுதலாக, வகுப்புகள் நிலையான முறைகளையும் கொண்டிருக்கலாம்.

வழக்கமான முறைகள் ஒரு வகுப்பின் பொருள்களுடன் (உதாரணங்கள்) பிணைக்கப்படுகின்றன மற்றும் வகுப்பின் சாதாரண (நிலையற்ற) மாறிகளைக் குறிக்கலாம் (அத்துடன் நிலையான மாறிகள் மற்றும் முறைகள் ). நிலையான முறைகள் வகுப்பின் நிலையான பொருளுடன் பிணைக்கப்பட்டுள்ளன, மேலும் நிலையான மாறிகள் மற்றும்/அல்லது வகுப்பின் பிற நிலையான முறைகளை மட்டுமே அணுக முடியும்.

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

உதாரணமாக:

public class DataInfo
{
   public int getValue()
   {
      return 100;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      System.out.println(DataInfo.getValue()); // This will generate an error!
   }
}

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

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

static Type name(parameters)
{
   method code
}

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

public class Solution
{
   public static void main(String args[])
   {
      test();
   }

   public static void test()
   {
      int d = 2/0;
   }
}

மற்றொரு வகுப்பிலிருந்து நிலையான முறையை அழைக்க, நிலையான முறையின் பெயருக்கு முன் வகுப்பின் பெயரைக் குறிப்பிட வேண்டும். இந்த கட்டமைப்பின் பொதுவான தோற்றம் பின்வருமாறு:

Type name = ClassName.methodName(arguments)

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

int x = Math.min(a, b);

int min(int a, int b)

Thread.sleep(200);

void sleep(long ms)

Path path = Path.of("c:\\readme.txt");

Path of(String str)

2. நிலையான vs சாதாரண (நிலையற்ற) முறைகள்

நிலையான முறைகளுக்கும் சாதாரண முறைகளுக்கும் என்ன வித்தியாசம்?

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

இரண்டு வகையான முறைகளுக்கு இடையிலான வேறுபாடுகள் பின்வரும் அட்டவணையில் வெளிப்படுத்தப்பட்டுள்ளன:

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

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

இரண்டாவதாக, சில நேரங்களில் நீங்கள் ஒரு மாறியின் ஒரே ஒரு நிகழ்வு இருக்க வேண்டும். எடுத்துக்காட்டாக, System.out( சிஸ்டம் கிளாஸ் ஸ்டாடிக் அவுட் மாறி ).

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

வகுப்பின் ஒரு நிகழ்வுக்கு கட்டுப்பட்டது

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

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

வகுப்பின் சாதாரண முறைகளை அழைக்கலாம்

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

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = min(a, b);
   return min(t, c);
}

int min(int a, int b)
{
   return a < b ? a : b;
}

int min(int a, int b, int c)
{
   int t = this.min(a, b);
   return this.min(t, c);
}

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

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

சரி, எந்தப் பொருளைக் கொண்டு அதை அழைப்போம்? எல்லாவற்றிற்கும் மேலாக, எங்கள் வகுப்பின் ஒரு நிகழ்வு கூட இன்னும் இல்லை!

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

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

வகுப்பின் சாதாரண மாறிகளை அணுகலாம்

ஒரு சாதாரண முறையில் இருந்து ஒரு வகுப்பின் சாதாரண மாறிகளை நீங்கள் அணுகலாம், ஏனெனில் இது மறைமுக அளவுரு மூலம் வகுப்பின் நிகழ்விற்கான குறிப்பை எளிதாகப் பெறலாம் this.

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

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

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

யாருக்கும் தெரியாது! அதனால்தான், ஒரு பொருளைப் பற்றிய குறிப்பைக் கடந்து செல்லாமல், ஒரு நிலையான முறையிலிருந்து ஒரு சாதாரண முறையை நீங்கள் அழைக்க முடியாது !

வகுப்பின் நிலையான மாறிகளை அணுகலாம்

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

ஒரு பொருளின் மீது அழைக்கலாம்

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

Thread th = Thread.current();
th.sleep(1000);

Thread th = Thread.current();
Thread.sleep(1000);

Integer i = 1;
int x = i.parseInt("12");

Integer i = 1;
int x = Integer.parseInt("12");

"".valueOf(12);

String.valueOf(12);

வகுப்பில் அழைக்கலாம்

ஒரு வகுப்பில் நிலையான முறையை மட்டுமே நீங்கள் அழைக்க முடியும். ஒரு சாதாரண முறையை அழைக்க, நீங்கள் வகுப்பின் ஒரு நிகழ்வைக் குறிப்பிட வேண்டும். எனவே, இந்த கட்டமைப்பைப் பயன்படுத்தி நீங்கள் ஒரு சாதாரண முறையை அழைக்க முடியாது:ClassName.methodName(arguments)