అందరికీ నమస్కారం, మహిళలు మరియు పెద్దమనుషులు, సాఫ్ట్‌వేర్ ఇంజనీర్లు! ఇంటర్వ్యూ ప్రశ్నల గురించి మాట్లాడుకుందాం. మీరు దేనికి సిద్ధం కావాలి మరియు మీరు తెలుసుకోవలసిన వాటి గురించి. ఈ పాయింట్‌లను మొదటిసారిగా సమీక్షించడానికి లేదా అధ్యయనం చేయడానికి ఇది మంచి సమయం. నేను OOP, జావా సింటాక్స్, జావా మినహాయింపులు, సేకరణలు మరియు మల్టీథ్రెడింగ్ గురించి తరచుగా అడిగే ప్రశ్నల యొక్క విస్తృతమైన సేకరణతో ముగించాను, వీటిని నేను సౌలభ్యం కోసం అనేక భాగాలుగా విభజిస్తాను. అన్నింటినీ ఒకేసారి కవర్ చేయడం కష్టం, కానీ ప్రోగ్రామర్‌గా వారి మొదటి ఉద్యోగాన్ని కనుగొనడానికి సిద్ధమవుతున్న వారికి ఈ విషయం మంచి పునాదిని అందిస్తుందని నేను ఆశిస్తున్నాను. ఉత్తమ అవగాహన మరియు నిలుపుదల కోసం, నేను ఇతర వనరుల ద్వారా కూడా కలపమని సలహా ఇస్తున్నాను. మీరు అనేక విభిన్న కోణాల నుండి ఒక కాన్సెప్ట్‌ను సంప్రదించడం ద్వారా లోతైన అవగాహనను పొందవచ్చు. ముఖ్యమైన:మేము వెర్షన్ 8 కంటే ముందు జావా గురించి మాత్రమే మాట్లాడతాము. 9, 10, 11, 12 మరియు 13 వెర్షన్‌లలో వచ్చిన అన్ని ఆవిష్కరణలు ఇక్కడ పరిగణించబడవు. సమాధానాలను ఎలా మెరుగుపరచాలనే దానిపై ఏవైనా ఆలోచనలు/కామెంట్‌లు స్వాగతం . మీ పఠనాన్ని ఆస్వాదించండి. వెళ్దాం!
జావా ఇంటర్వ్యూ: OOP గురించి ప్రశ్నలు
1. జావా యొక్క లక్షణాలు ఏమిటి?
సమాధానం:
OOP భావనలు:
వస్తువు ధోరణి
వారసత్వం
ఎన్క్యాప్సులేషన్
బహురూపత
సంగ్రహణ
క్రాస్-ప్లాట్‌ఫారమ్: జావా ప్రోగ్రామ్‌ను ఎలాంటి మార్పులు లేకుండా ఏ ప్లాట్‌ఫారమ్‌లోనైనా అమలు చేయవచ్చు. వాస్తవానికి, దీనికి ఇన్‌స్టాల్ చేయబడిన JVM (జావా వర్చువల్ మిషన్) అవసరం.
అధిక పనితీరు: జస్ట్-ఇన్-టైమ్ (JIT) కంపైలర్ అధిక పనితీరును సాధ్యం చేస్తుంది. JIT కంపైలర్ బైట్‌కోడ్‌ను మెషిన్ కోడ్‌గా మారుస్తుంది మరియు JVM అమలును ప్రారంభిస్తుంది.
మల్టీథ్రెడింగ్: JVM అనేది అమలు యొక్క థ్రెడ్‌ను సృష్టిస్తుంది main thread. ప్రోగ్రామర్ థ్రెడ్ క్లాస్ నుండి లేదా ఇంటర్‌ఫేస్‌ను అమలు చేయడం ద్వారా బహుళ థ్రెడ్‌లను సృష్టించవచ్చు Runnable.
2. వారసత్వం అంటే ఏమిటి?
వారసత్వం అంటే ఒక తరగతి మరొక తరగతిని వారసత్వంగా పొందవచ్చు ( విస్తరింపబడిన కీవర్డ్‌ని ఉపయోగించి). మీరు వారసత్వంగా పొందిన తరగతి నుండి కోడ్‌ని మళ్లీ ఉపయోగించవచ్చని దీని అర్థం. ఇప్పటికే ఉన్న తరగతిని అని పిలుస్తారు superclassమరియు కొత్తగా సృష్టించబడిన తరగతి subclass. తల్లిదండ్రులు మరియు child.
public class Animal {
private int age;
}
public class Dog extends Animal {
}
ఎక్కడ Animalఉంది parentమరియు Dogఉంది child.
3. ఎన్క్యాప్సులేషన్ అంటే ఏమిటి?
జావా డెవలపర్ స్థానాల కోసం ఇంటర్వ్యూలలో ఈ ప్రశ్న తరచుగా అడగబడుతుంది. ఎన్క్యాప్సులేషన్ అనేది యాక్సెస్ మాడిఫైయర్‌లు, గెట్టర్‌లు మరియు సెట్టర్‌లను ఉపయోగించడం ద్వారా అమలును దాచడం. డెవలపర్‌లు అవసరమని భావించే చోట బాహ్య ప్రాప్యతను నిరోధించడానికి ఇది జరుగుతుంది. నిజ జీవితంలో ఒక సాధారణ ఉదాహరణ కారు. ఇంజిన్ యొక్క ఆపరేషన్‌కు మాకు ప్రత్యక్ష ప్రాప్యత లేదు. మనం చేయాల్సిందల్లా కీని ఇగ్నిషన్‌లో ఉంచి ఇంజిన్‌ను ఆన్ చేయడం. హుడ్ కింద జరిగే ప్రక్రియలు మా వ్యాపారం కాదు. అంతేకాకుండా, మేము ఇంజిన్ యొక్క కార్యాచరణలో జోక్యం చేసుకుంటే, అది ఊహించలేని పరిస్థితికి దారి తీస్తుంది, బహుశా కారు దెబ్బతింటుంది మరియు శరీరానికి హాని కలిగించవచ్చు. ప్రోగ్రామింగ్‌లో సరిగ్గా అదే జరుగుతుంది. ఇది వికీపీడియాలో బాగా వివరించబడింది. కోడ్‌జిమ్‌లో ఎన్క్యాప్సులేషన్ గురించి ఒక కథనం కూడా ఉంది .
4. పాలిమార్ఫిజం అంటే ఏమిటి?
పాలీమార్ఫిజం అనేది ఆబ్జెక్ట్ యొక్క నిర్దిష్ట రకం గురించి సమాచారం లేకుండా, ఒకే ఇంటర్‌ఫేస్‌తో వస్తువులను ఒకే విధంగా వ్యవహరించే ప్రోగ్రామ్ యొక్క సామర్ధ్యం. సామెత చెప్పినట్లుగా, "ఒక ఇంటర్ఫేస్ - అనేక అమలులు". పాలిమార్ఫిజంతో, మీరు భాగస్వామ్య ప్రవర్తనల ఆధారంగా వివిధ రకాల వస్తువులను కలపవచ్చు మరియు ఉపయోగించవచ్చు. ఉదాహరణకు, మేము ఒక జంతు తరగతిని కలిగి ఉన్నాము, దానికి ఇద్దరు వారసులు ఉన్నారు: కుక్క మరియు పిల్లి. జెనెరిక్ యానిమల్ క్లాస్‌లో అందరిచే భాగస్వామ్యం చేయబడిన ప్రవర్తన ఉంటుంది, ధ్వనిని చేసే సామర్థ్యం. యానిమల్ క్లాస్‌ని వారసత్వంగా పొందే ప్రతిదాన్ని సేకరించి "మేక్ సౌండ్" పద్ధతిని అమలు చేయాల్సిన అవసరం వచ్చినప్పుడు మేము పాలిమార్ఫిక్ సామర్థ్యాలను ఉపయోగిస్తాము. ఇది ఎలా కనిపిస్తుందో ఇక్కడ ఉంది:
List<Animal> animals = Arrays.asList(new Cat(), new Dog(), new Cat());
animals.forEach(animal -> animal.makeSound());
మరో మాటలో చెప్పాలంటే, పాలిమార్ఫిజం సహాయపడుతుంది. మరియు ఇది పాలిమార్ఫిక్ (ఓవర్‌లోడ్) పద్ధతులకు కూడా వర్తిస్తుంది. పాలిమార్ఫిజం ఎలా ఉపయోగించాలి
జావా సింటాక్స్ గురించి ఇంటర్వ్యూ ప్రశ్నలు
5. జావాలో కన్స్ట్రక్టర్ అంటే ఏమిటి?
నిర్మాణదారులు క్రింది లక్షణాలను కలిగి ఉన్నారు:
కొత్త వస్తువు సృష్టించబడినప్పుడు, ప్రోగ్రామ్ దానిని సృష్టించడానికి తగిన కన్స్ట్రక్టర్‌ని ఉపయోగిస్తుంది.
కన్స్ట్రక్టర్ ఒక పద్ధతి వంటిది. రిటర్న్ వాల్యూ (శూన్యంతో సహా) లేదు మరియు దాని పేరు తరగతి పేరు వలె ఉంటుంది అనే వాస్తవం దాని విలక్షణమైన లక్షణాలు.
కన్స్ట్రక్టర్ స్పష్టంగా సృష్టించబడకపోతే, ఖాళీ కన్స్ట్రక్టర్ స్వయంచాలకంగా సృష్టించబడుతుంది.
కన్స్ట్రక్టర్‌ని భర్తీ చేయవచ్చు.
మీరు పారామీటర్‌లతో కన్‌స్ట్రక్టర్‌ను డిక్లేర్ చేస్తే, పారామీటర్‌లు లేనిది కూడా అవసరమైతే, మీరు దానిని విడిగా సృష్టించాలి, ఎందుకంటే ఇది స్వయంచాలకంగా సృష్టించబడదు.
6. ఏ రెండు తరగతులు వస్తువును వారసత్వంగా పొందవు?
ట్రిక్ ప్రశ్నల ద్వారా మోసపోకండి - అలాంటి తరగతులు లేవు. అన్ని తరగతులు ఆబ్జెక్ట్ క్లాస్‌ని నేరుగా లేదా పూర్వీకుల ద్వారా వారసత్వంగా పొందుతాయి!
7. లోకల్ వేరియబుల్ అంటే ఏమిటి?
జావా డెవలపర్‌ల కోసం ఇది మరొక ప్రముఖ ఇంటర్వ్యూ ప్రశ్న. స్థానిక వేరియబుల్ అనేది ఒక పద్ధతిలో నిర్వచించబడిన వేరియబుల్ మరియు ఆ పద్ధతిని అమలు చేస్తున్నంత కాలం ఉంటుంది. అమలు ముగిసిన వెంటనే, స్థానిక వేరియబుల్ ఉనికిలో ఉండదు. మెయిన్() పద్ధతిలో helloMessage అనే స్థానిక వేరియబుల్‌ని ఉపయోగించే ప్రోగ్రామ్ ఇక్కడ ఉంది:
ఇన్‌స్టాన్స్ వేరియబుల్ అనేది క్లాస్ లోపల డిక్లేర్ చేయబడిన వేరియబుల్. ఒక వస్తువు ఉన్నంత కాలం అది ఉంటుంది. ఉదాహరణకు, మనకు బీ క్లాస్ ఉంది, ఇందులో రెండు ఇన్‌స్టాన్స్ వేరియబుల్స్ ఉన్నాయి - నెక్టార్‌లోడ్ మరియు మాక్స్‌నెక్టర్‌లోడ్:
public class Bee {
/**
* Current nectar load
*/
private double nectarLoad;
/**
* Maximum nectar that can the bee can collect.
*/
private double maxNectarLoad = 20.0;
...
}
9. యాక్సెస్ మాడిఫైయర్స్ అంటే ఏమిటి?
యాక్సెస్ మాడిఫైయర్‌లు తరగతులు, పద్ధతులు మరియు వేరియబుల్‌లకు యాక్సెస్‌ను అనుకూలీకరించడానికి ఒక మెకానిజం. యాక్సెస్‌ని పెంచే క్రమంలో జాబితా చేయబడిన కింది మాడిఫైయర్‌లు ఉన్నాయి:
private— ఈ యాక్సెస్ మాడిఫైయర్ పద్ధతులు, ఫీల్డ్‌లు మరియు కన్స్ట్రక్టర్‌లపై ఉపయోగించబడుతుంది. యాక్సెస్ వారు ప్రకటించబడిన తరగతికి పరిమితం చేయబడింది.
package-private (default)— ఇది తరగతులకు డిఫాల్ట్ యాక్సెస్ స్థాయి. క్లాస్, మెథడ్, వేరియబుల్ లేదా కన్స్ట్రక్టర్ డిక్లేర్ చేయబడిన నిర్దిష్ట ప్యాకేజీకి యాక్సెస్ పరిమితం చేయబడింది.
protectedpackage-private— ఈ యాక్సెస్ మాడిఫైయర్ మాడిఫైయర్‌తో క్లాస్‌ని వారసత్వంగా పొందే క్లాస్‌ల యాక్సెస్ జోడింపుతో అదే యాక్సెస్ స్థాయిని అందిస్తుంది protected.
public— ఈ యాక్సెస్ స్థాయి తరగతులకు కూడా ఉపయోగించబడుతుంది. ఈ యాక్సెస్ స్థాయి అంటే అప్లికేషన్ అంతటా పూర్తి యాక్సెస్ ఉంది.
10. మెథడ్ ఓవర్‌రైడింగ్ అంటే ఏమిటి?
పిల్లల తరగతి దాని మాతృ తరగతి ప్రవర్తనను మార్చాలనుకున్నప్పుడు మేము పద్ధతులను భర్తీ చేస్తాము. పేరెంట్ మెథడ్‌లో ఉన్నదానిని మనం కూడా చేయవలసి వస్తే, మేము పిల్లలలో super.methodName()ని ఉపయోగించవచ్చు, ఇది పేరెంట్ పద్ధతిని అమలు చేస్తుంది. ఆ తర్వాత మన అదనపు తర్కాన్ని జోడించవచ్చు. తప్పనిసరిగా గమనించవలసిన అవసరాలు:
పద్ధతి సంతకం ఒకేలా ఉండాలి
తిరిగి వచ్చే విలువ తప్పనిసరిగా ఒకే విధంగా ఉండాలి
11. పద్ధతి సంతకాలు అంటే ఏమిటి?
పద్ధతి సంతకం అనేది పద్ధతి పేరు మరియు పద్ధతి తీసుకునే వాదనల కలయిక. పద్ధతులను ఓవర్‌లోడ్ చేస్తున్నప్పుడు పద్ధతి సంతకం అనేది ఒక పద్ధతి యొక్క ప్రత్యేక గుర్తింపు.
12. పద్ధతి ఓవర్‌లోడింగ్ అంటే ఏమిటి?
మెథడ్ ఓవర్‌లోడింగ్ అనేది పాలిమార్ఫిజం యొక్క లక్షణం, దీనిలో మేము ఒకే చర్యను చేసే బహుళ పద్ధతులను రూపొందించడానికి పద్ధతి సంతకాన్ని మారుస్తాము:
అదే పేరు
వివిధ వాదనలు
వివిధ రిటర్న్ రకాలు ఉండవచ్చు
ఉదాహరణకు, ArrayListతరగతి యొక్క add()పద్ధతిని ఓవర్‌లోడ్ చేయవచ్చు, ఇన్‌పుట్ ఆర్గ్యుమెంట్‌లను బట్టి వేరే మార్గాల్లో జోడించడానికి మమ్మల్ని అనుమతిస్తుంది:
add(Object o)- ఈ పద్ధతి కేవలం ఒక వస్తువును జోడిస్తుంది
add(int index, Object o)- ఈ పద్ధతి నిర్దిష్ట సూచిక వద్ద ఒక వస్తువును జోడిస్తుంది
add(Collection<Object> c)- ఈ పద్ధతి వస్తువుల జాబితాను జోడిస్తుంది
add(int index, Collection<Object> c)- ఈ పద్ధతి నిర్దిష్ట సూచిక నుండి ప్రారంభమయ్యే వస్తువుల జాబితాను జోడిస్తుంది.
13. ఇంటర్ఫేస్ అంటే ఏమిటి?
Java బహుళ వారసత్వానికి మద్దతు ఇవ్వదు. ఈ పరిమితిని అధిగమించడానికి, మనకు తెలిసిన మరియు ఇష్టపడే ఇంటర్‌ఫేస్‌లు జోడించబడ్డాయి;) చాలా కాలం వరకు, ఇంటర్‌ఫేస్‌లు ఎటువంటి అమలు లేకుండా కేవలం పద్ధతులను కలిగి ఉన్నాయి. ఈ సమాధానం సందర్భంలో, వాటి గురించి మాట్లాడుకుందాం. ఉదాహరణకి:
ఇంటర్‌ఫేస్‌లోని అన్ని పద్ధతులు పబ్లిక్ మరియు నైరూప్యమైనవి
అన్ని వేరియబుల్స్ పబ్లిక్ స్టాటిక్ ఫైనల్
తరగతులు ఇంటర్‌ఫేస్‌లను వారసత్వంగా పొందవు (అనగా మేము విస్తరించే కీవర్డ్‌ని ఉపయోగించము). బదులుగా, తరగతులు వాటిని అమలు చేస్తాయి (అంటే మేము పనిముట్ల కీవర్డ్‌ని ఉపయోగిస్తాము). అంతేకాకుండా, మీకు కావలసినన్ని ఇంటర్‌ఫేస్‌లను మీరు అమలు చేయవచ్చు.
ఇంటర్‌ఫేస్‌ను అమలు చేసే తరగతులు తప్పనిసరిగా ఇంటర్ఫేస్లో ఉన్న అన్ని పద్ధతుల అమలును అందించాలి.
ఇలా:
public class Cat implements Animal {
public void makeSound() {
// Method implementation
}
public void eat() {
// Implementation
}
public void sleep() {
// Implementation
}
}
14. ఇంటర్ఫేస్లో డిఫాల్ట్ పద్ధతి అంటే ఏమిటి?
ఇప్పుడు డిఫాల్ట్ పద్ధతుల గురించి మాట్లాడుకుందాం. అవి దేనికి? అవి ఎవరి కోసం? ఈ పద్ధతులు "రెండు చేతులకు" అందించడానికి జోడించబడ్డాయి. నేను దేని గురించి మాట్లాడుతున్నాను? బాగా, ఒక వైపు, కొత్త కార్యాచరణను జోడించాల్సిన అవసరం ఉంది: లాంబ్డాస్ మరియు స్ట్రీమ్ API. మరోవైపు, జావా ప్రసిద్ధి చెందిన దానిని నిలుపుకోవడం అవసరం - వెనుకకు అనుకూలత. దీన్ని చేయడానికి, ఇంటర్‌ఫేస్‌లకు కొన్ని కొత్త రెడీమేడ్ సొల్యూషన్స్ అవసరం. డిఫాల్ట్ పద్ధతులు మనకు ఎలా వచ్చాయి. డిఫాల్ట్ పద్ధతి అనేది ఇంటర్ఫేస్లో అమలు చేయబడిన పద్ధతి, defaultకీవర్డ్‌తో గుర్తించబడింది. ఉదాహరణకు, stream()ఇంటర్ఫేస్లో బాగా తెలిసిన పద్ధతి Collection. నన్ను నమ్మండి, ఈ ఇంటర్ఫేస్ కనిపించేంత సులభం కాదు. forEach()లేదా లో సమానంగా ప్రసిద్ధ పద్ధతిIterableఇంటర్ఫేస్. డిఫాల్ట్ పద్ధతులు జోడించబడే వరకు ఇది ఉనికిలో లేదు. మార్గం ద్వారా, మీరు కోడ్‌జిమ్‌లో దాని గురించి కూడా ఇక్కడ చదువుకోవచ్చు .
15. అలాంటప్పుడు మనం రెండు ఒకే విధమైన డిఫాల్ట్ పద్ధతులను ఎలా వారసత్వంగా పొందుతాము?
డిఫాల్ట్ పద్ధతి అంటే ఏమిటి అనే దాని గురించి మునుపటి సమాధానం మరొక ప్రశ్నను వేస్తుంది. మీరు ఇంటర్‌ఫేస్‌లలో పద్ధతులను అమలు చేయగలిగితే, సిద్ధాంతపరంగా మీరు ఒకే పద్ధతిలో రెండు ఇంటర్‌ఫేస్‌లను అమలు చేయవచ్చు. మేము దానిని ఎలా చేస్తాము? ఇక్కడ ఒకే పద్ధతిలో రెండు విభిన్న ఇంటర్‌ఫేస్‌లు ఉన్నాయి:
మరియు మేము ఈ రెండు ఇంటర్‌ఫేస్‌లను అమలు చేసే తరగతిని కలిగి ఉన్నాము. అయితే A లేదా B ఇంటర్ఫేస్లో మనం నిర్దిష్ట పద్ధతిని ఎలా ఎంచుకోవచ్చు? కింది ప్రత్యేక నిర్మాణం దీన్ని అనుమతిస్తుంది A.super.foo():
public class C implements A, B {
public void fooA() {
A.super.foo();
}
public void fooB() {
B.super.foo();
}
}
అందువలన, పద్ధతి ఇంటర్ఫేస్ యొక్క fooA()డిఫాల్ట్ పద్ధతిని ఉపయోగిస్తుంది , అయితే పద్ధతి ఇంటర్ఫేస్ యొక్క పద్ధతిని ఉపయోగిస్తుంది . foo()AfooB()foo()B
16. వియుక్త పద్ధతులు మరియు తరగతులు అంటే ఏమిటి?
జావాలో, abstractరిజర్వ్ చేయబడిన పదం. ఇది నైరూప్య తరగతులు మరియు పద్ధతులను సూచించడానికి ఉపయోగించబడుతుంది. మొదట, మనకు నిర్వచనాలు అవసరం. abstractవియుక్త పద్ధతి అనేది ఒక వియుక్త తరగతిలో అమలు చేయకుండా కీవర్డ్‌ని ఉపయోగించి ప్రకటించబడిన పద్ధతి . అంటే, ఇది ఇంటర్ఫేస్లో వలె ఒక పద్ధతి, కానీ కీవర్డ్‌తో పాటు, ఉదాహరణకు:
public abstract void foo();
వియుక్త తరగతి అనేది కీవర్డ్‌తో కూడా గుర్తించబడిన తరగతి abstract:
public abstract class A {
}
వియుక్త తరగతి అనేక లక్షణాలను కలిగి ఉంది:
మీరు వియుక్త తరగతి యొక్క వస్తువును సృష్టించలేరు
ఇది నైరూప్య పద్ధతులను కలిగి ఉంటుంది
దీనికి నైరూప్య పద్ధతులు ఉండకపోవచ్చు
సాధారణ ప్రవర్తనలు మరియు స్థితులను (అంటే పద్ధతులు మరియు వేరియబుల్స్) కలిగి ఉండే సంగ్రహణ (టటాలజీకి క్షమించండి) కోసం వియుక్త తరగతులు అవసరం. నిజ జీవితం ఉదాహరణలతో నిండి ఉంది. మన చుట్టూ ఉన్న ప్రతిదీ. "జంతువు", "కారు", "జామెట్రిక్ ఫిగర్" మరియు మొదలైనవి.
17. స్ట్రింగ్, స్ట్రింగ్‌బిల్డర్ మరియు స్ట్రింగ్‌బఫర్ మధ్య తేడా ఏమిటి?
Stringవిలువలు స్థిరమైన స్ట్రింగ్ పూల్‌లో నిల్వ చేయబడతాయి. స్ట్రింగ్ సృష్టించబడిన వెంటనే, అది ఈ పూల్‌లో కనిపిస్తుంది. మరియు మీరు దానిని తొలగించలేరు. ఉదాహరణకి:
String name = "book";
వేరియబుల్ స్థిరమైన స్ట్రింగ్ పూల్‌ను సూచిస్తుంది, పేరు వేరియబుల్‌ను వేరే విలువకు సెట్ చేస్తుంది, మనకు ఇవి ఉన్నాయి:
name = "pen";
స్థిరమైన స్ట్రింగ్ పూల్ ఇలా కనిపిస్తుంది: మరో మాటలో చెప్పాలంటే, రెండు విలువలు అలాగే ఉంటాయి. స్ట్రింగ్ బఫర్:
Stringవిలువలు స్టాక్‌లో నిల్వ చేయబడతాయి. విలువ మార్చబడితే, పాత విలువను కొత్త విలువ భర్తీ చేస్తుంది.
String Bufferసమకాలీకరించబడింది మరియు అందువల్ల థ్రెడ్ సురక్షితంగా ఉంటుంది.
థ్రెడ్ భద్రత కారణంగా, దాని పనితీరు పేలవంగా ఉంది.
ఉదాహరణ:
StringBuffer name = “book”;
పేరు వేరియబుల్ యొక్క విలువ మారిన వెంటనే, స్టాక్‌లోని విలువ మారుతుంది: StringBuilder సరిగ్గా అదే విధంగా ఉంటుంది StringBuffer, ఇది థ్రెడ్ సురక్షితం కాదు. ఫలితంగా, ఇది కంటే గమనించదగ్గ వేగంగా ఉంటుంది StringBuffer.
18. అబ్‌స్ట్రాక్ట్ క్లాస్ మరియు ఇంటర్ఫేస్ మధ్య తేడా ఏమిటి?
వియుక్త తరగతి:
వియుక్త తరగతులకు డిఫాల్ట్ కన్స్ట్రక్టర్ ఉంటుంది. నైరూప్య తరగతి యొక్క వారసుడు సృష్టించబడిన ప్రతిసారీ దీనిని పిలుస్తారు.
అవి నైరూప్య పద్ధతులు మరియు వియుక్త పద్ధతులు రెండింటినీ చేర్చవచ్చు. సాధారణంగా, నైరూప్య తరగతికి నైరూప్య పద్ధతులు ఉండవలసిన అవసరం లేదు.
ఒక అబ్‌స్ట్రాక్ట్‌ను వారసత్వంగా పొందే తరగతి తప్పనిసరిగా నైరూప్య పద్ధతులను మాత్రమే అమలు చేయాలి.
ఒక అబ్‌స్ట్రాక్ట్ క్లాస్‌లో ఇన్‌స్టాన్స్ వేరియబుల్స్ ఉండవచ్చు (ప్రశ్న #5 చూడండి).
ఇంటర్ఫేస్:
ఇంటర్‌ఫేస్‌కు కన్స్ట్రక్టర్ లేదు మరియు ప్రారంభించబడదు.
నైరూప్య పద్ధతులు మాత్రమే జోడించబడతాయి (డిఫాల్ట్ పద్ధతులు మినహా).
ఇంటర్‌ఫేస్‌ను అమలు చేసే తరగతులు తప్పనిసరిగా అన్ని పద్ధతులను అమలు చేయాలి (డిఫాల్ట్ పద్ధతులు మినహా).
ఇంటర్‌ఫేస్‌లు స్థిరాంకాలను మాత్రమే కలిగి ఉంటాయి.
19. శ్రేణి O(1)లో మూలకాన్ని ఎందుకు యాక్సెస్ చేస్తున్నారు?
ఈ ప్రశ్న నా చివరి ఇంటర్వ్యూలో అడిగారు. నేను తరువాత తెలుసుకున్నట్లుగా, ఈ ప్రశ్న యొక్క ఉద్దేశ్యం ఒక వ్యక్తి ఎలా ఆలోచిస్తున్నాడో చూడటం. స్పష్టంగా, ఈ జ్ఞానంలో తక్కువ ఆచరణాత్మక విలువ ఉంది. అది తెలుసుకుంటే చాలు. ముందుగా, O(1) అనేది "స్థిరమైన సమయం" అల్గోరిథం యొక్క సమయ సంక్లిష్టతకు సంజ్ఞామానం అని మనం స్పష్టం చేయాలి . మరో మాటలో చెప్పాలంటే, ఈ హోదా వేగవంతమైన అమలు సమయాన్ని సూచిస్తుంది. ఈ ప్రశ్నకు సమాధానమివ్వడానికి, శ్రేణుల గురించి మనకు తెలిసిన వాటిని పరిగణించాలి. శ్రేణిని సృష్టించడానికి int, మనం ఈ క్రింది వాటిని వ్రాయాలి:
int[] intArray = new int[100];
ఈ వాక్యనిర్మాణం నుండి అనేక ముగింపులు తీసుకోవచ్చు:
శ్రేణిని ప్రకటించినప్పుడు, దాని రకం తెలుస్తుంది. రకం తెలిసినట్లయితే, శ్రేణిలోని ప్రతి సెల్ పరిమాణం తెలుస్తుంది.
మొత్తం శ్రేణి పరిమాణం తెలుస్తుంది.
అందువల్ల ఏ సెల్‌కు వ్రాయాలో అర్థం చేసుకోవడానికి, మనం ఏ మెమరీ ప్రాంతానికి వ్రాయాలో లెక్కించాలి. కంప్యూటర్ కోసం, ఇది చాలా సులభం. కేటాయించిన మెమరీ ఎక్కడ మొదలవుతుందో, మూలకాల సంఖ్య మరియు ప్రతి సెల్ పరిమాణం కంప్యూటర్‌కు తెలుసు. వీటన్నింటికీ అర్థం, వ్రాయవలసిన స్థలం శ్రేణి యొక్క ప్రారంభ స్థానానికి సమానంగా ఉంటుంది + ప్రతి సెల్ పరిమాణం సూచికతో గుణించబడుతుంది.
కాబట్టి అర్రేలిస్ట్‌లోని ఆబ్జెక్ట్‌లను యాక్సెస్ చేస్తున్నప్పుడు మనం O(1)కి ఎలా చేరుకోవాలి?
ఈ ప్రశ్న వెంటనే మునుపటి ప్రశ్నను అనుసరిస్తుంది. నిజం ఏమిటంటే, ఆదిమాంశాలను కలిగి ఉన్న శ్రేణితో పని చేస్తున్నప్పుడు, మూలకం రకం యొక్క పరిమాణాన్ని మనకు ముందుగానే (సృష్టి సమయంలో) తెలుసు. కానీ మనకు ఈ విధమైన వారసత్వ క్రమానుగతంగా ఉంటే మరియు మేము A రకం మూలకాల కోసం ఒక సేకరణను సృష్టించాలనుకుంటే మరియు విభిన్న అమలులను (B, C మరియు D) జోడించాలనుకుంటే మనం ఏమి చేస్తాము :
List<A> list = new ArrayList();
list.add(new B());
list.add(new C());
list.add(new D());
list.add(new B());
ఈ పరిస్థితిలో, ప్రతి సెల్ పరిమాణాన్ని ఎలా లెక్కించాలి? అన్నింటికంటే, ప్రతి వస్తువు భిన్నంగా ఉంటుంది, బహుశా వివిధ అదనపు ఫీల్డ్‌లతో. ఏం చేయాలి? ఇక్కడ ప్రశ్న మిమ్మల్ని గందరగోళానికి గురిచేసే విధంగా వేయబడింది. సేకరణ నేరుగా వస్తువులను నిల్వ చేయదని మాకు తెలుసు. ఇది వస్తువులకు సంబంధించిన సూచనలను మాత్రమే నిల్వ చేస్తుంది. మరియు అన్ని సూచనలు ఒకే పరిమాణాన్ని కలిగి ఉంటాయి మరియు ఇది తెలిసినది. ఫలితంగా, మేము మునుపటి ప్రశ్నలో ఉన్న విధంగానే ఇక్కడ చిరునామాలను గణిస్తాము.
21. ఆటోబాక్సింగ్ మరియు అన్‌బాక్సింగ్
చారిత్రక నేపథ్యం: ఆటోబాక్సింగ్ మరియు అన్‌బాక్సింగ్ అనేది JDK 5లోని కొన్ని ప్రధాన ఆవిష్కరణలు. ఆటోబాక్సింగ్ అనేది ఒక ఆదిమ రకం నుండి సంబంధిత రేపర్ క్లాస్‌కి ఆటోమేటిక్‌గా మార్చే ప్రక్రియ. అన్‌బాక్సింగ్ అనేది ఆటోబాక్సింగ్‌కు ఖచ్చితమైన వ్యతిరేకం. ఇది రేపర్ క్లాస్‌ను ఆదిమంగా మార్చే ప్రక్రియ. కానీ రేపర్ విలువ అయితే null, అన్‌బాక్సింగ్ సమయంలో a NullPointerExceptionవిసిరివేయబడుతుంది.
// Manual boxing (the way it was BEFORE Java 5).
public void boxingBeforeJava5() {
Boolean booleanBox = new Boolean(true);
Integer intBox = new Integer(3);
// And so on for other types
}
After Java 5:
// Automatic boxing (the way it became in Java 5).
public void boxingJava5() {
Boolean booleanBox = true;
Integer intBox = 3;
// And so on for other types
}
రేపర్‌ను ఆశించే పద్ధతికి ఒక ఆదిమతత్వం వాదనగా పంపబడినప్పుడు:
public void exampleOfAutoboxing() {
long age = 3;
setAge(age);
}
public void setAge(Long age) {
this.age = age;
}
// అన్‌బాక్సింగ్ జరుగుతుంది:
మేము ఒక ప్రిమిటివ్ వేరియబుల్‌కు రేపర్ క్లాస్ యొక్క ఉదాహరణను కేటాయించినప్పుడు:
// BEFORE Java 5:
int intValue = new Integer(4).intValue();
double doubleValue = new Double(2.3).doubleValue();
char c = new Character((char) 3).charValue();
boolean b = Boolean.TRUE.booleanValue();
// And after JDK 5:
int intValue = new Integer(4);
double doubleValue = new Double(2.3);
char c = new Character((char) 3);
boolean b = Boolean.TRUE;
అంకగణిత కార్యకలాపాల సమయంలో. కార్యకలాపాలు ఆదిమ రకాలకు మాత్రమే వర్తిస్తాయి, కాబట్టి ఆదిమలకు అన్‌బాక్సింగ్ అవసరం.
// BEFORE Java 5:
Integer integerBox1 = new Integer(1);
Integer integerBox2 = new Integer(2);
// A comparison used to require this:
integerBox1.intValue() > integerBox2.intValue()
// In Java 5
integerBox1 > integerBox2
రేపర్ క్లాస్ యొక్క ఉదాహరణను సంబంధిత ఆదిమతను తీసుకునే పద్ధతికి పంపినప్పుడు:
public void exampleOfAutoboxing() {
Long age = new Long(3);
setAge(age);
}
public void setAge(long age) {
this.age = age;
}
22. చివరి కీవర్డ్ ఏమిటి మరియు అది ఎక్కడ ఉపయోగించబడుతుంది?
కీవర్డ్ finalవేరియబుల్స్, మెథడ్స్ మరియు క్లాస్‌లలో ఉపయోగించవచ్చు.
తుది వేరియబుల్ ప్రారంభించబడిన తర్వాత దాని విలువ మార్చబడదు.
ఆఖరి తరగతి స్టెరైల్ :) ఇది పిల్లలను కలిగి ఉండదు.
అంతిమ పద్ధతిని వారసుల ద్వారా భర్తీ చేయడం సాధ్యం కాదు.
మేము ఉన్నత స్థాయి అంశాలను కవర్ చేసాము. ఇప్పుడు లోతుగా డైవ్ చేద్దాం.
చివరి వేరియబుల్స్
జావా వేరియబుల్‌ను ప్రకటించడానికి మరియు దానికి విలువను కేటాయించడానికి మాకు రెండు మార్గాలను అందిస్తుంది:
మీరు వేరియబుల్‌ని డిక్లేర్ చేయవచ్చు మరియు దానిని తర్వాత ప్రారంభించవచ్చు.
మీరు వేరియబుల్‌ని ప్రకటించవచ్చు మరియు వెంటనే విలువను కేటాయించవచ్చు.
తుది వేరియబుల్స్ యొక్క ఈ ఉపయోగాలను ప్రదర్శించే ఉదాహరణ ఇక్కడ ఉంది:
public class FinalExample {
// A static final variable that is immediately initialized:
final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";
// A final variable that is not initialized, but will only work if you
// initialize it in the constructor:
final long creationTime;
public FinalExample() {
this.creationTime = System.currentTimeMillis();
}
public static void main(String[] args) {
FinalExample finalExample = new FinalExample();
System.out.println(finalExample.creationTime);
// The final FinalExample.FINAL_EXAMPLE_NAME field cannot be accessed
// FinalExample.FINAL_EXAMPLE_NAME = "Not you're not!";
// The final Config.creationTime field cannot be accessed
// finalExample.creationTime = 1L;
}
}
తుది వేరియబుల్‌ను స్థిరంగా పరిగణించవచ్చా?
తుది వేరియబుల్స్‌కు కొత్త విలువలను కేటాయించలేము కాబట్టి, ఇవి స్థిరమైన వేరియబుల్స్ అని తెలుస్తోంది. కానీ మొదటి చూపులో మాత్రమే: వేరియబుల్ డేటా రకం అయితే immutable, అవును, అది స్థిరంగా ఉంటుంది. అయితే డేటా రకం mutable, అంటే మార్చదగినది అయితే, వేరియబుల్ ద్వారా సూచించబడిన వస్తువు యొక్క విలువను మార్చడానికి పద్ధతులు మరియు వేరియబుల్‌లను ఉపయోగించడం సాధ్యమవుతుంది final. దీని కారణంగా, దీనిని స్థిరంగా పిలవలేము. కింది ఉదాహరణ కొన్ని చివరి వేరియబుల్స్ నిజంగా స్థిరాంకాలు అని చూపిస్తుంది, అయితే మరికొన్ని మారవచ్చు కాబట్టి అవి మారవు.
public class FinalExample {
// Immutable final variables
final static String FINAL_EXAMPLE_NAME = "I'm likely the final one";
final static Integer FINAL_EXAMPLE_COUNT = 10;
// Mutable final variables
final List<String> addresses = new ArrayList();
final StringBuilder finalStringBuilder = new StringBuilder("Constant?");
}
స్థానిక తుది వేరియబుల్స్
finalఒక పద్ధతిలో వేరియబుల్ సృష్టించబడినప్పుడు, దానిని వేరియబుల్ అంటారు local final:
public class FinalExample {
public static void main(String[] args) {
// You can do this
final int minAgeForDriveCar = 18;
// Or you can do this, in a for-each loop:
for (final String arg : args) {
System.out.println(arg);
}
}
}
లూప్ యొక్క ప్రతి పునరావృతం తర్వాత కొత్త వేరియబుల్ సృష్టించబడినందున, మేము లూప్ కోసం మెరుగుపరచబడిన చివరి కీవర్డ్‌ని ఉపయోగించవచ్చు. ఇది సాధారణ లూప్‌కి వర్తించదని గుర్తుంచుకోండి, కాబట్టి మనకు కంపైల్-టైమ్ ఎర్రర్ వస్తుంది.
// The final local j variable cannot be assigned
for (final int i = 0; i < args.length; i ++) {
System.out.println(args[i]);
}
చివరి తరగతి
ఒక తరగతిని పొడిగించడం finalసాధ్యం కాదు. మరింత సరళంగా చెప్పాలంటే, ఏ ఇతర తరగతి దానిని వారసత్వంగా పొందదు. finalJDKలోని తరగతికి అద్భుతమైన ఉదాహరణ స్ట్రింగ్. మార్పులేని తరగతిని సృష్టించడానికి మొదటి దశ దానిని గా గుర్తించడం final, తద్వారా దానిని పొడిగించకుండా నిరోధించడం:
public final class FinalExample {
}
// Compilation error!
class WantsToInheritFinalClass extends FinalExample {
}
చివరి పద్ధతులు
ఒక పద్ధతిని చివరిగా గుర్తించినప్పుడు, దానిని తుది పద్ధతి అంటారు (అర్ధవంతంగా ఉంది, సరియైనదా?). పిల్లల తరగతిలో చివరి పద్ధతిని భర్తీ చేయడం సాధ్యం కాదు. యాదృచ్ఛికంగా, ఆబ్జెక్ట్ క్లాస్ నిరీక్షణ() మరియు నోటిఫై() పద్ధతులు అంతిమమైనవి, కాబట్టి వాటిని భర్తీ చేసే సామర్థ్యం మాకు లేదు.
public class FinalExample {
public final String generateAddress() {
return "Some address";
}
}
class ChildOfFinalExample extends FinalExample {
// Compilation error!
@Override
public String generateAddress() {
return "My OWN Address";
}
}
జావాలో ఫైనల్‌ని ఎలా మరియు ఎక్కడ ఉపయోగించాలి
కొన్ని తరగతి-స్థాయి స్థిరాంకాలను నిర్వచించడానికి చివరి కీవర్డ్‌ని ఉపయోగించండి;
మీరు మార్చకూడదనుకునే వస్తువుల కోసం తుది వేరియబుల్‌లను సృష్టించండి. ఉదాహరణకు, లాగింగ్ ప్రయోజనాల కోసం మనం ఉపయోగించగల ఆబ్జెక్ట్-నిర్దిష్ట లక్షణాలు.
మీరు తరగతిని పొడిగించకూడదనుకుంటే, దానిని ఫైనల్‌గా గుర్తించండి.
మీరు మార్పులేని తరగతిని సృష్టించాలనుకుంటే, మీరు దానిని ఫైనల్ చేయాలి.
మీరు ఒక పద్దతి యొక్క అమలు దాని వారసులలో మారకూడదని కోరుకుంటే, ఆ పద్ధతిని ఇలా గుర్తు పెట్టండి final. అమలులో మార్పు లేదని నిర్ధారించుకోవడానికి ఇది చాలా ముఖ్యం.
23. మార్చదగిన మరియు మార్పులేని రకాలు ఏమిటి?
మార్చగల
ఉత్పరివర్తన వస్తువులు అంటే వాటి స్థితి మరియు వేరియబుల్స్ సృష్టి తర్వాత మార్చబడే వస్తువులు. మార్చగల తరగతులకు ఉదాహరణలు StringBuilder మరియు StringBuffer. ఉదాహరణ:
public class MutableExample {
private String address;
public MutableExample(String address) {
this.address = address;
}
public String getAddress() {
return address;
}
// This setter can change the name field
public void setAddress(String address) {
this.address = address;
}
public static void main(String[] args) {
MutableExample obj = new MutableExample("First address");
System.out.println(obj.getAddress());
// We are updating the name field, so this is a mutable object
obj.setAddress("Updated address");
System.out.println(obj.getAddress());
}
}
మార్పులేని
మార్పులేని వస్తువులు అంటే వస్తువును సృష్టించిన తర్వాత వాటి స్థితి మరియు వేరియబుల్స్ మార్చలేని వస్తువులు. HashMap కోసం గొప్ప కీ, మీరు అనుకోలేదా? :) ఉదాహరణకు, స్ట్రింగ్, పూర్ణాంకం, డబుల్, మరియు మొదలైనవి. ఉదాహరణ:
// We'll make this class final so no one can change it
public final class ImmutableExample {
private String address;
ImmutableExample(String address) {
this.address = address;
}
public String getAddress() {
return address;
}
// We remove the setter
public static void main(String[] args) {
ImmutableExample obj = new ImmutableExample("Old address");
System.out.println(obj.getAddress());
// There is no way to change this field, so it is an immutable object
// obj.setName("new address");
// System.out.println(obj.getName());
}
}
నేను OOP, జావా సింటాక్స్, జావా మినహాయింపులు, సేకరణలు మరియు మల్టీథ్రెడింగ్ గురించి తరచుగా అడిగే ప్రశ్నల యొక్క విస్తృతమైన సేకరణతో ముగించాను, వీటిని నేను సౌలభ్యం కోసం అనేక భాగాలుగా విభజిస్తాను. అన్నింటినీ ఒకేసారి కవర్ చేయడం కష్టం, కానీ ప్రోగ్రామర్‌గా వారి మొదటి ఉద్యోగాన్ని కనుగొనడానికి సిద్ధమవుతున్న వారికి ఈ విషయం మంచి పునాదిని అందిస్తుందని నేను ఆశిస్తున్నాను. ఉత్తమ అవగాహన మరియు నిలుపుదల కోసం, నేను ఇతర వనరుల ద్వారా కూడా కలపమని సలహా ఇస్తున్నాను. మీరు అనేక విభిన్న కోణాల నుండి ఒక కాన్సెప్ట్‌ను సంప్రదించడం ద్వారా లోతైన అవగాహనను పొందవచ్చు. ముఖ్యమైన:మేము వెర్షన్ 8 కంటే ముందు జావా గురించి మాత్రమే మాట్లాడతాము. 9, 10, 11, 12 మరియు 13 వెర్షన్‌లలో వచ్చిన అన్ని ఆవిష్కరణలు ఇక్కడ పరిగణించబడవు. సమాధానాలను ఎలా మెరుగుపరచాలనే దానిపై ఏవైనా ఆలోచనలు/కామెంట్‌లు స్వాగతం . మీ పఠనాన్ని ఆస్వాదించండి. వెళ్దాం!
పద్ధతి సంతకం అనేది పద్ధతి పేరు మరియు పద్ధతి తీసుకునే వాదనల కలయిక. పద్ధతులను ఓవర్‌లోడ్ చేస్తున్నప్పుడు పద్ధతి సంతకం అనేది ఒక పద్ధతి యొక్క ప్రత్యేక గుర్తింపు.
పేరు వేరియబుల్‌ను వేరే విలువకు సెట్ చేస్తుంది, మనకు ఇవి ఉన్నాయి:
మరో మాటలో చెప్పాలంటే, రెండు విలువలు అలాగే ఉంటాయి. స్ట్రింగ్ బఫర్:
పేరు వేరియబుల్ యొక్క విలువ మారిన వెంటనే, స్టాక్‌లోని విలువ మారుతుంది: 
StringBuilder సరిగ్గా అదే విధంగా ఉంటుంది 
కానీ మనకు ఈ విధమైన వారసత్వ క్రమానుగతంగా ఉంటే మరియు మేము A రకం మూలకాల కోసం ఒక సేకరణను సృష్టించాలనుకుంటే మరియు విభిన్న అమలులను (B, C మరియు D) జోడించాలనుకుంటే మనం ఏమి చేస్తాము :
GO TO FULL VERSION