జావాలో ఇంటర్ఫేస్ అంటే ఏమిటి మరియు దానిని ఎలా అమలు చేయాలి?

' ఇంటర్ఫేస్ జావా ప్రోగ్రామింగ్ భాషలో సంగ్రహణను సాధించే అధునాతన స్థాయి. జావా ఇంటర్ఫేస్ సహాయపడుతుంది సంక్లిష్టత తగ్గింపు కోడ్‌లో మరియు సులభతరం చేస్తుంది చదవడానికి . ఈ వ్యాసంలో, నేను మీకు జావా ఇంటర్ఫేస్ను ఈ క్రింది డాకెట్ ద్వారా వివరిస్తాను.

• జావా ఇంటర్ఫేస్ అంటే ఏమిటి?
• మనకు ఇంటర్ఫేస్ ఎందుకు అవసరం?
• జావా ఇంటర్ఫేస్ డిక్లేరింగ్: సింటాక్స్
• జావా ఇంటర్ఫేస్ ఉదాహరణ
• జావా ఇంటర్ఫేస్ గూడు
• తరగతి మరియు ఇంటర్ఫేస్ మధ్య వ్యత్యాసం
• ఇంటర్ఫేస్ యొక్క ప్రయోజనాలు మరియు అప్రయోజనాలు
• జావా ఇంటర్ఫేస్లో ముఖ్య పాయింట్లు

జావా ఇంటర్ఫేస్ అంటే ఏమిటి?

కంప్యూటర్ ఇంటర్ఫేస్ రెండు లేదా అంతకంటే ఎక్కువ వ్యవస్థలను వేరుచేసే సరిహద్దుగా పిలుస్తారు. ఇది వ్యవస్థలోని భాగాల మధ్య సంకేతాలను, ఆదేశాలను లేదా ప్రోటోకాల్‌లను మార్పిడి చేస్తుంది.

జావా సంగ్రహణ పద్ధతి లోపల వ్రాసిన అమలు తర్కాన్ని దాచడం ద్వారా ఒక నిర్దిష్ట పద్ధతి యొక్క కార్యాచరణను అందిస్తుంది. అదేవిధంగా, జావా ఇంటర్ఫేస్ కూడా ఒక వియుక్త తరగతి, ఇందులో మెథడ్ డిక్లరేషన్ ఉంటుంది, కానీ దాని నిర్వచనం కాదు. ఒక తరగతి పనిముట్లు నైరూప్య పద్ధతులను వారసత్వంగా పొందటానికి ఒక ఇంటర్ఫేస్. నైరూప్య పద్ధతులతో పాటు, ఒక ఇంటర్ఫేస్ కూడా చేర్చవచ్చు స్థిరాంకాలు, స్థిర పద్ధతులు, సమూహ ఇంటర్‌ఫేస్‌లు మరియు డిఫాల్ట్ పద్ధతులు.

తరగతి మరియు ఇంటర్ఫేస్ మధ్య సారూప్యతలు.

ఇంటర్ఫేస్ జావాలోని సాధారణ తరగతికి పూర్తిగా సమానంగా ఉంటుంది. ఇంటర్ఫేస్ వియుక్త పద్ధతులను కలిగి ఉంటుంది మరియు ఈ పద్ధతులు అమలు చేయడానికి రూపొందించబడ్డాయి. ఈ ప్రక్రియ కేవలం వారసత్వానికి సమానం, ఇది తరగతుల విషయానికి వస్తే సాధారణం. సారూప్యతలపై మేము మరింత చర్చిస్తాము.

• తరగతి మాదిరిగానే, ఇంటర్ఫేస్ కూడా అవసరమైనన్ని పద్ధతులను కలిగి ఉంటుంది.
• తరగతుల మాదిరిగానే, ఇంటర్ఫేస్ కూడా a తో వ్రాయబడుతుంది .జావా పొడిగింపు ఫైల్.
• ఆశ్చర్యకరంగా, ఇంటర్ఫేస్ కోసం బైట్‌కోడ్ a లో కనిపిస్తుంది .క్లాస్ ఫైల్.
• ఒక ఇంటర్ఫేస్ ప్యాకేజీ రూపంలో చూపబడుతుంది మరియు వాటి బైట్‌కోడ్ ప్యాకేజీ పేరుతో సరిపోయే డైరెక్టరీలో ఉంటుంది.

