టాప్ 21 జావా ఇంటర్వ్యూ ప్రశ్నలు

"విడదీయండి" public static void main(String args[]).

ఫ్రెషర్‌ల కోసం జనాదరణ పొందిన జావా ఇంటర్వ్యూ ప్రశ్నలలో ఒకటి మరియు చాలా సులభమైనది.

• publicయాక్సెస్ మాడిఫైయర్. ఈ పద్ధతికి ప్రాప్యతను పేర్కొనడానికి మేము దీన్ని ఉపయోగిస్తాము. ఇక్కడ మాడిఫైయర్ “పబ్లిక్”, కాబట్టి ఏదైనా తరగతికి ఈ పద్ధతికి యాక్సెస్ ఉంటుంది.

• static. ఈ జావా కీవర్డ్ అంటే మనం క్లాస్ యొక్క కొత్త ఆబ్జెక్ట్‌ని సృష్టించకుండా ఈ పద్ధతిని ఉపయోగిస్తాము.

• Voidపద్ధతి యొక్క రిటర్న్ రకం. పద్ధతి ఏ విలువను తిరిగి ఇవ్వదని అర్థం.

• mainపద్ధతి పేరు. JVM దానిని అప్లికేషన్‌కి ఎంట్రీ పాయింట్‌గా “తెలుసుకుంటుంది” (దీనికి నిర్దిష్ట సంతకం ఉండాలి). Mainప్రధాన అమలు జరిగే పద్ధతి.

• String args[]. ఇది ప్రధాన పద్ధతికి పంపబడిన పరామితి. మీరు దీన్ని అమలు చేసినప్పుడు మీ జావా అప్లికేషన్ అంగీకరించే స్ట్రింగ్ రకం వాదనలు ఇక్కడ ఉన్నాయి. మీరు వాటిని టెర్మినల్‌లో టైప్ చేయవచ్చు.

equals()మరియు మధ్య తేడా ఏమిటి ==?

మొదట, " ==" ఒక ఆపరేటర్ అయితే equals()ఒక పద్ధతి. మేము ==సూచన పోలిక (లేదా చిరునామా పోలిక) కోసం ఆపరేటర్‌ని మరియు equals()కంటెంట్ పోలిక కోసం పద్ధతిని ఉపయోగిస్తాము. ఆబ్జెక్ట్‌లలోని విలువలను సరిపోల్చేటప్పుడు ==రెండు ఆబ్జెక్ట్‌లు ఒకే మెమరీ లొకేషన్‌ను సూచిస్తాయో లేదో తనిఖీ చేస్తుంది .equals()

పద్ధతి లేకుండా ప్రోగ్రామ్‌ని అమలు చేయవచ్చా main()?

చాలా జావా ప్రాథమిక ఇంటర్వ్యూ ప్రశ్నలు చాలా సులభం. ఇలా. కాబట్టి చిన్న సమాధానం: అవును, మనం చేయగలం. ఉదాహరణకు మనం స్టాటిక్ బ్లాక్ ఉపయోగించి దీన్ని చేయవచ్చు.

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

class Example{  
 Static{
System.out.println("static block is invoked");
}  
  public static void main(String args[]){  
   System.out.println("Now main method");  
  }  
}

అవుట్‌పుట్:

static block is invoked
Now main method

వస్తువు అంటే ఏమిటి immutable? immutableమీరు వస్తువును సృష్టించగలరా ?

immutableమీరు తరగతికి చెందిన వస్తువులను సృష్టించిన తర్వాత వాటిని సవరించలేరు . కాబట్టి మీరు వాటిని సృష్టించిన తర్వాత, మీరు వాటిని మార్చలేరు. మీరు ఆబ్జెక్ట్‌ని సవరించడానికి ప్రయత్నిస్తే Immutableమీకు కొత్త వస్తువు (క్లోన్) వస్తుంది మరియు సృష్టి సమయంలో ఈ క్లోన్‌ని మార్చండి.

ఒక మంచి ఉదాహరణ String, ఇది immutableజావాలో ఉంది. అంటే మీరు ఆబ్జెక్ట్‌ను మార్చలేరు, కానీ మీరు ఆబ్జెక్ట్‌కు సూచనను మార్చవచ్చు.

కింది కోడ్‌లో ఎన్ని వస్తువులు సృష్టించబడ్డాయి?

జావా టెక్నికల్ ఇంటర్వ్యూ ప్రశ్నలలో ఒకటి #4ని భర్తీ చేస్తుంది.

String s1="Hello";  
String s2="Hello";  
String s3="Hello";  

