செயல்பாட்டு முறை

1. செயல்பாட்டு முறைகள்

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

எடுத்துக்காட்டாக, ஜாவாவில் Consumer<Type>இடைமுகம் உள்ளது, அதில் accept(Type obj)முறை உள்ளது. இந்த இடைமுகம் ஏன் தேவை?

ஜாவா 8 இல், சேகரிப்புகளுக்கு ஒரு forEach()முறை உள்ளது, இது சேகரிப்பின் ஒவ்வொரு உறுப்புக்கும் சில செயல்களைச் செய்ய உங்களை அனுமதிக்கிறது . இங்கே செயல்பாட்டு இடைமுகம் செயலை முறைக்கு அனுப்ப பயன்படுகிறது . Consumer<T>forEach()

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

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "Hello", "how's", "life?");

list.forEach( (s) -> System.out.println(s) );

கம்பைலர் மேலே உள்ள குறியீட்டை கீழே உள்ள குறியீட்டிற்கு மாற்றும்:

ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "Hello", "how's", "life?");

list.forEach(new Consumer<String>()
{
   public void accept(String s)
   {
      System.out.println(s));
   }
});

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

2. முறை குறிப்பு

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

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

list.forEach( (s) -> System.out.println(s) );

list.forEach( s -> System.out.println(s) );

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

இரண்டாவதாக, நீங்கள் இதை இப்படி எழுதலாம்:

list.forEach( System.out::println );

இதுவும் அதே குறியீடாகும். க்குப் பிறகு அடைப்புக்குறிகள் இல்லை என்பதை நினைவில் கொள்ளவும் println.

இங்கே எங்களிடம் அதே குறியீடு உள்ளது - ஒரு முறை அழைப்பு:

object::method

x -> object.method(x)

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

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

இது எளிமையான மற்றும் மிகவும் சுருக்கமான குறியீடாகும்.

3. கட்டமைப்பாளர்

I/O ஸ்ட்ரீம்களுடன் பணிபுரியும் போது இரட்டைப் பெருங்குடல்களைக் கொண்ட முறை குறிப்புகள் மிகவும் எளிதாக இருக்கும். இதை சிறிது நேரம் கழித்து பார்க்கலாம்.

இதற்கிடையில், ஒரு முறை குறிப்பை அனுப்ப 3 பிரபலமான வழிகளைப் பற்றி பேசலாம்:

ஒரு பொருளின் முறை பற்றிய குறிப்பு

ஒரு பொருளின் முறைக்கு ஒரு குறிப்பை அனுப்ப, நீங்கள் ஏதாவது எழுத வேண்டும் . இந்த குறியீடு சமமானதாகும் .object::method
x -> object.method(x)

சிறப்பு thisமற்றும் superமாறிகள் பொருளாகப் பயன்படுத்தப்படலாம்.

ஒரு வகுப்பின் முறை பற்றிய குறிப்பு

நிலையான முறைக்கு ஒரு குறிப்பை அனுப்ப, நீங்கள் இதைப் போன்ற ஒன்றை எழுத வேண்டும் . இந்தக் குறியீடு போன்ற குறியீடுகளாக மாற்றப்படும்class::methodx -> class.method(x);

ஒரு கட்டமைப்பாளரைப் பற்றிய குறிப்பு

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

எடுத்துக்காட்டாக, நீங்கள் சேகரிப்புகளுக்கான அழித்தல் வகையைப் பெறலாம் மற்றும் toArray()விரும்பிய வரிசையை உருவாக்கும் ஒரு கட்டமைப்பாளருக்கான குறிப்பை முறையை அனுப்பலாம்:toArray(int[]::new);