మనకు ఇంటర్ఫేస్ ఎందుకు అవసరం?

జావా మద్దతు ఇవ్వదు బహుళ వారసత్వం, దీని కారణంగా, ఇది ఒక సందర్భంలో ఒకటి కంటే ఎక్కువ తరగతులను విస్తరించడానికి తరగతులను అనుమతించదు. పిల్లల తరగతులు యొక్క లక్షణాలను వారసత్వంగా పొందలేకపోయింది బహుళ మాతృ తరగతులు ఒకే సందర్భంలో, దాని ఫలితంగా వజ్రాల సమస్య. ఈ సమస్యను అధిగమించడానికి, ఇంటర్ఫేస్ పరిచయం చేయబడింది. ఈ సమస్యను ఒక ఉదాహరణ ద్వారా అర్థం చేసుకుందాం.

మన దగ్గర రెండు విమానాలు ఉన్నాయని అనుకుందాం, ఒకటి మాత్రమే మోయగలదు ప్రయాణీకులు, మరొకటి మాత్రమే స్థానం. ఇప్పుడు, మనకు అవసరం వారసత్వంగా కార్గో విమానం మరియు ప్రయాణీకుల విమానం రెండింటి లక్షణాలు. ఈ పరిష్కారం ముగుస్తున్నందున జావా మద్దతు ఇవ్వదు అస్పష్టత రెండు విమానాల మధ్య.

కానీ, మీరు జావాను ఒక విమానం వారసత్వంగా పొందుతున్నారని భావించడం ద్వారా దీనిని సాధ్యం చేయగలిగితే అమలు చేస్తోంది ఇతర విమానంలో ఉన్న పద్ధతులు. ఇది ప్రయాణీకులు మరియు కార్గో సామాను రెండింటినీ తీసుకునే వాణిజ్య విమానం లాంటిది. ఇంటర్ఫేస్ ఒక పెద్ద విమానం తయారు చేయడం లాంటిది, ఇది రెండు పనులను ఒకదానికొకటి భాగాలతో జోక్యం చేసుకోకుండా చేయగలదు, బదులుగా కేవలం పద్ధతులను అరువుగా తీసుకుంటుంది ఇంటర్ఫేస్ క్లాస్.

// క్లాస్ ఎ కోడ్

ప్యాకేజీ బహుళ తరగతి A {void msg () {System.out.println ('హలో')}}

// క్లాస్ బి కోడ్

ప్యాకేజీ బహుళ తరగతి B {void msg () {System.out.println ('స్వాగతం')}}

క్లాస్ సి కోడ్