జావాలో స్ట్రింగ్ పూల్ ఉన్నందున సమాధానం “ఒకే”. కొత్త() ఆపరేటర్‌ని ఉపయోగించి మనం స్ట్రింగ్ ఆబ్జెక్ట్‌ను సృష్టించినప్పుడు, అది హీప్ మెమరీలో కొత్త ఆబ్జెక్ట్‌ను సృష్టిస్తుంది. మేము స్ట్రింగ్ లిటరల్ సింటాక్స్‌ని ఉపయోగిస్తే, మా ఉదాహరణలో వలె, అది ఇప్పటికే ఉన్నట్లయితే, స్ట్రింగ్ పూల్ నుండి ఇప్పటికే ఉన్న వస్తువుని తిరిగి ఇవ్వవచ్చు.

కింది కోడ్‌లో ఎన్ని వస్తువులు సృష్టించబడ్డాయి?

String s = new String("Hello");

2 వస్తువులు ఉన్నాయి. ఒకటి స్ట్రింగ్ స్థిరమైన పూల్‌లో ఉంది (ఇప్పటికే లేనట్లయితే) మరియు మరొకటి కుప్పలో ఉంది.

జావాలో క్లాసుల మధ్య Stringతేడా ఏమిటి ?StringBuilderStringBuffer

అగ్ర జావా ఇంటర్వ్యూ ప్రశ్నలలో నాయకుడు ఒకరు ఉన్నారు.

అన్నింటిలో మొదటిది Stringమార్పులేని తరగతి. అంటే మీరు ఒకసారి సృష్టించిన దాని కంటెంట్‌ను సవరించలేరు. అయితే StringBufferమరియు StringBuilderమార్చదగిన తరగతులు, కాబట్టి మీరు వాటిని తర్వాత మార్చవచ్చు. మేము ఆబ్జెక్ట్ యొక్క కంటెంట్‌ను మార్చినట్లయితే String, అది కొత్త స్ట్రింగ్‌ను సృష్టిస్తుంది కాబట్టి ఇది అసలైనదాన్ని సవరించదు. అందుకే StringBufferతో కంటే తో చేసిన పనితీరు మెరుగ్గా ఉంది String.

మధ్య ప్రధాన వ్యత్యాసం StringBufferమరియు StringBuilderదాని StringBufferపద్ధతులు సమకాలీకరించబడతాయి, అయితే StringBuilder'లు కాదు.

Stringలిటరల్ ఉపయోగించి మరియు ఆపరేటర్‌తో సృష్టించబడిన దానిలో ఏదైనా తేడా ఉందా new()?

ఉంది. మేము ఆపరేటర్‌తో స్ట్రింగ్‌ను సృష్టించినట్లయితే new(), అది కుప్పలో మరియు స్ట్రింగ్ పూల్‌లో కనిపిస్తుంది (ఇప్పటికే లేనట్లయితే). మీరు అక్షరార్థాన్ని ఉపయోగించి సృష్టించినట్లయితే String, అది స్ట్రింగ్ పూల్‌లో సృష్టించబడుతుంది (ఇప్పటికే లేనట్లయితే). స్ట్రింగ్ పూల్ అనేది కుప్పలో ఉన్న నిల్వ ప్రాంతం, ఇది స్ట్రింగ్ అక్షరాలను నిల్వ చేస్తుంది.

మీరు జావాలో భర్తీ చేయగలరా privateలేదా పద్ధతిని మార్చగలరా?static

రూకీల కోసం జావా గమ్మత్తైన ఇంటర్వ్యూ ప్రశ్నలలో ఒకటి. మీరు నిజంగా జావాలో భర్తీ చేయలేరు privateలేదా పద్ధతిని మార్చలేరు.static

privateప్రైవేట్ యాక్సెస్ స్పెసిఫైయర్ యొక్క పరిధి తరగతిలో మాత్రమే ఉన్నందున మీరు పద్ధతులను భర్తీ చేయలేరు . మీరు ఏదైనా ఓవర్‌రైడ్ చేయబోతున్నప్పుడు, మాకు తల్లిదండ్రులు మరియు పిల్లల తరగతి ఉండాలి. సూపర్‌క్లాస్ పద్ధతి అయితే private, పిల్లల తరగతి దానిని ఉపయోగించలేరు మరియు చైల్డ్ క్లాస్‌లోని పద్ధతులు కొత్త పద్ధతులుగా పరిగణించబడతాయి (ఓవర్‌రైడ్ చేయబడలేదు).

Staticపద్ధతులు కూడా ఓవర్‌రైడ్ చేయబడవు, ఎందుకంటే staticపద్ధతులు క్లాస్‌లోని భాగమే మరియు క్లాస్‌లోని ఏదైనా వస్తువులో భాగం కాదు. ఖచ్చితంగా మీరు పిల్లల తరగతులలో అదే పద్ధతిని అదే సంతకంతో ప్రకటించవచ్చు static, కానీ మళ్లీ అవి కొత్త పద్ధతులుగా పరిగణించబడతాయి.

