ஜாவா தொடரியல்: நிரலாக்க மொழிக்கான மிக சுருக்கமான அறிமுகம்

ஜாவா தொடரியல் என்றால் என்ன?

ஜாவா தொடரியல் என்பது மொழியின் அடிப்படை, அனைத்து முக்கிய விதிகள், கட்டளைகள், கம்பைலர் மற்றும் கணினி "புரிந்து கொள்ளும்" நிரல்களை எழுதுவதற்கான கட்டுமானங்கள். ஒவ்வொரு நிரலாக்க மொழிக்கும் அதன் தொடரியல் மற்றும் மனித மொழி உள்ளது. இந்த கட்டுரை ஜாவா நிரலாக்க மொழியின் அடிப்படை தொடரியல் மீது கவனம் செலுத்துகிறது மற்றும் புதிய டெவலப்பர்கள் அல்லது மற்றொரு நிரலாக்க மொழியை அறிந்தவர்களுக்காக வடிவமைக்கப்பட்டுள்ளது. சில அம்சங்கள் தொடக்கநிலையாளர்களுக்கு தெளிவாக இருக்காது. அப்படியானால், அவற்றைத் தவிர்த்துவிட்டு உதாரணங்களில் கவனம் செலுத்துவது நல்லது. எல்லாவற்றையும் போலவே, ஒரு நிரலாக்க மொழியை சுழற்சி முறையில் கற்றுக்கொள்வது நல்லது, படிப்படியாக சில கருத்துகளைப் பற்றிய ஆழமான புரிதலுக்கு வருகிறது. ஒவ்வொரு ஜாவா நிரலும் தரவு (மாறிகள்) மற்றும் நடத்தை (செயல்பாடுகள் அல்லது முறைகள்) ஆகியவற்றுடன் ஒன்றையொன்று இணைக்கும் பொருள்களின் தொகுப்பாகும். மேலும் ஜாவா நிரல் ஒரு வகுப்பு அல்லது சில வகுப்புகள். ஒரு பொருள் என்பது ஒரு வகுப்பின் உதாரணம். நீங்கள் வகுப்பை ஒரு மாதிரியாகப் புரிந்து கொள்ளலாம், எடுத்துக்காட்டாக, குக்கீ கட்டர்கள் மற்றும் குக்கீகள் போன்ற பொருள்கள். அல்லது ஒரு சுருக்கமான "ஜாவா புரோகிராமர்" மற்றும் பொருள் "ஜாவா புரோகிராமர் ஜான்" அல்லது "ஜாவா புரோகிராமர் ஐவி" என வகுப்பு.

ஜாவாவில் பொருள்

ஜாவாவில் உள்ள பொருட்களுக்கு நிலைகள் மற்றும் நடத்தைகள் உள்ளன. எடுத்துக்காட்டு: ஒரு பூனை கூறுகிறது: அதன் பெயர் ஃபர், நிறம் சிவப்பு, உரிமையாளர் ஜான்; பூனைக்கு நடத்தை உள்ளது இப்போது ஃபர் தூங்குகிறது. அவர் பர்ர், நடக்க, மற்றும் பல. ஒரு பொருள் என்பது ஒரு வகுப்பின் உதாரணம்.

ஜாவாவில் வகுப்பு

வகுப்பு என்பது பொருளின் மாதிரி அல்லது டெம்ப்ளேட் அல்லது வரைபடமாகும். இது நடத்தையை விவரிக்கிறது மற்றும் அதன் வகையின் பொருள் ஆதரிக்கிறது என்று கூறுகிறது. உதாரணமாக, பூனை வகுப்பிற்கு அதன் பெயர், நிறம், உரிமையாளர்; பூனை சாப்பிடுவது, துடைப்பது, நடப்பது, தூங்குவது போன்ற நடத்தைகளையும் கொண்டுள்ளது.

ஜாவாவில் முறைகள்

தர்க்கங்களை விவரிப்பதற்கும், தரவுகளை கையாளுவதற்கும் மற்றும் அனைத்து செயல்களையும் செயல்படுத்துவதற்கும் முறைகள் உள்ளன. ஒவ்வொரு முறையும் நடத்தையை வரையறுக்கிறது. ஒரு வகுப்பில் பல முறைகள் இருக்கலாம். எடுத்துக்காட்டாக, பூனை வகுப்பிற்கு (தூங்குவதற்கு) தூக்கம்() என்ற முறையை எழுதலாம் அல்லது purr () க்கு purr.

ஜாவாவில் நிகழ்வு மாறிகள்

ஒவ்வொரு பொருளுக்கும் ஒரு தனித்துவமான நிகழ்வு மாறிகள் உள்ளன. பொருள் நிலை பொதுவாக இந்த நிகழ்வு மாறிகளுக்கு ஒதுக்கப்பட்ட மதிப்புகளால் உருவாக்கப்படுகிறது. உதாரணமாக பூனையின் பெயர் அல்லது வயது மாறி இருக்கலாம். நாங்கள் எளிமையான ஜாவா நிரலுடன் தொடங்கப் போகிறோம். இந்த எடுத்துக்காட்டைப் பயன்படுத்தி, ஜாவா தொடரியல் அடிப்படைக் கருத்துக்களைப் புரிந்துகொள்வோம், பின்னர் அவற்றைக் கூர்ந்து கவனிப்போம்.

