சிறந்த 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 எழுத்துப்பூர்வ தொடரியல் பயன்படுத்தினால், அது ஏற்கனவே இருந்தால், String pool-ல் இருந்து ஏற்கனவே இருக்கும் ஒரு பொருளைத் திருப்பி அனுப்பலாம்.

பின்வரும் குறியீட்டில் எத்தனை பொருள்கள் உருவாக்கப்பட்டுள்ளன?

String s = new String("Hello");

2 பொருள்கள் உள்ளன. ஒன்று சரம் நிலையான குளத்தில் உள்ளது (ஏற்கனவே இல்லை என்றால்) மற்றொன்று குவியலில் உள்ளது.

ஜாவாவில் வகுப்புகளுக்கும் String, StringBuilderவகுப்புகளுக்கும் என்ன வித்தியாசம் ?StringBuffer

ஜாவா நேர்காணல் கேள்விகளில் தலைவன் ஒருவர் இருக்கிறார்.

முதலில் 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.