Abstract Classమరియు మధ్య వ్యత్యాసంInterface

OOP సూత్రాలను కలిగి ఉన్న ప్రముఖ జావా డెవలపర్ ఇంటర్వ్యూ ప్రశ్నలలో ఒకటి. అన్నింటిలో మొదటిది, జావాలో interfaceప్రవర్తనను నిర్వచిస్తుంది మరియు abstract classసోపానక్రమాన్ని సృష్టిస్తుంది.

staticమేము తరగతిలో వేరియబుల్స్ మరియు పద్ధతులను ప్రకటించవచ్చా abstract?

staticఅవును, పద్ధతిలో వేరియబుల్స్ మరియు పద్ధతులను ప్రకటించడం సాధ్యమవుతుంది abstract. స్థిరమైన సందర్భాన్ని యాక్సెస్ చేయడానికి వస్తువును తయారు చేయవలసిన అవసరం లేదు. abstractకాబట్టి తరగతి పేరును ఉపయోగించడం ద్వారా తరగతి లోపల డిక్లేర్ చేయబడిన స్టాటిక్ సందర్భాన్ని యాక్సెస్ చేయడానికి మాకు అనుమతి ఉంది abstract.

JVM ఏ రకమైన మెమరీ ప్రాంతాలను కేటాయించింది?

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

హీప్ అనేది రన్‌టైమ్ డేటా ప్రాంతం, ఇక్కడ ఆబ్జెక్ట్‌లకు మెమరీ కేటాయించబడుతుంది.

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

ప్రోగ్రామ్ కౌంటర్ రిజిస్టర్ ప్రస్తుతం అమలు చేయబడుతున్న జావా వర్చువల్ మెషీన్ సూచనల చిరునామాను కలిగి ఉంది.

స్థానిక పద్ధతి స్టాక్ అప్లికేషన్‌లో ఉపయోగించే అన్ని స్థానిక పద్ధతులను కలిగి ఉంటుంది.

జావాలో బహుళ వారసత్వం ఎందుకు అనుమతించబడదు?

ఇది నిజంగా సంక్లిష్టంగా ఉంటుంది. మూడు తరగతులను ఊహించుకోండి A, Bమరియు Cమరియు Cవారసత్వంగా Aమరియు B. ఇప్పుడు, Aమరియు Bతరగతులు అదే పద్ధతిని కలిగి ఉన్నాయి మరియు మీరు దానిని పిల్లల తరగతి వస్తువు నుండి పిలుస్తారు... ఏది? A'లు లేదా B'లు? ఇక్కడ మనకు అస్పష్టత ఉంది.

మీరు రెండు తరగతులను వారసత్వంగా పొందేందుకు ప్రయత్నిస్తే జావా కంపైల్ టైమ్ ఎర్రర్‌ను అందిస్తుంది.

మేము పద్ధతిని ఓవర్‌లోడ్ చేయవచ్చా main()?

mainఖచ్చితంగా, పద్ధతి ఓవర్‌లోడింగ్‌ని ఉపయోగించడం ద్వారా జావా ప్రోగ్రామ్‌లో అనేక పద్ధతులను కలిగి ఉండటానికి మాకు అనుమతి ఉంది . ప్రయత్నించి చూడండి!

మేము కన్స్ట్రక్టర్‌ని ఇలా ప్రకటించవచ్చా final?

లేదు. finalఒక కన్‌స్ట్రక్టర్‌ని వారసత్వంగా పొందలేనందున దానిని ప్రకటించలేము . కాబట్టి కన్స్ట్రక్టర్‌లను ఇలా ప్రకటించడం అర్థరహితం final. అయితే, మీరు దీన్ని చేయడానికి ప్రయత్నిస్తే, జావా కంపైలర్ మీకు లోపాన్ని విసురుతుంది.

మనం ఇంటర్‌ఫేస్‌ని ఇలా ప్రకటించవచ్చా final?

లేదు, మేము దీన్ని చేయలేము. finalఇంటర్‌ఫేస్ దాని నిర్వచనం ప్రకారం కొంత తరగతి ద్వారా అమలు చేయబడాలి కాబట్టి ఇంటర్‌ఫేస్ కాదు . అందువల్ల, ఇంటర్‌ఫేస్‌ను తయారు చేయడంలో అర్థం లేదు final. అయితే, మీరు అలా చేయడానికి ప్రయత్నిస్తే, కంపైలర్ లోపాన్ని చూపుతుంది.

static bindingమరియు మధ్య తేడా ఏమిటి dynamic binding?

bindingకంపైలర్ ద్వారా కంపైల్ సమయంలో పరిష్కరించబడే దానిని ప్రారంభ staticబైండింగ్ అంటారు. Bindingఅన్ని static, privateమరియు finalపద్ధతులు కంపైల్-సమయంలో పూర్తి చేయబడతాయి.