எளிய ஜாவா திட்டம்: வணக்கம், ஜாவா!

இங்கே ஒரு எளிய ஜாவா நிரல்:

class HelloJava {
   public static void main(String[] args) {
       System.out.println("Hello, Java!");
   }
}

இந்த நிரல் "ஹலோ, ஜாவா!" என்ற சரத்தை அச்சிடுகிறது. ஆறுதல் சொல்ல. JDK மற்றும் IntelliJ IDEA ஐ நிறுவி, மேலே நீங்கள் பார்க்கும் குறியீட்டை எழுத முயற்சிக்கவும். அல்லது முதல் முயற்சியாக அதைச் செய்ய ஆன்லைன் IDE ஐக் கண்டறியவும். இப்போது இந்த நிரலை வரிக்கு வரியாக எடுத்துக்கொள்வோம், ஆனால் ஒரு தொடக்கக்காரருக்குத் தேவையில்லாத சில விவரங்களைத் தவிர்க்கவும்.

class HelloJava 

ஜாவாவில் உள்ள ஒவ்வொரு நிரலும் ஒரு வகுப்பு அல்லது பல வகுப்புகள். வரி வகுப்பு HelloJava என்பது இங்கே நாம் ஒரு புதிய வகுப்பை உருவாக்குகிறோம், அதன் பெயர் HelloJava. நாம் மேலே வரையறுத்துள்ளபடி, வர்க்கம் என்பது ஒரு வகையான டெம்ப்ளேட் அல்லது ப்ளூபிரிண்ட் ஆகும், இது வகுப்பின் பொருள்களின் நடத்தை மற்றும் நிலைகளை விவரிக்கிறது. புதிய புரோகிராமர்களுக்கு இது கடினமாக இருக்கலாம், இந்த கருத்தை சிறிது நேரம் கழித்து நீங்கள் கற்றுக் கொள்வீர்கள். இப்போதைக்கு ஹலோஜாவா வகுப்பு என்பது உங்கள் திட்டத்தின் ஆரம்பம். ஒரே வரியிலும் உரை முழுவதும் சுருள் பிரேஸ் { இருப்பதை நீங்கள் கவனித்திருக்கலாம் . ஒரு ஜோடி சுருள் பிரேஸ்கள் {} ஒரு தொகுதியைக் குறிக்கிறது, இது ஒரு ஒற்றை அலகாகக் கருதப்படும் நிரலாக்க அறிக்கைகளின் குழு. இங்கு { என்பது அலகின் ஆரம்பம் மற்றும் }அதன் முடிவு. தொகுதிகள் ஒன்றோடொன்று உள்ளமைக்கப்படலாம் அல்லது அவை வரிசையாக இருக்கலாம். மேலே உள்ள திட்டத்தில் இரண்டு உள்ளமை தொகுதிகள் உள்ளன. வெளிப்புறமானது ஹலோ வகுப்பின் உடலைக் கொண்டுள்ளது . உள் தொகுதி முக்கிய() முறையின் உடலைக் கொண்டுள்ளது .

public static void main (String args []) {

இங்கே முக்கிய முறையின் ஆரம்பம். ஒரு முறை என்பது ஒரு நடத்தை அல்லது ஒரு நிரலில் ஒரு செயல்பாட்டைச் செய்ய உங்களை அனுமதிக்கும் கட்டளைகளின் வரிசை. எடுத்துக்காட்டாக, 2 எண்களைப் பெருக்கவும் அல்லது ஒரு சரத்தை அச்சிடவும். வேறு வார்த்தைகளில் கூறுவதானால், ஒரு முறை ஒரு செயல்பாடு. வேறு சில நிரலாக்க மொழிகளில், முறைகள் பெரும்பாலும் "செயல்பாடுகள்" என்று குறிப்பிடப்படுகின்றன. ஜாவா நிரலின் அனைத்து கூறுகளையும் போலவே முறைகளும் ஒரு வகுப்பிற்குள் அமைந்துள்ளன. ஒவ்வொரு வகுப்பிலும் ஒன்று, பல அல்லது முறைகள் இல்லாமல் இருக்கலாம். பொது என்பது ஒரு அணுகல் மாற்றி. பொது மாற்றியமைப்புடன் குறிக்கப்பட்ட ஒரு மாறி, முறை அல்லது வகுப்பை நிரலில் எங்கிருந்தும் அணுகலாம். ஜாவாவில் அவற்றில் நான்கு உள்ளன: பொது, தனியார், பாதுகாக்கப்பட்ட மற்றும் இயல்புநிலை (காலி). அவற்றைப் பற்றி சிறிது நேரம் கழித்து பேசுவோம். முதல் படியாக உங்கள் எல்லா முறைகளையும் பொதுவில் வைப்பது நல்லது. வெற்றிடமானதுமுறையின் திரும்பும் வகை. வெற்றிடமானது எந்த மதிப்பையும் தராது. பிரதானமானது நிரலின் தொடக்கப் புள்ளியைக் குறிக்கிறது. இதற்குப் பெயர்தான் முறை. String[] args என்பது ஒரு முக்கிய முறை வாதம். இப்போதைக்கு, கிட்டத்தட்ட ஒவ்வொரு ஜாவா நிரலுக்கும் முக்கிய முறை உள்ளது என்பதை அறிந்தால் போதும் , அது நிரலைத் தொடங்குகிறது மற்றும் பொது நிலையான வெற்றிட பிரதான (ஸ்ட்ரிங்[] args) ஸ்டாடிக் முறைகள் வகுப்பில் வேலை செய்யக்கூடியவை என அறிவிக்கிறது. அவற்றின் அறிவிப்பில் நிலையான முக்கிய சொல்லைப் பயன்படுத்தும் முறைகள் நேரடியாக உள்ளூர் மற்றும் நிலையான மாறிகளுடன் மட்டுமே செயல்பட முடியும்.

 System.out.println("Hello, Java!"); 

முறையாக இந்த வரி அவுட் ஆப்ஜெக்ட்டின் println முறையை செயல்படுத்துகிறது. அவுட் ஆப்ஜெக்ட் அவுட்புட்ஸ்ட்ரீம் வகுப்பில் அறிவிக்கப்பட்டு , கணினி வகுப்பில் நிலையான முறையில் துவக்கப்படும் . இருப்பினும், புதியவர்களுக்கு இது சற்று சிக்கலானது. இந்த வரி "ஹலோ, ஜாவா!" என்ற வார்த்தைகளை அச்சிடுகிறது என்பதை ஒரு தொடக்கக்காரர் அறிந்தால் போதும். பணியகத்திற்கு. எனவே உங்கள் IDE இல் நிரலை இயக்கினால், கன்சோலில் வெளியீட்டைப் பெறுவீர்கள்:

ஜாவா அடிப்படை தொடரியல் விதிகள்

ஜாவாவில் நிரலாக்கத்தின் போது பின்பற்ற வேண்டிய சில முக்கிய தொடரியல் விதிகள் உள்ளன:

• கோப்பின் பெயர் வகுப்பின் பெயருடன் ஒத்ததாக இருக்க வேண்டும்;
• பெரும்பாலும் ஒவ்வொரு வகுப்பும் .java நீட்டிப்புடன் தனித்தனி கோப்பில் இருக்கும். வகுப்பு கோப்புகள் பொதுவாக கோப்புறைகளாக தொகுக்கப்படும். இந்த கோப்புறைகள் தொகுப்புகள் என்று அழைக்கப்படுகின்றன;
• எழுத்துக்கள் கேஸ் சென்சிடிவ். சரம் சரத்திற்கு சமம் அல்ல ;
• ஜாவா நிரல் செயலாக்கத்தின் ஆரம்பம் எப்போதும் முக்கிய முறையில் தொடங்குகிறது: பொது நிலையான வெற்றிட பிரதான (ஸ்ட்ரிங் [] args) . முக்கிய () முறை எந்த ஜாவா நிரலுக்கும் தேவையான பகுதியாகும்;
• முறை (செயல்முறை, செயல்பாடு) என்பது கட்டளைகளின் வரிசை. முறைகள் பொருளின் நடத்தையை வரையறுக்கின்றன;
• நிரல் கோப்பில் உள்ள முறைகளின் வரிசை பொருத்தமற்றது;
• ஒரு வகுப்பின் பெயரின் முதல் எழுத்து பெரிய எழுத்தில் உள்ளது என்பதை நினைவில் கொள்ளவும். நீங்கள் பல சொற்களைப் பயன்படுத்தினால், ஒவ்வொரு வார்த்தையின் முதல் எழுத்துக்கும் பெரிய எழுத்தைப் பயன்படுத்தவும் (“MyFirstJavaClass”);
• ஜாவா தொடரியல் அனைத்து முறைகளின் பெயர்களும் ஒரு சிறிய எழுத்துடன் தொடங்குகின்றன. பல சொற்களைப் பயன்படுத்தும் போது, ​​அடுத்தடுத்த எழுத்துக்கள் பெரியதாக இருக்கும் ("பொது வெற்றிடமான myFirstMethodName ()");
• கோப்புகள் வகுப்பு பெயர் மற்றும் .java நீட்டிப்பு ("MyFirstJavaClass.java") மூலம் சேமிக்கப்படும்;
• ஜாவா தொடரியல், குறியீட்டின் தொகுதி மற்றும் புதிய குறியீட்டின் பகுதியைக் குறிக்கும் "{...}" பிரிப்பான்கள் உள்ளன;
• ஒவ்வொரு குறியீடு அறிக்கையும் அரைப்புள்ளியுடன் முடிவடைய வேண்டும்.

ஜாவா மாறிகள் மற்றும் தரவு வகைகள் மாறிகள் என்பது தரவைச் சேமிக்கப் பயன்படும் சிறப்புப் பொருள்கள். ஏதேனும் தரவு. ஜாவாவில், எல்லா தரவுகளும் மாறிகளில் சேமிக்கப்படும். ஒரு மாறி என்பது ஒதுக்கப்பட்ட இடம் அல்லது மாறியை வைப்பதற்கான பெட்டி என்று நீங்கள் கூறலாம். ஒவ்வொரு மாறிக்கும் அதன் தரவு வகை, பெயர் (அடையாளங்காட்டி) மற்றும் மதிப்பு இருக்கும். தரவு வகைகள் பழமையானவை மற்றும் பழமையானவை அல்லாதவை அல்லது குறிப்புகளாக இருக்கலாம். பழமையான தரவு வகைகள் இருக்கலாம்:

• முழு எண்கள்: பைட், ஷார்ட், இன்ட், லாங்
• பின்னங்கள்: மிதவை மற்றும் இரட்டை
• தருக்க மதிப்புகள்: பூலியன்
• குறியீட்டு மதிப்புகள் (எழுத்துகள் மற்றும் எண்களைக் குறிக்கும்): கரி

ஜாவா மாறிகள் எடுத்துக்காட்டு:

int s;
s = 5;  
char myChar = ‘a’; 

இந்த குறியீட்டில் நாம் ஒரு முழு எண் மாறி s (ஒரு வெற்று கொள்கலன்) ஐ உருவாக்கி, அதில் மதிப்பு 5 ஐ வைக்கிறோம். myChar என்ற மாறியின் அதே கதை . நாங்கள் அதை ஒரு சார் தரவு வகையுடன் உருவாக்கி, அதை a எழுத்தாக வரையறுத்துள்ளோம் . இந்த வழக்கில் நாம் ஒரு மாறியை உருவாக்கி, ஒரே நேரத்தில் அதற்கு ஒரு மதிப்பை ஒதுக்குகிறோம். ஜாவா தொடரியல் இந்த வழியில் செய்ய உங்களை அனுமதிக்கிறது. குறிப்பு வகைகள் என்பது மதிப்புகள் அல்லது பிற பொருள்களுக்கான குறிப்புகளை வைத்திருக்கும் சில பொருள்கள். அவை பூஜ்யத்தைப் பற்றிய குறிப்பையும் கொண்டிருக்கலாம். பூஜ்யம் என்பது மதிப்பு இல்லாததைக் குறிக்க ஒரு சிறப்பு மதிப்பு. குறிப்பு வகைகளில் சரம், வரிசைகள் மற்றும் நீங்கள் விரும்பும் ஒவ்வொரு வகுப்பும் அடங்கும். உங்களிடம் வயலின் வகுப்பு இருந்தால், இந்த வகுப்பின் மாறியை உருவாக்கலாம். ஜாவா குறிப்பு வகை மாறிகள் எடுத்துக்காட்டு:

String s = “my words”; 
Violin myViolin; 

அவற்றைப் பற்றி நீங்கள் பின்னர் அறிந்து கொள்வீர்கள். பழமையான அல்லாத வகை மாறிகள் பெரிய எழுத்துக்களில் இருந்து தொடங்குகின்றன, அதே நேரத்தில் பழமையானவை - சிறிய எழுத்துக்களில் இருந்து தொடங்குகின்றன. உதாரணமாக:

int i = 25;
String s = “Hello, Java!”; 

ஜாவா வரிசைகள்

வரிசைகள் என்பது ஒரே வகையின் பல மாறிகளை சேமிக்கும் பொருள்கள். இருப்பினும், ஒரு வரிசையே குவியலில் உள்ள ஒரு பொருளாகும். எப்படி அறிவிப்பது, கட்டமைப்பது மற்றும் துவக்குவது என்பதை இனிவரும் அத்தியாயங்களில் பார்ப்போம். வரிசை உதாரணம்:

int[] myArray = {1,7,5};

இங்கே மூன்று முழு எண்களிலிருந்து (1,7 மற்றும் 5) கொண்ட ஒரு வரிசை உள்ளது.

ஜாவா எனம்ஸ்

பழமையான தரவு வகைகளுக்கு கூடுதலாக, ஜாவாவில் எண் அல்லது கணக்கீடு போன்ற ஒரு வகை உள்ளது. கணக்கீடுகள் தர்க்கரீதியாக தொடர்புடைய மாறிலிகளின் தொகுப்பைக் குறிக்கின்றன. எண் ஆபரேட்டரைப் பயன்படுத்தி ஒரு கணக்கெடுப்பு அறிவிக்கப்படுகிறது, அதைத் தொடர்ந்து கணக்கீட்டின் பெயர். பின்னர் கமாவால் பிரிக்கப்பட்ட எண்ணியல் கூறுகளின் பட்டியல் வரும்:

enum DayOfWeek {
     MONDAY,
     TUESDAY,
     WEDNESDAY,
     THURSDAY,
     FRIDAY,
     SATURDAY,
     SUNDAY
}

ஒரு கணக்கீடு உண்மையில் ஒரு புதிய வகையைக் குறிக்கிறது, எனவே அந்த வகையின் மாறியை வரையறுத்து அதைப் பயன்படுத்தலாம். கணக்கீட்டைப் பயன்படுத்துவதற்கான ஒரு எடுத்துக்காட்டு இங்கே.

ஜாவா என்ற உதாரணம்

public class MyNum{      
    public static void main(String[] args) {
          
        Day myDay = DayOfWeek.FRIDAY;
        System.out.println(myDay);	//print a day from the enum     
}
}
enum DayOfWeek{
  
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

நீங்கள் நிரலை இயக்கினால், FRIDAY கன்சோலில் அச்சிடப்படும். உங்கள் Enum மற்றும் MyNum வகுப்புக் குறியீட்டை ஒரே கோப்பில் வைக்கலாம், ஆனால் இரண்டு தனித்தனி கோப்புகளை உருவாக்குவது சிறந்தது: ஒன்று MyNum வகுப்பிற்கும் ஒன்று நாள் enum. IntelliJ IDEA ஆனது உருவாக்கும் போது enum ஐ தேர்வு செய்ய உங்களை அனுமதிக்கிறது.

ஜாவாவில் மாறிகளை அறிவித்தல்

உண்மையில் நாம் மேலே சில மாறிகளை அறிவித்துள்ளோம் மற்றும் அவற்றை அடையாளம் கண்டுள்ளோம். அறிவிப்பு என்பது ஒரு குறிப்பிட்ட வகையின் மாறிக்கு நினைவகத்தை ஒதுக்கி அதற்கு பெயரிடும் செயல்முறையாகும். அந்த மாதிரி ஏதாவது:

int i; 
boolean boo; 

அசைன்மென்ட் ஆபரேட்டரை (=) பயன்படுத்தி ஒரு மாறியை துவக்கவும் அறிவிக்கலாம். அதாவது நாம் ஒதுக்கிய நினைவகத்தில் ஒரு குறிப்பிட்ட மதிப்பை வைக்கிறோம். அறிவிப்பின் ஒரு கணத்தில் அல்லது அதற்குப் பிறகு நாம் அதைச் சரியாகச் செய்யலாம்.

ஒரு மாறி உதாரணத்தை அறிவிக்கிறது

String str; 
int i = 5; 
Str = “here is my string”; 

துவக்கம் இல்லாமல் ஒரு மாறியை நீங்கள் அறிவித்தால், அது எப்படியும் சில இயல்புநிலை மதிப்பைப் பெறுகிறது. எண்ணுக்கு இந்த மதிப்பு 0, சரம் அல்லது வேறு எந்த குறிப்பு வகைக்கும் இது ஒரு சிறப்பு பூஜ்ய அடையாளங்காட்டியாகும்.

ஜாவா அடையாளங்காட்டிகள்

அடையாளங்காட்டிகள் என்பது ஜாவா கூறுகளின் பெயர்கள் - வகுப்புகள், மாறிகள் மற்றும் முறைகள். அனைத்து ஜாவா கூறுகளுக்கும் பெயர்கள் இருக்க வேண்டும்.

Class Violin {
int age; 
String masterName;  
}

வயலின் என்பது வகுப்பு அடையாளங்காட்டி. வயது மற்றும் முதன்மை பெயர் ஆகியவை மாறிகள் அடையாளங்காட்டிகள். இங்கே சில ஜாவா அடையாளங்காட்டி விதிகள்:

• அனைத்து அடையாளங்காட்டிகளும் லத்தீன் எழுத்து (A முதல் Z அல்லது a to z), நாணய எழுத்து ($) அல்லது அடிக்கோடிடுதல் (_) ஆகியவற்றுடன் தொடங்கும்.
• முதல் எழுத்துக்குப் பிறகு, அடையாளங்காட்டிகள் எந்த எழுத்துக் கலவையையும் கொண்டிருக்கலாம்.
• ஒரு ஜாவா முக்கிய வார்த்தை ஒரு அடையாளங்காட்டியாக இருக்க முடியாது (சிறிது நேரம் கழித்து நீங்கள் முக்கிய வார்த்தைகளை கண்டுபிடிக்கலாம்).
• அடையாளங்காட்டிகள் வழக்கு உணர்திறன் கொண்டவை.

அடையாளங்காட்டிகளின் உதாரணம்

சட்ட அடையாளங்காட்டிகள்: java, $mySalary, _something சட்டவிரோத அடையாளங்காட்டிகள்: 1stPart, -one

ஜாவா மாற்றிகள்

மாற்றியமைப்பாளர்கள் என்பது ஜாவா மொழியின் சிறப்பு வார்த்தைகளாகும், நீங்கள் கூறுகளை மாற்ற பயன்படுத்தலாம் (வகுப்புகள், முறைகள், மாறிகள்). ஜாவாவில் இரண்டு வகை மாற்றிகள் உள்ளன: அணுகல் மற்றும் அணுகல் அல்லாத மாற்றிகள்.

அணுகல் மாற்றிகளின் உதாரணம்

ஜாவாவில் 4 அணுகல் மாற்றிகள் உள்ளன:

• பொது . ஒரு பொது உறுப்பு இதை வகுப்பிலிருந்து, வகுப்பிற்கு வெளியே, தொகுப்பிற்கு உள்ளேயும் வெளியேயும் அணுகலாம்
• இயல்புநிலை (காலி) மாற்றியமைப்புடன் கூடிய உறுப்பு தொகுப்பிற்குள் மட்டுமே அணுக முடியும்
• பாதுகாக்கப்பட்ட மாற்றியை குழந்தை வகுப்பு மூலம் தொகுப்பிற்கு உள்ளேயும் வெளியேயும் அணுகலாம்
• அது அறிவித்த வகுப்பிற்குள் மட்டுமே தனிப்பட்ட உறுப்பு கிடைக்கும்.

அணுகல் அல்லாத மாற்றிகளின் உதாரணம்

அவற்றில் 7 உள்ளன

• நிலையான
• இறுதி
• சுருக்கம்
• ஒத்திசைக்கப்பட்டது
• நிலையற்ற
• எளிதில் ஆவியாகிற
• பூர்வீகம்

ஜாவா முக்கிய வார்த்தைகள்

ஜாவா முக்கிய வார்த்தைகள் என்பது ஜாவாவில் பயன்படுத்த வேண்டிய சிறப்பு சொற்கள், அவை குறியீட்டின் திறவுகோலாக செயல்படுகின்றன. அவை ஒதுக்கப்பட்ட சொற்களாகவும் அறியப்படுகின்றன: மாறிகள், முறைகள், வகுப்புகள் போன்றவற்றின் அடையாளங்காட்டிகளுக்கு அவற்றைப் பயன்படுத்த முடியாது. அவை இங்கே:

• abstract : சுருக்க வகுப்பை அறிவிக்க முக்கிய வார்த்தை.
• boolean : ஒரு மாறியை பூலியன் வகையாக அறிவிக்க ஜாவா பூலியன் முக்கிய சொல். இத்தகைய மாறிகள் உண்மையாகவும் பொய்யாகவும் மட்டுமே இருக்க முடியும்.
• break : லூப்பை உடைக்க அல்லது அறிக்கையை மாற்ற ஜாவா பிரேக் முக்கிய சொல்லைப் பயன்படுத்தவும்.
• byte : ஒரு பைட் முழு எண் மாறியை அறிவிப்பதற்கான ஜாவா பைட் முக்கிய வார்த்தை.
• வழக்கு : உரையின் தொகுதிகளைக் குறிக்க ஸ்விட்ச் ஸ்டேட்மெண்ட்களுடன் பயன்படுத்தப்படுகிறது.
• catch : ட்ரை பிளாக்கிற்குப் பிறகு விதிவிலக்குகளைப் பிடிக்கப் பயன்படுகிறது .
• char : ஒரு எழுத்து மாறிக்கான ஜாவா சார் முக்கிய சொல். இது கையொப்பமிடப்படாத 16-பிட் யூனிகோட் எழுத்துகளை வைத்திருக்க முடியும்.
• class : ஒரு வகுப்பை அறிவிக்க ஜாவா கிளாஸ் முக்கிய வார்த்தை.
• தொடரவும் : லூப்பைத் தொடர ஜாவா முக்கிய வார்த்தை.
• default : சுவிட்ச் ஸ்டேட்மெண்ட்டில் குறியீட்டின் இயல்புநிலைத் தொகுதியைக் குறிப்பிட ஜாவா முன்னிருப்புச் சொல்.
• do : do-while loop கட்டுமானத்தில் பயன்படுத்தப்படுகிறது.
• இரட்டை : எண் மாறியை அறிவிக்க ஜாவா இரட்டைச் சொல் பயன்படுத்தப்படுகிறது. இது 8 பைட் மிதக்கும் புள்ளி எண்களை வைத்திருக்க முடியும்.
• வேறு : நீங்கள் வேறு நிபந்தனை அறிக்கைகளில் இதைப் பயன்படுத்தலாம்.
• enum : நிலையான மாறிலிகளை வரையறுக்கப் பயன்படுகிறது.
• நீட்டிக்கிறது : ஜாவா ஒரு வர்க்கம் மற்றொரு வகுப்பை விரிவுபடுத்துகிறது என்பதைக் குறிக்க முக்கிய சொல்லை நீட்டிக்கிறது (மற்ற வகுப்பின் குழந்தை வகுப்பு).
• இறுதி : மாறி ஒரு மாறிலி என்பதைக் குறிக்கும் முக்கிய சொல்.
• இறுதியாக : விதிவிலக்கு கையாளப்பட்டாலும் இல்லாவிட்டாலும் செயல்படுத்தப்படும் குறியீட்டின் தொகுதியைக் குறிக்கிறது.
• float : 4-பைட் மிதக்கும் புள்ளி எண்ணைக் கொண்டிருக்கும் ஒரு மாறி.
• for : loop ஐ தொடங்குவதற்கான ஒரு முக்கிய சொல். சில நிபந்தனைகள் உண்மையாக இருக்கும்போது, ​​அறிவுறுத்தல்களின் தொகுப்பை மீண்டும் மீண்டும் இயக்க இது பயன்படுகிறது.
• if : நிலைமையை சரிபார்ப்பதற்கான முக்கிய சொல். நிபந்தனை உண்மையாக இருந்தால் அது தடுப்பை செயல்படுத்துகிறது.
• செயல்படுத்துகிறது : ஒரு இடைமுகத்தை செயல்படுத்துவதற்கான முக்கிய சொல்.
• import : ஒரு தொகுப்பு, வகுப்பு அல்லது இடைமுகத்தை இறக்குமதி செய்வதற்கான ஜாவா முக்கிய வார்த்தை.
• instanceof : பொருள் ஒரு குறிப்பிட்ட வகுப்பின் அல்லது இடைமுகத்தின் நிகழ்வா என்பதைச் சரிபார்க்கிறது.
• int : 4-பைட் கையொப்பமிடப்பட்ட முழு எண் எண்ணை வைத்திருக்கக்கூடிய ஒரு மாறி.
• இடைமுகம் : இடைமுகத்தை அறிவிக்க ஜாவா இடைமுகச் சொல் பயன்படுத்தப்படுகிறது.
• நீளம் : 8-பைட் கையொப்பமிடப்பட்ட முழு எண் எண்ணை வைத்திருக்கக்கூடிய ஒரு மாறி.
• நேட்டிவ் : JNI (ஜாவா நேட்டிவ் இன்டர்ஃபேஸ்) ஐப் பயன்படுத்தி நேட்டிவ் குறியீட்டில் ஒரு முறை செயல்படுத்தப்படுவதைக் குறிப்பிடுகிறது.
• புதிய : புதிய பொருட்களை உருவாக்க ஜாவா புதிய முக்கிய சொல்.
• தொகுப்பு : ஜாவா வகுப்புகளின் கோப்புகளுக்கான ஜாவா தொகுப்பை (கோப்புறை) அறிவிக்கிறது.
• private : ஒரு அணுகல் மாற்றியானது ஒரு முறை அல்லது மாறி அது அறிவிக்கப்பட்ட வகுப்பில் மட்டுமே தெரியும் என்பதைக் குறிக்கிறது.
• பாதுகாக்கப்பட்ட : ஒரு அணுகல் மாற்றியமைப்பானது குழந்தை வகுப்பு மூலம் தொகுப்பிற்கு உள்ளேயும் வெளியேயும் ஒரு முறை அல்லது மாறியை அணுக முடியும் என்பதைக் குறிக்கிறது.
• பொது : அணுகல் மாற்றி என்பது ஒரு உறுப்பு எங்கும் அணுகக்கூடியது என்பதைக் குறிக்கிறது.
• return : ஒரு முறையின் செயல்பாட்டின் முடிவை வழங்குகிறது.
• short : 2-பைட் கையொப்பமிடப்பட்ட முழு எண் எண்ணை வைத்திருக்கக்கூடிய ஒரு மாறி.
• நிலையான : ஒரு மாறி அல்லது முறை ஒரு வர்க்கம், ஒரு பொருள், முறை அல்ல என்பதைக் குறிக்கிறது.
• strictfp : மிதக்கும் புள்ளி கணக்கீடுகளை கட்டுப்படுத்துகிறது.
• super : பெற்றோர் வர்க்கப் பொருளைக் குறிக்கிறது.
• சுவிட்ச் : செயல்படுத்தப்பட வேண்டிய குறியீடு தொகுதியை (அல்லது அவற்றில் பல) தேர்ந்தெடுக்கிறது.
• synchronized : ஒரு அணுகல் அல்லாத மாற்றி. ஒரு நேரத்தில் ஒரு நூல் மூலம் மட்டுமே இந்த முறையை அணுக முடியும் என்று அது குறிப்பிடுகிறது.
• இது : ஒரு முறை அல்லது கட்டமைப்பாளரில் தற்போதைய பொருளைக் குறிக்கிறது.
• வீசுதல் : விதிவிலக்கை வெளிப்படையாக வீசுவதற்குப் பயன்படுகிறது.
• வீசுகிறது : விதிவிலக்கு அறிவிக்கிறது.
• நிலையற்றது : ஒரு நிலையற்ற தரவுப் பகுதியை வரிசைப்படுத்த முடியாது.
• முயற்சி : விதிவிலக்குகள் சரிபார்க்கப்படும் குறியீட்டின் தொகுதியைத் தொடங்குகிறது.
• void : ஒரு முறை மதிப்பை வழங்காது என்பதைக் குறிப்பிடுகிறது.
• ஆவியாகும் : ஒரு மாறி ஒத்திசைவின்றி மாறக்கூடும் என்பதைக் குறிக்கிறது.
• while : சிறிது நேர வளையத்தை தொடங்குகிறது. நிபந்தனை உண்மையாக இருக்கும் போது நிரலின் ஒரு பகுதியை பல முறை மீண்டும் கூறுகிறது.

ஜாவாவில் கருத்துகள்

ஜாவா ஒற்றை வரி மற்றும் பல வரி கருத்துகளை ஆதரிக்கிறது. எந்தக் கருத்தின் உள்ளேயும் எல்லா எழுத்துகளும் உள்ளன, அவை ஜாவா கம்பைலரால் புறக்கணிக்கப்படும். டெவலப்பர்கள் குறியீட்டை விளக்குவதற்கு அல்லது எதையாவது நினைவுபடுத்துவதற்கு அவற்றைப் பயன்படுத்துகின்றனர். கருத்து எடுத்துக்காட்டுகள்:

//single-line comment 
/*here we have a multi-line comment. As you can see it uses slash and asterisks from both sides of it.*/   

public class HelloJava {
   /* this program was created to demonstrate comments in Java. This one is a multi-line comment.
   You can use such comments anywhere in your programs*/
   public static void main(String[] args) {
       //here is a single-line comment
       String j = "Java"; //This is my string
       int a = 15; //here I have an integer
       System.out.println("Hello, " + j + " " + a + "!");
       int[] myArray = {1,2,5};
       System.out.println(myArray.length);
   }
}

ஜாவாவில் உள்ள எழுத்துக்கள்

ஜாவாவில் உள்ள எழுத்துகள் என்பது மாறிக்கு ஒதுக்கப்பட்ட சில நிலையான மதிப்புகள். அவை எண்கள் அல்லது உரைகள் அல்லது ஒரு மதிப்பைக் குறிக்க வேறு ஏதாவது இருக்கலாம்.

• ஒருங்கிணைந்த எழுத்துக்கள்
• மிதக்கும் புள்ளி இலக்கியங்கள்
• சார் எழுத்துக்கள்
• சரம் எழுத்துக்கள்
• பூலியன் எழுத்துக்கள்

ஜாவா சொற்களின் எடுத்துக்காட்டுகள்

 int i = 100; //100 is an integral  literal 
double d = 10.2;//10.2 is a floating point literal 
char c = ‘b’; //b is a char literal 
String myString = “Hello!”; 
boolean bool = true; 

குறிப்பு: பூஜ்யமும் எழுத்துப்பூர்வமானது.

ஜாவாவில் அடிப்படை ஆபரேட்டர்கள்

பல்வேறு வகையான ஆபரேட்டர்கள் உள்ளன: எண்கணிதம்

• + (எண்கள் கூட்டல் மற்றும் சரம் இணைத்தல்)
• - (கழித்தல் அல்லது கழித்தல்)
• * (பெருக்கல்)
• / (பிரிவு)
• % (மாடுலஸ் அல்லது மீதி)

ஒப்பீடு

• < (குறைவாக)
• <= (இதை விட குறைவாக அல்லது சமமாக)
• > (அதிகமாக)
• >= (அதை விட அதிகமாகவோ அல்லது சமமாகவோ)
• == (சமமாக)
• != (சமமாக இல்லை)

தருக்க

• && (மற்றும்)
• || (அல்லது)
• ! (இல்லை)
• ^ (XOR)

தரவு வகைகள், மாறிகள், முறைகள் மற்றும் ஆபரேட்டர்கள் பற்றி ஏற்கனவே அறிந்திருக்கிறோம். குறியீட்டின் ஒரு எளிய உதாரணம் இருக்கட்டும், ஆனால் முதல் ஜாவா நிரலை விட சற்று சிக்கலானது. NumberOperations என்ற வகுப்பை உருவாக்குவோம்

public class NumbersOperations {
   int a;
   int b;
   public static int add(int a,int b){
       return a+b;
   }
   public static int sub (int a, int b){
       return a-b;
   }
   public static double div (double a, int b){
       return a/b;
   }
}

2 எண்களைக் கொண்டு கையாள மர முறைகளைக் கொண்ட ஒரு வகுப்பு இங்கே உள்ளது. இந்த நிரலுக்குள் 2 எண்களைப் பெருக்க 4வது முறை int mul (int a, int b) ஐ எழுத முயற்சி செய்யலாம் . NumberOprations வேலையை நிரூபிக்க ஒரு வகுப்பையும் உருவாக்குவோம் :

public class NumberOperationsDemo {
   public static void main(String[] args) {
       int c = NumbersOperations.add(4,5);
       System.out.println(c);
       double d = NumbersOperations.div(1,2);
       System.out.println(d);
   }
}

நீங்கள் NumberOperationsDemo ஐ இயக்கினால் , அடுத்த வெளியீட்டைப் பெறுவீர்கள்:

முடிவுரை

இவை ஜாவா மொழியின் அடிப்படைகள் மற்றும் பல விஷயங்கள் குழப்பத்தை ஏற்படுத்தும். என்ன என்பதைக் கண்டுபிடிக்க நிறைய நிரலாக்கங்கள் தேவை. இந்த மொழியை நீங்கள் கற்றுக் கொள்வதற்கான ஒரே வழி - பயிற்சி மூலம். இப்போதே குறியீட்டைத் தொடங்குங்கள், கோட்ஜிம் பிராக்டிகல் ஜாவா பாடத்தின் முதல் தேடலை முடிக்க முயற்சிக்கவும் . உங்கள் ஜாவா கற்றலில் நல்ல அதிர்ஷ்டம்!