ఫంక్షనల్ పద్ధతి

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);