ప్యాకేజీ బహుళ తరగతి సి విస్తరిస్తుంది A, B {// ఇది జావా చేత అంగీకరించబడదు, ఇది లోపం విసిరివేస్తుంది మరియు కోడ్ అమలు చేయబడదు. పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {C ఆబ్జెక్ట్ = కొత్త సి () ఆబ్జెక్ట్.ఎమ్ఎస్జి ()}}

అవుట్పుట్:

లోపం. ఈ ప్రత్యేక విధానం మినహాయింపును విసురుతుంది. జావా బహుళ వారసత్వాలకు మద్దతు ఇవ్వదు. ఈ లోపం అంటారు వజ్రాల సమస్య 

ఇంటర్ఫేస్ ఉపయోగించి ఒక పరిష్కారాన్ని ప్రయత్నిద్దాం, పిల్లల తరగతులు నుండి పద్ధతులను యాక్సెస్ చేయవచ్చు బహుళ తల్లిదండ్రులు ఒకే సందర్భంలో తరగతులు.

// ఇంటర్ఫేస్ కోడ్

ప్యాకేజీ MIS పబ్లిక్ ఇంటర్ఫేస్ పరిష్కారం {పబ్లిక్ శూన్య హలో () పబ్లిక్ శూన్య స్వాగతం ()}

// క్లాస్ కోడ్

ప్యాకేజీ MIS పబ్లిక్ క్లాస్ క్లాస్ఏ పరిష్కారాన్ని అమలు చేస్తుంది {పబ్లిక్ శూన్య హలో () {java.lang.System.out.println ('హలో వరల్డ్')} పబ్లిక్ శూన్య స్వాగతం () {java.lang.System.out.println ('ఎడురేకాకు స్వాగతం .

అవుట్పుట్:

హలో వరల్డ్

ఎడురేకాకు స్వాగతం

జావా ఇంటర్ఫేస్ డిక్లేరింగ్: సింటాక్స్

ఇంటర్ఫేస్ ఇంటర్ఫేస్_పేరు {// స్థిరమైన క్షేత్రాలను ప్రకటించండి // పద్ధతులను ప్రకటించండి () // డిఫాల్ట్ పద్ధతులు}

జావా ఇంటర్ఫేస్లో ఒక ఉదాహరణ ద్వారా చూద్దాం

జావా ఇంటర్ఫేస్ ఉదాహరణ

జావా ఇంటర్ఫేస్ ఆధారంగా సరళమైన కాలిక్యులేటర్‌ను క్రియేట్ చేద్దాం.

// ఇంటర్ఫేస్ కోడ్

ప్యాకేజీ బేసిక్ ఆపరేషన్స్ పబ్లిక్ ఇంటర్ఫేస్ మ్యాథ్స్ {పబ్లిక్ శూన్య యాడ్ () పబ్లిక్ శూన్య ఉప () పబ్లిక్ శూన్యమైన ముల్ () పబ్లిక్ శూన్యమైన డివి ()}

// క్లాస్ కోడ్

ప్యాకేజీ బేసిక్ ఆపరేషన్స్ దిగుమతి java.util.Scanner పబ్లిక్ క్లాస్ స్టూడెంట్ 1 గణితాలను అమలు చేస్తుంది public public పబ్లిక్ శూన్య యాడ్‌ను ఓవర్రైడ్ చేయండి () {స్కానర్ kb = కొత్త స్కానర్ (System.in) System.out.println ('అదనంగా చేయడానికి ఏదైనా రెండు పూర్ణాంక విలువలను నమోదు చేయండి') int a = kb.nextInt () int b = kb.nextInt () int s = a + b System.out.println ('+ a +' మరియు '+ b +' మొత్తం '+ s) public public పబ్లిక్ శూన్య ఉపను అధిగమించండి () {స్కానర్ kb = క్రొత్త స్కానర్ (System.in) System.out.println ('సబ్‌స్ట్రాక్షన్ చేయడానికి ఏదైనా రెండు పూర్ణాంక విలువలను నమోదు చేయండి') int a = kb.nextInt () int b = kb.nextInt () int s = ab System.out.println ('+ a +' మరియు '+ b +' యొక్క వ్యత్యాసం '+ s) public public పబ్లిక్ శూన్యమైన ముల్ () ని ఓవర్రైడ్ చేయండి {స్కానర్ kb = క్రొత్త స్కానర్ (System.in) System.out.println (' ఎంటర్ చెయ్యండి ఏదైనా రెండు పూర్ణాంక విలువలు గుణకారం ') int a = kb.nextInt () int b = kb.nextInt () int s = a * b System.out.println (' '+ a +' మరియు '+ b +' యొక్క ఉత్పత్తి '+ s) public public పబ్లిక్ శూన్యమైన డివి () {స్కానర్ kb = క్రొత్త స్కానర్ (System.in) System.out.println ('ఏదైనా రెండు పూర్ణాంక విలువల విభాగాన్ని నమోదు చేయండి') int a = kb.nextInt () int b = kb.nextInt () int s = a / b System.out.p rintln ('+ a +' మరియు '+ b +' యొక్క పరిమాణం '+ s)} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {student1 Edureka1 = new student1 () Edureka1.add () Edureka1.sub () Edureka1. mul () Edureka1.div ()}}

అవుట్పుట్:

మరింత ముందుకు, మేము జావా ఇంటర్ఫేస్ గూడు నేర్చుకుంటాము.

జావా ఇంటర్ఫేస్ గూడు

ఇంటర్ఫేస్ గూడు మరొక లోపల ఇంటర్ఫేస్ను ప్రకటించే ప్రక్రియ ఉన్న ఇంటర్ఫేస్ లేదా లోపల ఇంటర్ఫేస్ను ప్రకటించడం a తరగతి. నెస్టెడ్ ఇంటర్ఫేస్ను కూడా అంటారు ఇన్నర్ ఇంటర్ఫేస్.

నెస్టెడ్ ఇంటర్ఫేస్ యాక్సెస్ చేయబడదు నేరుగా . అందువల్ల, నేమ్‌స్పేస్‌లను వాటికి సంబంధించిన వాటితో సమూహపరచడం ద్వారా వాటిని పరిష్కరించడానికి నెస్టింగ్ అమలు చేయబడుతుంది ఇంటర్ఫేస్లు మరియు తరగతులు. ఈ విధానం ద్వారా,మేము కాల్ చేయవచ్చు సమూహ ఇంటర్ఫేస్ ద్వారా Uter టర్ క్లాస్ లేదా ఇంటర్ఫేస్ పేరు తరువాత a చుక్క( . ) , మరియు ఇంటర్ఫేస్ పేరు.

దీని ఆధారంగా కొన్ని ఉదాహరణలు ప్రయత్నిద్దాం ఇంటర్ఫేస్ గూడు. మొదట, గూడు చేయడానికి ప్రయత్నిద్దాం a జావా ఇంటర్ఫేస్ మరొక లోపల జావా ఇంటర్ఫేస్ క్రింద చూపిన విధంగా:

// ఇంటర్ఫేస్ కోడ్

ప్యాకేజీ నెస్ట్ పబ్లిక్ ఇంటర్ఫేస్ uter టర్ ఇంటర్‌ఫేస్ {శూన్య ప్రదర్శన () ఇంటర్ఫేస్ ఇన్నర్‌ఇంటర్‌ఫేస్ {శూన్యమైన ఇన్నర్‌మెథడ్ ()}}

// క్లాస్ కోడ్

ప్యాకేజీ నెస్ట్ క్లాస్ NestedInterfaceDemo uter టర్ ఇంటర్‌ఫేస్.ఇన్నర్ ఇంటర్‌ఫేస్ {పబ్లిక్ శూన్యమైన ఇన్నర్‌మెథడ్ () {int n = 10, t1 = 0, t2 = 1 System.out.print ('మొదటి' + n + 'నిబంధనలు:') (int i = 1 i & lt = n ++ i) {System.out.print (t1 + '+') int sum = t1 + t2 t1 = t2 t2 = sum} System.out.println ('nested InnerInterface method నుండి ప్రింటింగ్ ...! n ')} పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {uter టర్ఇంటర్ఫేస్.ఇన్నర్ఇంటర్ఫేస్ ఆబ్జ్ = కొత్త నెస్టెడ్ఇంటర్ఫేస్డెమో () ఆబ్జెక్ట్.ఇన్నర్ మెథడ్ ()}}

అవుట్పుట్:

మొదటి 10 నిబంధనలు: 0 + 1 + 1 + 2 + 3 + 5 + 8 + 13 + 21 + 34 + నెస్టెడ్ ఇన్నర్ ఇంటర్‌ఫేస్ పద్ధతి నుండి ప్రింటింగ్ ...!

ఇప్పుడు, గూడు చేయడానికి ప్రయత్నిద్దాం a జావా ఇంటర్ఫేస్ లోపల ఒక జావా క్లాస్.

// ఇంటర్ఫేస్ కోడ్

ప్యాకేజీ నెస్ట్ 2 పబ్లిక్ క్లాస్ ఎడురేకాక్లాస్ {ఇంటర్ఫేస్ ఎడురేకా ఇంటర్‌ఫేస్ {శూన్యమైన నెస్టెడ్ మెథడ్ ()}}

// క్లాస్ కోడ్

ప్యాకేజీ Nest2 class NestedInterfaceDemo2 EdurekaClass.EdurekaInterface {public void NestedMethod () {స్ట్రింగ్ ఇన్పుట్ = 'Edureka' బైట్ [] strAsByteArray = input.getBytes () బైట్ [] result = new byte .length i ++) result [i] = strAsByteArray [strAsByteArray.length-i-1] System.out.println (new string (result))} పబ్లిక్ స్టాటిక్ వాయిడ్ మెయిన్ (స్ట్రింగ్ అర్గ్స్ []) {EdurekaClass.EdurekaInterface obj = new NestedInterfaceDemo () obj.NestedMethod ()}}

అవుట్పుట్:

akerudE

ఇంటర్ఫేస్ క్లాస్‌తో సమానంగా కనిపిస్తున్నప్పటికీ, వాటి మధ్య కొన్ని తేడాలు ఉన్నాయి, వాటి తేడాలను చర్చిద్దాం.

జావా క్లాస్ మరియు జావా ఇంటర్ఫేస్ మధ్య వ్యత్యాసం

జావా ఇంటర్ఫేస్ యొక్క ప్రయోజనాలు మరియు అప్రయోజనాలు

ప్రయోజనాలు:

• జావా ఇంటర్ఫేస్ మద్దతు ఇస్తుంది బహుళ వారసత్వం.
• సంక్లిష్ట ప్రోగ్రామింగ్ విధానాలను విచ్ఛిన్నం చేయడానికి మరియు సరళీకృతం చేయడానికి ప్రోగ్రామర్లను జావా ఇంటర్ఫేస్ అనుమతిస్తుంది డిపెండెన్సీలు వస్తువుల మధ్య.
• జావా ఇంటర్ఫేస్ చేస్తుంది డేటా సభ్యులు మరియు పద్ధతులు ఒక అనువర్తనంలో వదులుగా కలుపుతారు.

ప్రతికూలతలు:

స్క్లైట్ సమీక్ష కోసం db బ్రౌజర్

• జావా ఇంటర్ఫేస్ యొక్క ఉపయోగం తగ్గిస్తుంది అమలు వేగం అప్లికేషన్ యొక్క.
• అనువర్తనంలోని జావా ఇంటర్‌ఫేస్‌లు పెద్ద ఎత్తున పదేపదే ఉపయోగించబడతాయి లేదా అస్సలు ఉపయోగించబడవు.

జావా ఇంటర్ఫేస్లో ముఖ్య పాయింట్లు

• ఇంటర్ఫేస్లో ప్రకటించిన పద్ధతుల్లో ఏదీ పూర్తి సంగ్రహణను అందించే శరీరాన్ని కలిగి లేదు.
• ఇంటర్ఫేస్ యొక్క వస్తువును సృష్టించడం సాధ్యం కాదు. అందువల్ల, ఇంటర్ఫేస్ యొక్క ఇన్‌స్టాంటియేషన్ సాధ్యం కాదు.
• కీవర్డ్ పనిముట్లను ఉపయోగించి క్లాస్ ఇంటర్ఫేస్ను అమలు చేయగలదు. దీనిని ఒక ఉదాహరణ ద్వారా చూద్దాం.

// ఇంటర్ఫేస్ కోడ్

ప్యాకేజీ extInterface public interface extInterface {public void method1 () public void method2 ()}

// క్లాస్ కోడ్

ప్యాకేజీ extInterface import java.util.Scanner class Edureka extInterface {public void method1 () {System.out.println ('method1 అమలు') స్కానర్ స్కానర్ = క్రొత్త స్కానర్ (System.in) System.out.println ('సంఖ్యను నమోదు చేయండి జావాలో వర్గమూలాన్ని కనుగొనడానికి: ') డబుల్ స్క్వేర్ = స్కానర్.నెక్స్ట్ డబుల్ () డబుల్ స్క్వేర్ రూట్ = మ్యాథ్.స్క్ర్ట్ (స్క్వేర్) System.out.printf (' సంఖ్య యొక్క వర్గమూలం:% f అంటే:% f% n ', చదరపు, స్క్వేర్ రూట్)} పబ్లిక్ శూన్య పద్ధతి 2 () {System.out.println ('పద్ధతి 2 అమలు')} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ ఆర్గ్ []) {extInterface obj = new Edureka () obj.method1 ()}}

అవుట్పుట్:

పద్ధతి 1 యొక్క అమలు జావాలో వర్గమూలాన్ని కనుగొనడానికి సంఖ్యను నమోదు చేయండి: 16 సంఖ్య యొక్క వర్గమూలం: 16.0: 4.0

• ఒక తరగతి ఒకే సందర్భంలో బహుళ వారసత్వాలను అమలు చేయగలదు. కింది కోడ్ ద్వారా దాన్ని అర్థం చేసుకుందాం.

// ఇంటర్ఫేస్ 1 కోడ్

ప్యాకేజీ విస్తరించు పబ్లిక్ ఇంటర్ఫేస్ ఇంటర్ఫేస్ 1 {పబ్లిక్ శూన్యమైన ఆర్మ్‌స్ట్రాంగ్ ()}

// ఇంటర్ఫేస్ 2 కోడ్

ప్యాకేజీ విస్తరించు పబ్లిక్ ఇంటర్ఫేస్ ఇంటర్ఫేస్ 2 {పబ్లిక్ శూన్య ప్రైమ్ ()} // క్లాస్ కోడ్ ప్యాకేజీ విస్తరించు పబ్లిక్ క్లాస్ ఎడురేకా 2 ఇంటర్ఫేస్ 1, ఇంటర్ఫేస్ 2 {పబ్లిక్ శూన్య ఆర్మ్‌స్ట్రాంగ్ () {int c = 0, a, temp int n = 153 // input temp = n (n & gt0) {a = n% 10 n = n / 10 c = c + (a * a * a)} if (temp == c) System.out.println ('ఆర్మ్‌స్ట్రాంగ్ సంఖ్య') else System.out.println ('ఆర్మ్‌స్ట్రాంగ్ సంఖ్య కాదు') System.out.println ('ఇంటర్ఫేస్ 1 కు విస్తరిస్తోంది')} పబ్లిక్ శూన్య ప్రైమ్ () {int i, m = 0, ఫ్లాగ్ = 0 int n = 3 // ఇన్పుట్ m = n / 2 ఉంటే (n == 0 || n == 1) {System.out.println (n + 'ప్రధాన సంఖ్య కాదు')} else {(i = 2i & lt = mi ++) {if (n% i == 0) {సిస్టమ్ .out.println (n + 'ప్రైమ్ నంబర్ కాదు') ఫ్లాగ్ = 1 బ్రేక్}} if (ఫ్లాగ్ == 0) {System.out.println (n + 'అనేది ప్రైమ్ నంబర్')}} System.out.println ('విస్తరిస్తోంది ఇంటర్ఫేస్ 2 కు)}} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ అర్గ్స్ []) {ఇంటర్ఫేస్ 2 ఆబ్జ్ = కొత్త ఎడురేకా 2 () ఆబ్జెక్ట్.ప్రైమ్ () ఇంటర్ఫేస్ 1 ఆబ్జెక్ట్ 1 (కొత్త ఎడురేకా 2 () ఆబ్జెక్ట్ 1.ఆర్మ్స్ట్రాంగ్ ()}}

అవుట్పుట్:

3 అనేది ప్రధాన సంఖ్య ఇంటర్ఫేస్ 2 ఆర్మ్‌స్ట్రాంగ్ సంఖ్యకు విస్తరించడం ఇంటర్ఫేస్ 1 కు విస్తరించడం

• జావా ఇంటర్‌ఫేస్‌కు డిక్లరేషన్ సమయంలో ప్రారంభించినట్లు ప్రకటించిన వేరియబుల్స్ అవసరం.
• ఇంటర్ఫేస్ కోసం యాక్సెస్ మాడిఫైయర్లు డిఫాల్ట్‌గా పబ్లిక్ స్టాటిక్ మరియు ఫైనల్‌కు సెట్ చేయబడతాయి. దీనిని ఒక ఉదాహరణ ద్వారా అర్థం చేసుకుందాం

// ఇంటర్ఫేస్ కోడ్

ప్యాకేజీ పరీక్ష పబ్లిక్ ఇంటర్ఫేస్ ప్రయత్నించండి public // పబ్లిక్ ఇంటెంట్ a = 10 // పబ్లిక్ స్టాటిక్ ఫైనల్ Int a = 10 // స్టాటిక్ Int a = 0 // ఫైనల్ Int a = 10 // int a = 10}

• పై ప్రకటనలన్నీ ఇంటర్ఫేస్ లోపల నిజం మరియు చెల్లుతాయి.
• జావా ఇంటర్ఫేస్ ఎన్ని ఇంటర్‌ఫేస్‌లను విస్తరించగలదు, కానీ ఎప్పటికీ అమలు చేయదు.
• జావా క్లాస్ ఎన్ని ఇంటర్‌ఫేస్‌లను అమలు చేయగలదు.
• జావా క్లాస్ ఒకే పద్ధతి పేరు మరియు విభిన్న రిటర్న్ రకంతో ఇంటర్‌ఫేస్‌లను అమలు చేయదు.
• ఒకే పద్ధతి పేరుతో రెండు లేదా అంతకంటే ఎక్కువ పద్ధతులు ఉంటే, బహుళ ఇంటర్‌ఫేస్‌లలో ఉంటే, అప్పుడు ఒకసారి పద్ధతిని అమలు చేస్తే సరిపోతుంది. దీనిని ఆచరణాత్మక ఉదాహరణతో అర్థం చేసుకుందాం.

// ఇంటర్ఫేస్ కోడ్

ప్యాకేజీ అదే పబ్లిక్ ఇంటర్ఫేస్ A {పబ్లిక్ శూన్య ప్రదర్శన ()} // ఇంటర్ఫేస్ కోడ్ ప్యాకేజీ అదే పబ్లిక్ ఇంటర్ఫేస్ B {పబ్లిక్ శూన్య ప్రదర్శన ()} // క్లాస్ కోడ్ ప్యాకేజీ అదే తరగతి అదే అమలు చేస్తుంది A, B {పబ్లిక్ శూన్య ప్రదర్శన () {System.out .println ('డేటాను ప్రదర్శిస్తోంది')} పబ్లిక్ స్టాటిక్ శూన్య ప్రధాన (స్ట్రింగ్ [] అర్గ్స్) {అదే ముద్రణ = క్రొత్త అదే () print.display ()}}

అవుట్పుట్:

ఎడురేకా ఇ-లెర్నింగ్‌కు స్వాగతం

దీనితో, మేము ఈ వ్యాసం ముగింపుకు వచ్చాము. ఇంటర్ఫేస్, సింటాక్స్, కార్యాచరణ, ఇంటర్ఫేస్ గూడు, జావా ఇంటర్ఫేస్ యొక్క ముఖ్య అంశాలు మరియు వాటిని ఉపయోగించి చేసే ఆపరేషన్ల యొక్క ప్రాముఖ్యతను మీరు అర్థం చేసుకున్నారని నేను ఆశిస్తున్నాను.

ఇప్పుడు మీరు జావా యొక్క ప్రాథమికాలను అర్థం చేసుకున్నారు, చూడండి ప్రపంచవ్యాప్తంగా 250,000 కంటే ఎక్కువ సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది. వసంత .

మాకు ప్రశ్న ఉందా? ఈ “జావా ఇంటర్ఫేస్” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.