కంపైలర్‌లో Dynamic bindingపిలవబడే పద్ధతిని ఎంచుకోలేదు. ఓవర్‌రైడింగ్ అనేది ఒక ఖచ్చితమైన ఉదాహరణ dynamic binding. ఓవర్‌రైడింగ్‌లో తల్లిదండ్రులు మరియు పిల్లల తరగతులు రెండూ ఒకే పద్ధతిని కలిగి ఉంటాయి.

Static Binding
class Cat{  
 private void talk()
{System.out.println("cat is mewing...");
}  
  
 public static void main(String args[]){  
  Cat cat=new Cat();  
  cat.talk();  
 }  
}  
Dynamic Binding
class Animal{  
 void talk(){
System.out.println("animal is talking...");
}  
}  
  
class Cat extends Animal{  
 void talk(){
System.out.println("cat is talking...");
}    
 public static void main(String args[]){  
  Animal animal=new Cat();  
  animal.talk();  
 }  
}

జావాలో చదవడానికి మాత్రమే తరగతిని ఎలా సృష్టించాలి?

మీరు తరగతి ఫీల్డ్‌లన్నింటినీ ప్రైవేట్‌గా చేయడం ద్వారా దీన్ని చేయవచ్చు. క్లాస్ యొక్క ప్రైవేట్ ప్రాపర్టీని మెథడ్‌కి తిరిగి ఇచ్చే రీడ్-ఓన్లీ క్లాస్‌లో గెట్టర్ పద్ధతులు మాత్రమే ఉన్నాయి main. మీరు ఈ ఆస్తిని సవరించలేరు, కారణం సెట్టర్స్ పద్ధతి లేకపోవడమే.

public class HockeyPlayer{    
private String team ="Maple leaf";    
public String getTeam(){    
return team;    
}    
}

జావాలో వ్రాయడానికి మాత్రమే తరగతిని ఎలా సృష్టించాలి?

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

public class HockeyPlayer{       
private String team;    
public void setTeam(String college){    
this.team = team;    
}    
}    

ప్రతి tryబ్లాక్‌కి తప్పనిసరిగా ఒక బ్లాక్ ఉండాలి catch, కాదా?

లేదు. ఇది అవసరం కాదు. ప్రతి tryబ్లాక్ బ్లాక్ లేకుండా ఉంటుంది catch. దీనిని క్యాచ్‌బ్లాక్ లేదా చివరగా బ్లాక్ లేదా అవి లేకుండా కూడా అనుసరించవచ్చు.

public class Main{  
     public static void main(String []args){  
        try{  
            int variable = 1;   
            System.out.println(variable/0);  
        }  
        finally  
        {  
            System.out.println("the other part of the program...");  
        }  
     }  
}

అవుట్‌పుట్:

Exception in thread main java.lang.ArithmeticException:/ by zero
the other part of the program...

class Main {
        public static void main(String[] args) throws IOException {
            try(InputStreamReader inputStreamReader = new InputStreamReader(System.in);
                BufferedReader reader = new BufferedReader(inputStreamReader)){
                System.out.println("test");
            }
        }
    }

అవుట్‌పుట్:

test

throwకీవర్డ్‌ల మధ్య తేడా ఏమిటి throws?

Throwsమినహాయింపును ప్రకటించడానికి ఉపయోగించబడుతుంది, కాబట్టి ఇది try-catchబ్లాక్ మాదిరిగానే పని చేస్తుంది. Throwకీవర్డ్ అనేది ఒక పద్ధతి లేదా కోడ్ యొక్క ఏదైనా ఇతర బ్లాక్ నుండి మినహాయింపును స్పష్టంగా విసిరేందుకు ఉపయోగించబడుతుంది.

Throwక్లాస్ మరియు త్రోల యొక్క ఒక ఉదాహరణ తర్వాత Exceptionమినహాయింపు తరగతి పేర్లతో ఉంటుంది.

Throwమినహాయింపును త్రోయడానికి మెథడ్ బాడీలో ఉపయోగించబడుతుంది. Throwsపద్ధతిలో ఉన్న స్టేట్‌మెంట్‌లలో సంభవించే మినహాయింపులను ప్రకటించడానికి పద్ధతి సంతకంలో ఉపయోగించబడుతుంది.

ఇది ఒక సమయంలో ఒక మినహాయింపును విసిరేందుకు అనుమతించబడుతుంది కానీ మీరు వాటిని కీవర్డ్‌ని ఉపయోగించి ప్రకటించడం ద్వారా బహుళ మినహాయింపులను నిర్వహించవచ్చు. మీరు throwబహుళ మినహాయింపులను ప్రకటించవచ్చు, ఉదా, public void method()throws IOException, SQLException.