ഇന്ന് നമുക്ക് ജാവയിലെ തരങ്ങൾ പെട്ടെന്ന് മനസ്സിലാക്കാം. ജാവയിലെ എല്ലാ തരങ്ങളും രണ്ട് ഗ്രൂപ്പുകളായി തിരിച്ചിരിക്കുന്നു - പ്രാകൃതവും റഫറൻസ് തരങ്ങളും.

ഇവിടെ നമ്മൾ പ്രാകൃത തരങ്ങൾ കൈകാര്യം ചെയ്യും.

ശരി, ഒരുപക്ഷേ ഏറ്റവും പ്രാകൃതമായ തരം ലോജിക്കൽ ഡാറ്റാ തരമാണ്. അവൻ തന്നെ ബൂളിയൻ- ഏറ്റവും ലളിതമായ ഡാറ്റ തരം. ഈ തരത്തിലുള്ള ഒരു വേരിയബിളിന് രണ്ട് മൂല്യങ്ങൾ മാത്രമേ സംഭരിക്കാൻ കഴിയൂ: ശരിയോ തെറ്റോ. ഈ തരത്തിലുള്ള വേരിയബിളുകൾ ഉപയോഗിച്ച് ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ നടത്താം: "!" — നിഷേധം (അല്ല), “&&” — ലോജിക്കൽ AND (ഒപ്പം), “||” - ലോജിക്കൽ OR (അല്ലെങ്കിൽ), "^" - എക്സ്ക്ലൂസീവ് OR (xor). ഈ പ്രവർത്തനങ്ങൾക്കുള്ള ട്രൂത്ത് ടേബിളുകൾ കണ്ടെത്താനാകും.

അടുത്തത് പൂർണ്ണസംഖ്യ ഡാറ്റ തരങ്ങളാണ്. ജാവയിലെ ഈ തരങ്ങളിൽ ഇനിപ്പറയുന്നവ ഉൾപ്പെടുന്നു: ബൈറ്റ്, ചെറുത്, intഒപ്പം നീളമുള്ള. ഈ തരങ്ങളിൽ ഓരോന്നും വ്യത്യസ്ത ശ്രേണിയിലുള്ള മൂല്യങ്ങൾ സ്വീകരിക്കുന്നു, അവയ്ക്ക് പൊതുവായുള്ള ഒരേയൊരു കാര്യം എല്ലാ മൂല്യങ്ങളും എല്ലായ്പ്പോഴും പൂർണ്ണസംഖ്യകളാണ്. അതിനാൽ, ബൈറ്റ് തരത്തിന് ഇടവേള 128 മുതൽ 127 വരെ, ഹ്രസ്വ തരത്തിന്? 32768 മുതൽ 32767 വരെ, int തരത്തിന്? അവ ഉപയോഗിച്ച് നമ്മൾ കുറയ്ക്കുക, കൂട്ടിച്ചേർക്കുക, ഹരിക്കുക, ഗുണിക്കുക...

തീർച്ചയായും ഫ്ലോട്ടിംഗ് പോയിന്റ് ഡാറ്റ തരങ്ങളും ഫ്രാക്ഷണൽ തരങ്ങളും ഉണ്ട്. ഈ ഫ്ലോട്ട്ഒപ്പം ഇരട്ട പ്രിസിഷൻ തരവും ഇരട്ടി. float ഏകദേശം കൂടാതെ, ഈ തരങ്ങൾക്ക് പ്രത്യേക അർത്ഥങ്ങളുണ്ട് +? — പ്ലസ് അനന്തത, -? - മൈനസ് ഇൻഫിനിറ്റി, NaN ഒരു സംഖ്യയല്ല (ഉദാഹരണത്തിന്, 0 കൊണ്ട് ഹരിക്കുമ്പോൾ).

അതിനാൽ, നമുക്ക് ഏതെങ്കിലും തരത്തിലുള്ള വേരിയബിൾ പ്രഖ്യാപിക്കണമെങ്കിൽ, ആദ്യം അതിന്റെ തരവും അതിന്റെ പേരും സൂചിപ്പിക്കണം:

ഇന്റ് ഐ; ഫ്ലോട്ട് എഫ്;

നിങ്ങൾക്ക് പ്രാരംഭ മൂല്യം ഉടൻ വ്യക്തമാക്കാനും കഴിയും:

Int i = 0; ഫ്ലോട്ട് f = 3.5;

ജാവ ഇംപ്ലിസിറ്റ് ടൈപ്പ് കൺവേർഷൻ ഉപയോഗിക്കുന്നു. അത് എന്താണ്? ശരി, ഉദാഹരണത്തിന്, നിങ്ങൾ രണ്ട് വേരിയബിളുകൾ ചേർക്കാൻ ആഗ്രഹിക്കുന്നു, ഒന്ന് int ടൈപ്പ്, മറ്റൊന്ന് ടൈപ്പ് ഫ്ലോട്ട്. അപ്പോൾ നിങ്ങളുടെ int എന്ന വേരിയബിൾ ടൈപ്പ് ഫ്ലോട്ട് ആയി പരിവർത്തനം ചെയ്യപ്പെടും, അതിനുശേഷം മാത്രമേ കൂട്ടിച്ചേർക്കൽ സംഭവിക്കൂ. അതനുസരിച്ച്, ഫലം ഫ്ലോട്ട് തരത്തിലുള്ളതായിരിക്കും. ഈ സാഹചര്യത്തിൽ, ചെറിയ തരം എല്ലായ്പ്പോഴും വലുതായി പരിവർത്തനം ചെയ്യപ്പെടുന്നു, കൂടാതെ പൂർണ്ണസംഖ്യ ഫ്രാക്ഷണൽ ഒന്നായി മാറുന്നു. ശരി, ഉദാഹരണത്തിന്, ഇത് പ്രവർത്തിക്കും:

Int a = 3; ഫ്ലോട്ട് ബി = 4.5, സി; c = a + b;

എന്നാൽ ഇതല്ല:

Int a = 3, c; ഫ്ലോട്ട് ബി = 4.5; c = a + b;

ഇവിടെ ഫലം എഴുതിയിരിക്കുന്ന വേരിയബിൾ int ടൈപ്പാണ്, ഫലം തന്നെ ഫ്ലോട്ട് ടൈപ്പ് ആയിരിക്കും. തീർച്ചയായും, നിങ്ങൾക്ക് ഒരു തരം മറ്റൊന്നിലേക്ക് സ്വമേധയാ പരിവർത്തനം ചെയ്യാൻ കഴിയും. ഇത് ഇതുപോലെയാണ് ചെയ്യുന്നത്:

Int a = 3, c; ഫ്ലോട്ട് ബി = 4.5; c = (int)(a + b);

ഇവിടെ, നൊട്ടേഷൻ (int) ഉപയോഗിച്ച്, ഞങ്ങൾ a, b എന്നിവയുടെ തുകയെ int എന്ന് ടൈപ്പുചെയ്യുന്നു. എന്നിരുന്നാലും, പൂർണ്ണസംഖ്യ വേരിയബിളിന് 7.5 മൂല്യം സംഭരിക്കാൻ കഴിയില്ലെന്ന് വ്യക്തമാണ്. ഫ്രാക്ഷണൽ തരങ്ങൾ പൂർണ്ണസംഖ്യകളിലേക്ക് കാസ്‌റ്റ് ചെയ്യുമ്പോൾ, ഫ്രാക്ഷണൽ ഭാഗം വെറുതെ കളയുന്നു. ഇത് ചില പിശകുകൾക്ക് കാരണമായേക്കാം, അതിനാൽ അതിനെക്കുറിച്ച് മറക്കരുത്.

ഒരു വേരിയബിൾ ഞങ്ങൾക്ക് ഒരു സ്റ്റോറേജ് നാമത്തിൽ നൽകിയിരിക്കുന്നു, അതുവഴി ഞങ്ങളുടെ പ്രോഗ്രാം കൈകാര്യം ചെയ്യാൻ കഴിയും. ജാവയിലെ ഓരോ വേരിയബിളിനും ഒരു പ്രത്യേക തരം ഉണ്ട്, അത് മെമ്മറിയിൽ അതിന്റെ വലുപ്പവും സ്ഥാനവും നിർണ്ണയിക്കുന്നു; മെമ്മറിയിൽ സൂക്ഷിക്കാൻ കഴിയുന്ന മൂല്യങ്ങളുടെ ശ്രേണി; കൂടാതെ വേരിയബിളിൽ പ്രയോഗിക്കാൻ കഴിയുന്ന ഒരു കൂട്ടം പ്രവർത്തനങ്ങളും.

എല്ലാ വേരിയബിളുകളും ഉപയോഗിക്കുന്നതിന് മുമ്പ് അവ പ്രഖ്യാപിക്കണം. അടിസ്ഥാന പരസ്യ ഫോം ചുവടെ:

ഡാറ്റ തരം വേരിയബിൾ [=മൂല്യം], [വേരിയബിൾ [=മൂല്യം], ...] ;

ഒരു നിർദ്ദിഷ്‌ട തരത്തിന്റെ ഒന്നിലധികം വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ, നിങ്ങൾക്ക് കോമ-ഡിലിമിറ്റഡ് ലിസ്റ്റ് ഉപയോഗിക്കാം.

ജാവയിലെ വേരിയബിൾ ഡിക്ലറേഷന്റെയും ഇനീഷ്യലൈസേഷന്റെയും ഉദാഹരണങ്ങൾ ചുവടെയുണ്ട്:

Int a, b, c; // a, b, c എന്നീ മൂന്ന് പൂർണ്ണസംഖ്യകളുടെ പ്രഖ്യാപനം. int a = 10, b = 10; // സമാരംഭത്തിന്റെ ഉദാഹരണം. ബൈറ്റ് b = 22; // ടൈപ്പ് ബൈറ്റിന്റെ വേരിയബിൾ ബി ആരംഭിക്കുക. ഇരട്ട പൈ = 3.14159; // പൈയുടെ പ്രഖ്യാപനവും നിയമനവും. char a = "a"; // ചാറിന്റെ വേരിയബിളിന് "a" മൂല്യം നൽകിയിരിക്കുന്നു.

ഈ ട്യൂട്ടോറിയലിൽ, ജാവ ഭാഷയിൽ ലഭ്യമായ വിവിധ തരം വേരിയബിളുകൾ ഞങ്ങൾ നോക്കും. നിലവിലുണ്ട് മൂന്ന് തരം വേരിയബിളുകൾ:

• പ്രാദേശിക വേരിയബിളുകൾ;
• ഉദാഹരണ വേരിയബിളുകൾ;
• സ്റ്റാറ്റിക് വേരിയബിളുകൾ അല്ലെങ്കിൽ ക്ലാസ് വേരിയബിളുകൾ.

ജാവയിലെ ലോക്കൽ വേരിയബിളുകൾ

• ലോക്കൽ വേരിയബിളുകൾ രീതികളിലോ കൺസ്ട്രക്റ്ററുകളിലോ ബ്ലോക്കുകളിലോ പ്രഖ്യാപിക്കുന്നു.
• ഒരു മെത്തേഡ്, കൺസ്ട്രക്റ്റർ അല്ലെങ്കിൽ ബ്ലോക്ക് റൺ ചെയ്യുമ്പോൾ, മെത്തേഡ്, കൺസ്ട്രക്റ്റർ അല്ലെങ്കിൽ ബ്ലോക്ക് പൂർത്തിയായതിന് ശേഷം നശിപ്പിക്കപ്പെടുമ്പോൾ ലോക്കൽ വേരിയബിളുകൾ സൃഷ്ടിക്കപ്പെടുന്നു.
• ലോക്കൽ വേരിയബിളുകൾക്കായി ആക്സസ് മോഡിഫയറുകൾ ഉപയോഗിക്കാൻ കഴിയില്ല.
• പ്രഖ്യാപിത രീതി, കൺസ്ട്രക്റ്റർ അല്ലെങ്കിൽ ബ്ലോക്കിൽ മാത്രമേ അവ ദൃശ്യമാകൂ.
• ലോക്കൽ വേരിയബിളുകൾ സ്റ്റാക്ക് തലത്തിൽ ആന്തരികമായി നടപ്പിലാക്കുന്നു.
• ജാവയിൽ ലോക്കൽ വേരിയബിളുകൾക്ക് സ്ഥിര മൂല്യമില്ല, അതിനാൽ അവ ആദ്യ ഉപയോഗത്തിന് മുമ്പ് പ്രഖ്യാപിക്കുകയും ഒരു പ്രാരംഭ മൂല്യം നൽകുകയും വേണം.

ഉദാഹരണം

"പ്രായം" എന്നത് ഒരു പ്രാദേശിക വേരിയബിളാണ്, ഇത് "pupAge()" രീതിക്കുള്ളിൽ നിർവചിച്ചിരിക്കുന്നു, അതിന്റെ വ്യാപ്തി ഈ രീതിയിൽ മാത്രം പരിമിതപ്പെടുത്തിയിരിക്കുന്നു.

പബ്ലിക് ക്ലാസ് ടെസ്റ്റ്(പബ്ലിക് അസാധുവായ pupAge())( int age = 0; age = age + 7; System.out.println("പപ്പി പ്രായം:" + വയസ്സ്); ) പൊതു സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ(സ്ട്രിംഗ് ആർഗ്സ്)(ടെസ്റ്റ് ടെസ്റ്റ് = പുതിയ ടെസ്റ്റ്(); test.pupAge(); ) )

ഇനിപ്പറയുന്ന ഫലം ലഭിക്കും:

നായ്ക്കുട്ടിയുടെ പ്രായം: 7

ആരംഭിക്കാതെയുള്ള ഉദാഹരണം

ആരംഭിക്കാതെ "പ്രായം" ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം. സമാഹരിക്കുന്ന സമയത്ത് പ്രോഗ്രാം ഒരു പിശക് എറിയുന്നു.

പബ്ലിക് ക്ലാസ് ടെസ്റ്റ്(പബ്ലിക് അസാധുവായ pupAge())( int age; age = age + 7; System.out.println("Puppy age:" + age); ) പൊതു സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ(സ്ട്രിംഗ് ആർഗ്സ്)(ടെസ്റ്റ് ടെസ്റ്റ് = പുതിയ ടെസ്റ്റ് (); test.pupAge(); ) )

ഇത് സമാഹരിക്കുന്ന സമയത്ത് ഇനിപ്പറയുന്ന പിശക് സന്ദേശത്തിന് കാരണമാകും:

Test.java:4:വേരിയബിൾ നമ്പർ തുടങ്ങിയിരിക്കില്ല പ്രായം = വയസ്സ് + 7; ^1 പിശക്

ഉദാഹരണ വേരിയബിളുകൾ

• ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ ക്ലാസിനുള്ളിൽ പ്രഖ്യാപിക്കപ്പെടുന്നു, എന്നാൽ രീതി, കൺസ്ട്രക്റ്റർ അല്ലെങ്കിൽ ഏതെങ്കിലും ബ്ലോക്കിന് പുറത്ത്.
• ഒരു ഒബ്ജക്റ്റിനായി സ്റ്റാക്ക് സ്പേസ് അനുവദിക്കുമ്പോൾ, ഓരോ വേരിയബിൾ മൂല്യത്തിനും ഒരു സ്ലോട്ട് സൃഷ്ടിക്കപ്പെടുന്നു.
• ജാവയിൽ, "പുതിയ" കീവേഡ് ഉപയോഗിച്ച് ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുമ്പോൾ ഇൻസ്‌റ്റൻസ് വേരിയബിളുകൾ സൃഷ്‌ടിക്കുകയും ഒബ്‌ജക്റ്റ് നശിപ്പിക്കപ്പെടുമ്പോൾ നശിപ്പിക്കപ്പെടുകയും ചെയ്യുന്നു.
• വേരിയബിളുകളിൽ ഒന്നിലധികം രീതികൾ, കൺസ്ട്രക്റ്റർ, അല്ലെങ്കിൽ ബ്ലോക്ക്, അല്ലെങ്കിൽ ക്ലാസിലുടനീളം ഉണ്ടായിരിക്കേണ്ട ഒബ്ജക്റ്റിന്റെ അവസ്ഥയുടെ അവശ്യ ഭാഗങ്ങൾ എന്നിവ പരാമർശിക്കേണ്ട മൂല്യങ്ങൾ അടങ്ങിയിരിക്കുന്നു.
• ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ ഉപയോഗത്തിന് മുമ്പോ ശേഷമോ ക്ലാസ് തലത്തിൽ പ്രഖ്യാപിക്കാം.
• ഉദാഹരണ വേരിയബിളുകൾക്ക് ആക്സസ് മോഡിഫയറുകൾ നൽകാം.
• ജാവയിലെ ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ ഒരു ക്ലാസിലെ എല്ലാ രീതികൾക്കും കൺസ്ട്രക്‌റ്ററുകൾക്കും ബ്ലോക്കുകൾക്കും ദൃശ്യമാണ്. ചട്ടം പോലെ, അവയെ സ്വകാര്യമാക്കാൻ ശുപാർശ ചെയ്യുന്നു (ആക്സസ് ലെവൽ). എന്നിരുന്നാലും, ആക്സസ് മോഡിഫയറുകൾ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഈ വേരിയബിളുകളുടെ ഉപവിഭാഗങ്ങൾക്ക് അവ ദൃശ്യമാക്കാനാകും.
• ഇൻസ്റ്റൻസ് വേരിയബിളുകൾക്ക് ഡിഫോൾട്ട് മൂല്യങ്ങളുണ്ട്. സംഖ്യകൾക്ക് ഡിഫോൾട്ട് 0 ആണ്, ലോജിക്കൽ ആയവയ്ക്ക് തെറ്റ്, ഒബ്ജക്റ്റ് റഫറൻസുകൾക്ക് ശൂന്യം. മൂല്യങ്ങൾ പ്രഖ്യാപനത്തിലോ കൺസ്ട്രക്റ്ററിലോ നൽകാം.
• ജാവയിലെ ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ ക്ലാസിനുള്ളിലെ വേരിയബിൾ നെയിം വിളിച്ച് നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയും. എന്നിരുന്നാലും, സ്റ്റാറ്റിക് രീതികളിലും വിവിധ ക്ലാസുകളിലും (ഉദാഹരണ വേരിയബിളുകളിലേക്ക് പ്രവേശനം നൽകുമ്പോൾ) പൂർണ്ണ യോഗ്യതയുള്ള പേര് ഉപയോഗിച്ച് വിളിക്കണം - ObjectReference.VariableName.

ഉദാഹരണം

java.io.* ഇറക്കുമതി ചെയ്യുക; പബ്ലിക് ക്ലാസ് എംപ്ലോയി( // ഇൻസ്റ്റൻസ് വേരിയബിൾ ഏതൊരു ചൈൽഡ് ക്ലാസ്സിനും പൊതുവായതാണ്. പബ്ലിക് സ്ട്രിംഗ് നാമം; // ശമ്പള വേരിയബിൾ ജീവനക്കാരിൽ മാത്രമേ ദൃശ്യമാകൂ. സ്വകാര്യ ഇരട്ട ശമ്പളം; // വേരിയബിളിന്റെ പേര് കൺസ്ട്രക്റ്ററിൽ നൽകിയിരിക്കുന്നു. പബ്ലിക് എംപ്ലോയി (സ്ട്രിംഗ് empName)( name = empName; ) // ശമ്പള വേരിയബിളിന് പൊതു ശൂന്യമായ സെറ്റ് സാലറി (ഇരട്ട empSal)( ശമ്പളം = empSal; ) // ഈ രീതി ജീവനക്കാരുടെ ഡാറ്റ പൊതു ശൂന്യമായ printEmp())( System.out.println) പ്രിന്റ് ചെയ്യുന്നു ("പേര്: " + പേര്) ; System.out.println("ശമ്പളം:" + ശമ്പളം); ) പൊതു സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ(സ്ട്രിംഗ് ആർഗ്സ്)( Employee empOne = new Employee("Oleg"); empOne.setSalary(1000) ; empOne.printEmp(); )

പ്രോഗ്രാം ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് ഉണ്ടാക്കും:

പേര്: ഒലെഗ് ശമ്പളം: 1000.0

ജാവയിലെ ക്ലാസ് വേരിയബിളുകൾ അല്ലെങ്കിൽ സ്റ്റാറ്റിക് വേരിയബിളുകൾ

• ക്ലാസ് വേരിയബിളുകൾ, ജാവയിൽ സ്റ്റാറ്റിക് വേരിയബിളുകൾ എന്നും അറിയപ്പെടുന്നു, ക്ലാസിൽ ഒരു സ്റ്റാറ്റിക് കീവേഡ് ഉപയോഗിച്ച് പ്രഖ്യാപിക്കപ്പെട്ടവയാണ്, എന്നാൽ രീതി, കൺസ്ട്രക്റ്റർ അല്ലെങ്കിൽ ബ്ലോക്ക് എന്നിവയ്ക്ക് പുറത്ത്.
• എത്ര ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്‌ടിച്ചാലും ഒരു ക്ലാസിലെ ഓരോ സ്റ്റാറ്റിക് വേരിയബിളിന്റെയും ഒരു കോപ്പി മാത്രമേ ഉണ്ടാകൂ.
• സ്ഥിരാങ്കങ്ങളായി പ്രഖ്യാപിക്കപ്പെടുമ്പോൾ ഒഴികെ ജാവയിൽ സ്റ്റാറ്റിക് അല്ലെങ്കിൽ ക്ലാസ് വേരിയബിളുകൾ വളരെ അപൂർവമായി മാത്രമേ ഉപയോഗിക്കൂ. പൊതു/സ്വകാര്യം, അന്തിമം, സ്റ്റാറ്റിക് എന്നിങ്ങനെ പ്രഖ്യാപിക്കപ്പെടുന്ന വേരിയബിളുകളാണ് സ്ഥിരാങ്കങ്ങൾ. സ്ഥിരാങ്കങ്ങൾ അവയുടെ യഥാർത്ഥ മൂല്യത്തിൽ നിന്ന് ഒരിക്കലും മാറുന്നില്ല.
• ജാവയിൽ, ഒരു പ്രോഗ്രാം ആരംഭിക്കുമ്പോൾ സ്റ്റാറ്റിക് വേരിയബിളുകൾ സൃഷ്ടിക്കപ്പെടുകയും പ്രോഗ്രാം പ്രവർത്തിക്കുന്നത് നിർത്തുമ്പോൾ നശിപ്പിക്കപ്പെടുകയും ചെയ്യുന്നു.
• ദൃശ്യപരത ഒരു ഉദാഹരണ വേരിയബിൾ പോലെയാണ്. എന്നിരുന്നാലും, മിക്ക സ്റ്റാറ്റിക് വേരിയബിളുകളും പബ്ലിക് ആയി പ്രഖ്യാപിക്കപ്പെടുന്നു, കാരണം അവ ക്ലാസിലെ ഉപയോക്താക്കൾക്ക് ആക്സസ് ചെയ്യാവുന്നതാണ്.
• സ്ഥിരസ്ഥിതി മൂല്യങ്ങൾ ഉദാഹരണ വേരിയബിളുകൾക്ക് സമാനമാണ്. സംഖ്യകൾക്ക് സ്ഥിരസ്ഥിതി 0 ആണ്, ബൂളിയൻ തരത്തിലുള്ള ഡാറ്റയ്ക്ക് - തെറ്റ്; ഒബ്ജക്റ്റ് റഫറൻസുകൾക്ക് - null. മൂല്യങ്ങൾ പ്രഖ്യാപനത്തിലോ കൺസ്ട്രക്റ്ററിലോ നൽകാം. കൂടാതെ, അവ പ്രത്യേക സ്റ്റാറ്റിക് ഇനീഷ്യലൈസർ ബ്ലോക്കുകളിൽ നൽകാം.
• ക്ലാസ് നാമം ഉപയോഗിച്ച് വിളിക്കുന്നതിലൂടെ സ്റ്റാറ്റിക് വേരിയബിളുകൾ ആക്സസ് ചെയ്യാൻ കഴിയും ClassName.VariableName.
• ക്ലാസ് വേരിയബിളുകൾ പബ്ലിക്, സ്റ്റാറ്റിക്, ഫൈനൽ എന്നിങ്ങനെ പ്രഖ്യാപിക്കുമ്പോൾ, പേരുകൾ വലിയക്ഷരത്തിലാണ്. സ്റ്റാറ്റിക് വേരിയബിളുകൾ സ്റ്റാറ്റിക് അല്ലെങ്കിൽ, വാക്യഘടന ഉദാഹരണത്തിനും പ്രാദേശിക വേരിയബിളുകൾക്കും തുല്യമാണ്.

ഉദാഹരണം

java.io.* ഇറക്കുമതി ചെയ്യുക; പൊതു ക്ലാസ് ജീവനക്കാരൻ( // ശമ്പള വേരിയബിൾ പ്രൈവറ്റ് സ്റ്റാറ്റിക് പ്രൈവറ്റ് സ്റ്റാറ്റിക് ഡബിൾ സാലറി; // ഡിപ്പാർട്ട്മെന്റ് (ഡിപ്പാർട്ട്മെന്റ്) സ്ഥിരമായ ഒരു പൊതു സ്റ്റാറ്റിക് ഫൈനൽ ആണ്. .println(DEPARTMENT+"ശരാശരി ശമ്പളം: "+ശമ്പളം); ) )

ഇത് ഇനിപ്പറയുന്ന ഔട്ട്പുട്ട് ഉണ്ടാക്കും:

വികസന ശരാശരി ശമ്പളം: 1000

കുറിപ്പ്:ഒരു പുറം ക്ലാസിൽ നിന്ന് ആക്‌സസ് ചെയ്യാൻ, സ്ഥിരാങ്കങ്ങൾ Employee.DEPARTMENT ആയി ആക്‌സസ് ചെയ്യപ്പെടണം.

ആക്‌സസ് മോഡിഫയറുകൾ മുമ്പത്തെ മെറ്റീരിയലുകളിൽ ഒന്നിലധികം തവണ പരാമർശിച്ചിട്ടുണ്ട്. അടുത്ത പാഠത്തിൽ നാം അവയെ വിശദമായി പരിശോധിക്കും.

ഒരു പ്രിമിറ്റീവ് വേരിയബിൾ ഡിക്ലറേഷൻ സ്റ്റേറ്റ്‌മെന്റിന് ശേഷം ഒരു ഇനീഷ്യലൈസേഷൻ സ്റ്റേറ്റ്‌മെന്റ് "=" എന്നത് സൃഷ്‌ടിച്ച വേരിയബിളിന് ഒരു പ്രാരംഭ മൂല്യം നൽകുന്നു.

1. പൂർണ്ണസംഖ്യ വേരിയബിൾ തരങ്ങൾ

മുഴുവൻതരങ്ങൾ അവയ്ക്ക് അനുവദിച്ച മെമ്മറിയുടെ വലുപ്പത്തിൽ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു. പൂർണ്ണസംഖ്യ തരങ്ങളുടെ സവിശേഷതകൾ പട്ടികയിൽ നൽകിയിരിക്കുന്നു. 1.1 മേശ 1.1 ജാവ ഇന്റിജർ തരങ്ങളുടെ സവിശേഷതകൾ
ചുവടെയുള്ള പട്ടികയിൽ നിന്ന് നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ടൈപ്പ് ചാർ ഒഴികെയുള്ള പൂർണ്ണസംഖ്യ വേരിയബിളുകൾ ജാവയിൽ ഒപ്പിട്ട വേരിയബിളുകളായി കണക്കാക്കപ്പെടുന്നു. ഒരു പ്രോഗ്രാമിൽ പൂർണ്ണസംഖ്യകളുടെ സ്ഥിരാങ്കങ്ങൾ മൂന്ന് വഴികളിൽ ഒന്ന് വ്യക്തമാക്കാം: ദശാംശം, ഹെക്സാഡെസിമൽ അല്ലെങ്കിൽ ഒക്ടൽ മൂല്യങ്ങൾ. സ്ഥിരസ്ഥിതിയായി, എല്ലാ സംഖ്യകളും ഇങ്ങനെ വ്യാഖ്യാനിക്കപ്പെടുന്നു ദശാംശംകൂടാതെ int എന്ന തരത്തിലുള്ളവയാണ്. സംഖ്യയുടെ അവസാനത്തിൽ "l" എന്ന അക്ഷരമോ "L" എന്ന അക്ഷരമോ ചേർത്തുകൊണ്ട് നിങ്ങൾ ഒരു നീണ്ട തരം ആണെന്ന് വ്യക്തമായി സൂചിപ്പിക്കാൻ കഴിയും. ഹെക്സാഡെസിമൽ"0x" അല്ലെങ്കിൽ "0X" എന്ന അക്ഷരങ്ങൾ ഉപയോഗിച്ചാണ് മൂല്യം വ്യക്തമാക്കുന്നത്, തുടർന്ന് സംഖ്യയുടെ മൂല്യം (0-9 അക്കങ്ങളും A-F അല്ലെങ്കിൽ a-f അക്ഷരങ്ങളും), ഉദാഹരണത്തിന്: 0x7FFF . ഒക്ടൽ നൊട്ടേഷനിലെ ഒരു സംഖ്യ പൂജ്യത്തിൽ നിന്ന് ആരംഭിക്കണം, തുടർന്ന് ഒന്നോ അതിലധികമോ ഒക്ടൽ അക്കങ്ങൾ, ഉദാഹരണത്തിന് 077777. ഒക്ടൽ, ഹെക്‌സാഡെസിമൽ സംഖ്യകൾ പോസിറ്റീവും നെഗറ്റീവും ആയിരിക്കാം കൂടാതെ ദശാംശ പ്രാതിനിധ്യത്തിലെ സംഖ്യകളുടെ അതേ ശ്രേണികളിൽ വ്യത്യാസപ്പെടാം (ഉദാഹരണത്തിന്, ഹെക്‌സാഡെസിമൽ ബൈറ്റ് നമ്പറുകൾക്ക് പരമാവധി മൂല്യം 0x7F ഉം കുറഞ്ഞ മൂല്യം 0x80 ഉം, ഒക്ടൽ സംഖ്യകൾക്ക് 177 ഉം -200 ഉം ഉണ്ട്, യഥാക്രമം) പൂർണ്ണസംഖ്യ വേരിയബിളുകൾ പ്രഖ്യാപിക്കുന്നതിനുള്ള ഉദാഹരണങ്ങൾ: int x = 0 ; നീണ്ട i, j, k; ബൈറ്റ് a1 = 0xF1 , a2 = 0x07 ; ഹ്രസ്വ r1 = 017; ചിഹ്നങ്ങൾജാവയിൽ ചാർ കീവേഡ് ഉപയോഗിച്ച് നിർവ്വചിക്കുകയും യൂണികോഡ് സ്റ്റാൻഡേർഡ് ഉപയോഗിച്ച് നടപ്പിലാക്കുകയും ചെയ്യുന്നു. ഒരു പ്രോഗ്രാമിലോ സാധാരണ ചിഹ്നമായോ നിങ്ങൾക്ക് ഒരു ചിഹ്ന സ്ഥിരാങ്കം വ്യക്തമാക്കാൻ കഴിയും. പ്രതീകാത്മക മൂല്യം ഒരു ജോടി ഒറ്റ അപ്പോസ്ട്രോഫികളിൽ ഉൾപ്പെടുത്തിയിരിക്കണം, ഉദാഹരണത്തിന്: char symbol= "f" ; പ്രതീകങ്ങൾ എഴുതാനുള്ള മറ്റൊരു മാർഗ്ഗം "\u" എന്ന ജോടി പ്രതീകങ്ങളാണ്, തുടർന്ന് പ്രതീകത്തിന്റെ യൂണിക്കോഡ് കോഡിനെ പ്രതിനിധീകരിക്കുന്ന നാലക്ക ഹെക്‌സാഡെസിമൽ സംഖ്യ (0000 മുതൽ FFFF വരെ), ഉദാഹരണത്തിന്: char ചിഹ്നം = "\u0042" ; കീബോർഡിൽ കാണാത്ത ചില പ്രതീകങ്ങൾ എസ്‌കേപ്പ് സീക്വൻസുകൾ എന്ന് വിളിക്കപ്പെടുന്നവ ഉപയോഗിച്ച് വ്യക്തമാക്കാം, അതിൽ "\" എന്ന അക്ഷരവും തുടർന്ന് എസ്‌കേപ്പ് സീക്വൻസ് തിരിച്ചറിയുന്ന അക്ഷരമാലാക്രമവും അടങ്ങിയിരിക്കുന്നു, പട്ടിക 1-ൽ കാണിച്ചിരിക്കുന്നത്. 1.2 മേശ 1.2 ജാവ ഭാഷയിൽ ഉപയോഗിക്കുന്ന എസ്കേപ്പ് സീക്വൻസുകൾ

മറ്റെന്താണ് വായിക്കേണ്ടത്:

2. വേരിയബിളുകളുടെ യഥാർത്ഥ തരം

ജാവ ഭാഷ അക്കങ്ങളെയും വേരിയബിളുകളെയും പിന്തുണയ്ക്കുന്നു ഫ്ലോട്ടിംഗ് പോയിന്റ്പതിവ്, ഇരട്ട ബിറ്റ് - ഫ്ലോട്ടും ഇരട്ട തരങ്ങളും. ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾക്കായി, നിങ്ങൾ ഒരു ഡോട്ട് കൊണ്ട് വേർതിരിച്ച പൂർണ്ണസംഖ്യയും ഫ്രാക്ഷണൽ ഭാഗങ്ങളും വ്യക്തമാക്കേണ്ടതുണ്ട്, ഉദാഹരണത്തിന് 4.6 അല്ലെങ്കിൽ 7.0. വലിയ സംഖ്യകൾക്ക്, നിങ്ങൾക്ക് എക്‌സ്‌പോണൻഷ്യൽ നൊട്ടേഷൻ ("e" എന്ന ചിഹ്നം അല്ലെങ്കിൽ "E" ചിഹ്നം ഉപയോഗിച്ച് മാന്റിസയെ എക്‌സ്‌പോണന്റിൽ നിന്ന് വേർതിരിക്കാം), ഉദാഹരണത്തിന്, -3.58×107 എന്ന സംഖ്യ –3.58E7 എന്നും സംഖ്യ എന്നും എഴുതിയിരിക്കുന്നു. 73.675×10-15 എന്ന് എഴുതിയിരിക്കുന്നത് 73.675e-15 എന്നാണ്. ജാവ യഥാർത്ഥ തരങ്ങളുടെ സവിശേഷതകൾ പട്ടികയിൽ അവതരിപ്പിച്ചിരിക്കുന്നു. 2.1 മേശ 2.1 ജാവ റിയൽ തരങ്ങളുടെ സവിശേഷതകൾ
ഫ്ലോട്ടിംഗ്-പോയിന്റ് വേരിയബിളുകൾക്ക് സംഖ്യാ മൂല്യങ്ങൾ മാത്രമല്ല, പ്രത്യേകമായി നിർവചിക്കപ്പെട്ട ഏതെങ്കിലും ഫ്ലാഗുകളും (സംസ്ഥാനങ്ങൾ) സംഭരിക്കാൻ കഴിയും: നെഗറ്റീവ് ഇൻഫിനിറ്റി, നെഗറ്റീവ് സീറോ, പോസിറ്റീവ് ഇൻഫിനിറ്റി, പോസിറ്റീവ് സീറോ, അല്ലാത്തത്-എ-നമ്പർ (NaN). എല്ലാ ഫ്ലോട്ടിംഗ്-പോയിന്റ് സ്ഥിരാങ്കങ്ങളും ടൈപ്പ് ഡബിൾ ആണെന്ന് അനുമാനിക്കപ്പെടുന്നു. ഒരു ഫ്ലോട്ട് നമ്പർ വ്യക്തമാക്കുന്നതിന്, നിങ്ങൾ "f" എന്ന പ്രതീകമോ അല്ലെങ്കിൽ "F" എന്ന ചിഹ്നമോ നമ്പറിന്റെ അവസാനം കൂട്ടിച്ചേർക്കണം. ഫ്ലോട്ടിംഗ് പോയിന്റ് വേരിയബിൾ ഡിക്ലറേഷനുകളുടെ ഉദാഹരണങ്ങൾ:ഫ്ലോട്ട് x1 = 3.5f, x2 = 3.7E6f, x3 = - 1.8E-7f; ഇരട്ട z = 1.0;

3. ബൂളിയൻ വേരിയബിൾ തരം

ബൂളിയൻ വേരിയബിളുകൾക്ക് (ലോജിക്കൽ വേരിയബിളുകൾ) രണ്ട് മൂല്യങ്ങളിൽ ഒന്ന് എടുക്കാം: "ശരി" അല്ലെങ്കിൽ "തെറ്റ്" കൂടാതെ പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ റിലേഷണൽ (താരതമ്യം), ലോജിക്കൽ പ്രവർത്തനങ്ങളിൽ ഉപയോഗിക്കുന്നു. അങ്ങനെ, 5> 3 എന്ന താരതമ്യത്തിന്റെ ഫലം "ശരി" ആയിരിക്കും, കൂടാതെ താരതമ്യം 8 ന്റെ ഫലം< 1 будет «ложь». В отличие от C, где результату «ложь» сопоставлено целое значение типа int , равное 0, а результату «истина» – ненулевое значение типа int , и, соответственно, результатам сравнения присваивается целое значение (обычно 0 или 1), в Java для булевских переменных введен свой, отдельный тип данных. Переменные ബൂളിയൻ തരംജാവയിൽ ബൂളിയൻ കീവേഡ് ഉപയോഗിച്ചാണ് വ്യക്തമാക്കുന്നത്, രണ്ട് മൂല്യങ്ങളിൽ ഒന്ന് മാത്രമേ ഉണ്ടാകൂ: സത്യംഅഥവാ തെറ്റായ, ഉദാഹരണത്തിന് ബൂളിയൻ സ്വിച്ച് = true ; ആദ്യത്തേതിലേക്കുള്ള ലിങ്ക്

സംഖ്യകൾ സംഭരിക്കാൻ രൂപകൽപ്പന ചെയ്ത തരങ്ങളാണ് സംഖ്യാ തരങ്ങൾ. നിങ്ങൾ കണക്ക് ചെയ്യുമ്പോൾ, നിങ്ങൾ സംഖ്യാ മൂല്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നു. രണ്ട് തരത്തിലുള്ള സംഖ്യാ തരങ്ങളുണ്ട്. ഒരു ഫ്രാക്ഷണൽ ഭാഗം ഇല്ലാതെ സംഖ്യകൾ സംഭരിക്കുന്നതിന് രൂപകൽപ്പന ചെയ്തവയെ വിളിക്കുന്നു മുഴുവൻതരങ്ങൾ, ഒരു സംഖ്യയുടെ ഫ്രാക്ഷണൽ ഭാഗം സംഭരിക്കാൻ കഴിയുന്നവ - യഥാർത്ഥ,അല്ലെങ്കിൽ ഉള്ള തരങ്ങൾ ഫ്ലോട്ടിംഗ് പോയിന്റ്.

ജാവയിൽ ഒപ്പിടാത്ത നമ്പറുകൾ എന്ന ആശയമില്ല. ഈ ഭാഷയിലെ എല്ലാ സംഖ്യാ തരങ്ങളും ഒപ്പിട്ടിരിക്കുന്നു. ഉദാഹരണത്തിന്, ഒരു ബൈറ്റ് വേരിയബിളിന്റെ മൂല്യം ഹെക്സാഡെസിമലിൽ 0x80 ആണെങ്കിൽ, സംഖ്യ -1 ആണ്.

2.1.1.1. പൂർണ്ണസംഖ്യ തരങ്ങൾ

ജാവയുടെ ഒപ്പിടാത്ത സംഖ്യകളുടെ അഭാവം പൂർണ്ണസംഖ്യ തരങ്ങളുടെ എണ്ണം പകുതിയായി കുറയ്ക്കുന്നു. ഭാഷയ്ക്ക് 4 പൂർണ്ണസംഖ്യ തരങ്ങളുണ്ട്, മെമ്മറിയിൽ 1, 2, 4, 8 ബൈറ്റുകൾ ഉണ്ട്. ഓരോ തരത്തിനും - ബൈറ്റ്, ഷോർട്ട്, ഇന്റ്, ലോംഗ് - അതിന്റേതായ സ്വാഭാവിക ഉപയോഗങ്ങളുണ്ട്.

ടൈപ്പ് ചെയ്യുകബൈറ്റ്

സൈൻ ചെയ്ത 8-ബിറ്റ് തരമാണ് ബൈറ്റ് തരം. അതിന്റെ ശ്രേണി -128 മുതൽ 127 വരെയാണ്. നെറ്റ്‌വർക്കിൽ നിന്നോ ഫയലിൽ നിന്നോ ഡൗൺലോഡ് ചെയ്‌ത ഒരു അനിയന്ത്രിതമായ ബൈറ്റ് സ്ട്രീം സംഭരിക്കുന്നതിന് ഇത് ഏറ്റവും അനുയോജ്യമാണ്.

ബൈറ്റ് ബി;
ബൈറ്റ് c = 11;

ബിറ്റ് കൃത്രിമത്വം ഉൾപ്പെട്ടിട്ടില്ലെങ്കിൽ, ബൈറ്റ് തരം സാധാരണയായി ഒഴിവാക്കേണ്ടതാണ്. കൗണ്ടറുകളിലും ഗണിത പദപ്രയോഗങ്ങളിലും ഉപയോഗിക്കുന്ന സാധാരണ പൂർണ്ണസംഖ്യകൾക്ക്, int തരം കൂടുതൽ അനുയോജ്യമാണ്.

ടൈപ്പ് ചെയ്യുകചെറുത്

ഷോർട്ട് എന്നത് സൈൻ ചെയ്ത 16-ബിറ്റ് തരമാണ്. ഇതിന്റെ ശ്രേണി -32768 മുതൽ 32767 വരെയാണ്. ജാവയിൽ ഇത് ഏറ്റവും അപൂർവമായി മാത്രം ഉപയോഗിക്കുന്ന തരമാണ്, കാരണം ഇത് ഏറ്റവും പ്രധാനപ്പെട്ട ബൈറ്റ് ആദ്യം വരുന്ന തരമായി നിർവചിച്ചിരിക്കുന്നു.

ഹ്രസ്വ എസ്;
ഷോർട്ട് t= 129;
ടൈപ്പ് ചെയ്യുകint

int തരം 32-ബിറ്റ് ഒപ്പിട്ട പൂർണ്ണസംഖ്യകളെ പ്രതിനിധീകരിക്കുന്നു. ഈ തരത്തിനായുള്ള സാധുവായ മൂല്യങ്ങളുടെ പരിധി -2147483648 മുതൽ 2147483647 വരെയാണ്. രണ്ട് ബില്യൺ വരെ മൂല്യങ്ങളുള്ള സാധാരണ പൂർണ്ണസംഖ്യകൾ സംഭരിക്കുക എന്നതാണ് ഈ ഡാറ്റാ തരത്തിന്റെ ഏറ്റവും സാധാരണമായ ഉപയോഗം. ഈ തരം അറേകളും കൗണ്ടറുകളും ഉപയോഗിക്കുന്നതിന് മികച്ചതാണ്. വരും വർഷങ്ങളിൽ, ഈ തരം 32-ബിറ്റ് പ്രോസസറുകൾ മാത്രമല്ല, 32-ബിറ്റ് കോഡ് കോംപാറ്റിബിലിറ്റി മോഡിൽ എക്സിക്യൂട്ട് ചെയ്യുന്നതിനുള്ള വേഗതയേറിയ പൈപ്പ്ലൈനിംഗിനുള്ള പിന്തുണയുള്ള 64-ബിറ്റ് പ്രോസസറുകളുടെ മെഷീൻ വാക്കുകളുമായി തികച്ചും പൊരുത്തപ്പെടും. ടൈപ്പ് ബൈറ്റ്, ഷോർട്ട്, ഇൻറ്റ്, ഇന്റിഗർ ലിറ്ററലുകൾ എന്നിവയുടെ വേരിയബിളുകൾ ഒരേ എക്‌സ്‌പ്രഷനിൽ ദൃശ്യമാകുമ്പോഴെല്ലാം, മൂല്യനിർണ്ണയം പൂർത്തിയാകുന്നതിന് മുമ്പ് മുഴുവൻ എക്‌സ്‌പ്രെഷനും ഇൻറ്റിലേക്ക് കാസ്‌റ്റ് ചെയ്യുന്നു.

int j = 1000;
ടൈപ്പ് ചെയ്യുകനീളമുള്ള

സൈൻ ചെയ്ത 64-ബിറ്റ് നമ്പറുകളെ പ്രതിനിധീകരിക്കുന്നതിനാണ് നീളമുള്ള തരം രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. പ്രപഞ്ചത്തിലെ ആറ്റങ്ങളുടെ എണ്ണം കണക്കാക്കുന്നത് പോലുള്ള ജോലികൾക്ക് പോലും സ്വീകാര്യമായ മൂല്യങ്ങളുടെ പരിധി വളരെ വലുതാണ്.

നീളമുള്ളമീറ്റർ;
നീളമുള്ളn = 123;

തിരിച്ചറിയേണ്ട ആവശ്യമില്ല ബിറ്റ് ആഴംപൂർണ്ണസംഖ്യ തരം, അത് ഉൾക്കൊള്ളുന്ന മെമ്മറിയുടെ അളവ്. പ്രവർത്തിക്കുന്ന ജാവ കോഡിന്, നിങ്ങളുടെ വേരിയബിളുകൾക്ക് അനുയോജ്യമെന്ന് തോന്നുന്നിടത്തോളം മെമ്മറി ഉപയോഗിക്കാനാകും, അവയുടെ പെരുമാറ്റം നിങ്ങൾ നിർവചിക്കുന്ന തരങ്ങളുടെ സ്വഭാവവുമായി പൊരുത്തപ്പെടുന്നിടത്തോളം.

പട്ടിക 2.1. വിവിധ തരം പൂർണ്ണസംഖ്യകൾക്കുള്ള ബിറ്റ് ഡെപ്‌ഥുകളുടെയും സ്വീകാര്യമായ ശ്രേണികളുടെയും പട്ടിക

		ബിറ്റ് ഡെപ്ത്	പരിധി
			-9, 223, 372,036, 854, 775, 808 ... 9, 223, 372, 036, 854, 775, 807
			-2, 147, 483, 648 .... 2, 147, 483, 647
			-32,768 .... 32, 767
			-128 ... 127

2.1.1.2. ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾ

ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾ, പലപ്പോഴും മറ്റ് ഭാഷകളിൽ യഥാർത്ഥ സംഖ്യകൾ എന്ന് വിളിക്കപ്പെടുന്നു, ഒരു ഭിന്നസംഖ്യയുടെ ഉപയോഗം ആവശ്യമായ കണക്കുകൂട്ടലുകളിൽ ഉപയോഗിക്കുന്നു. ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾക്കായി ഒരു സ്റ്റാൻഡേർഡ് (IEEE-754) തരം സെറ്റ് ജാവ നടപ്പിലാക്കുന്നു - ഫ്ലോട്ട്, ഡബിൾ - കൂടാതെ അവയ്‌ക്കൊപ്പം പ്രവർത്തിക്കാൻ ഓപ്പറേറ്റർമാർ.

പട്ടിക 2.2. ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പർ തരങ്ങളുടെ സവിശേഷതകൾ

		ബിറ്റ് ഡെപ്ത്	പരിധി
			1.7e-308....1.7e+ 308
			3.4e-038....3.4e+ 038

ടൈപ്പ് ചെയ്യുകഫ്ലോട്ട്

സാധാരണ ഉള്ള വേരിയബിളുകളിൽ, അല്ലെങ്കിൽ ഒറ്റ കൃത്യത,ഫ്ലോട്ട് കീവേഡ് ഉപയോഗിച്ച് പ്രഖ്യാപിച്ചു, യഥാർത്ഥ മൂല്യം സംഭരിക്കുന്നതിന് 32 ബിറ്റുകൾ ഉപയോഗിക്കുന്നു,

ഫ്ലോട്ട് എഫ്;
ഫ്ലോട്ട് f2 = 3.14;
ടൈപ്പ് ചെയ്യുകഇരട്ടി

എപ്പോൾ ഇരട്ട കൃത്യത,ഇരട്ട കീവേഡ് ഉപയോഗിച്ച് വ്യക്തമാക്കിയ, മൂല്യങ്ങൾ സംഭരിക്കുന്നതിന് 64 ബിറ്റുകൾ ഉപയോഗിക്കുന്നു. എല്ലാം അതീന്ദ്രിയമായ sin, cos, sqrt തുടങ്ങിയ ഗണിത പ്രവർത്തനങ്ങൾ ഇരട്ട ഫലം നൽകുന്നു,

ഇരട്ടിഡി;
ഇരട്ട പൈ = 3.14159265358979323846;

എന്താണ് ഒരു വേരിയബിൾ?

ഒരു ജാവ പ്രോഗ്രാമിന്റെ ജീവിതത്തിൽ, നിങ്ങൾക്ക് മൂല്യമുള്ള ഒരു കണ്ടെയ്‌നറായി ഒരു വേരിയബിളിനെ കണക്കാക്കാം. എല്ലാ വേരിയബിളും a നിയുക്തമാക്കിയിരിക്കുന്നു ഡാറ്റ തരംഅത് കൈവശം വയ്ക്കാൻ കഴിയുന്ന മൂല്യത്തിന്റെ തരവും അളവും രൂപകൽപ്പന ചെയ്യുന്നു.

ഒരു പ്രോഗ്രാമിൽ ഒരു വേരിയബിൾ ഉപയോഗിക്കുന്നതിന് നിങ്ങൾ 2 ഘട്ടങ്ങൾ ചെയ്യേണ്ടതുണ്ട്

1. വേരിയബിൾ ഡിക്ലറേഷൻ
2. വേരിയബിൾ ഇനിഷ്യലൈസേഷൻ

ഈ ട്യൂട്ടോറിയലിൽ, നിങ്ങൾ പഠിക്കും-

വേരിയബിൾ ഡിക്ലറേഷൻ:

ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാൻ, നിങ്ങൾ ഡാറ്റ തരം വ്യക്തമാക്കുകയും വേരിയബിളിന് ഒരു അദ്വിതീയ നാമം നൽകുകയും വേണം.

മറ്റ് സാധുവായ പ്രഖ്യാപനങ്ങളുടെ ഉദാഹരണങ്ങളാണ്

Int a,b,c; ഫ്ലോട്ട് പൈ; ഇരട്ട ഡി; ചാർ എ;

വേരിയബിൾ ഇനിഷ്യലൈസേഷൻ:

ഒരു വേരിയബിൾ ആരംഭിക്കുന്നതിന്, നിങ്ങൾ അതിന് ഒരു സാധുവായ മൂല്യം നൽകണം.

മറ്റ് സാധുവായ ഇനീഷ്യലൈസേഷനുകളുടെ ഉദാഹരണം

പൈ =3.14f; ചെയ്യുക =20.22d; a='v';

നിങ്ങൾക്ക് വേരിയബിൾ ഡിക്ലറേഷനും ഇനീഷ്യലൈസേഷനും സംയോജിപ്പിക്കാൻ കഴിയും.

Int a=2,b=4,c=6; ഫ്ലോട്ട് പൈ=3.14f; ഡബിൾ ഡോ=20.22ഡി; char a=’v’;

വേരിയബിളുകളുടെ തരങ്ങൾ

ജാവയിൽ, മൂന്ന് തരം വേരിയബിളുകൾ ഉണ്ട്:

1. പ്രാദേശിക വേരിയബിളുകൾ
2. ഉദാഹരണ വേരിയബിളുകൾ
3. സ്റ്റാറ്റിക് വേരിയബിളുകൾ

1) ലോക്കൽ വേരിയബിളുകൾ

ഒരു രീതിയുടെ ബോഡിക്കുള്ളിൽ പ്രഖ്യാപിക്കപ്പെടുന്ന ഒരു വേരിയബിളാണ് ലോക്കൽ വേരിയബിളുകൾ.

2) ഉദാഹരണ വേരിയബിളുകൾ

STATIC കീവേഡ് ഇല്ലാതെയാണ് ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ നിർവചിച്ചിരിക്കുന്നത്. അവ ഒരു രീതി പ്രഖ്യാപനത്തിന് പുറത്ത് നിർവചിച്ചിരിക്കുന്നു. അവ ഒബ്ജക്റ്റ് സ്പെസിഫിക് ആണ്, അവ ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ എന്നറിയപ്പെടുന്നു.

3) സ്റ്റാറ്റിക് വേരിയബിളുകൾ

പ്രോഗ്രാം എക്സിക്യൂഷന്റെ തുടക്കത്തിൽ സ്റ്റാറ്റിക് വേരിയബിളുകൾ ഒരു തവണ മാത്രമേ ആരംഭിക്കുകയുള്ളൂ. ഏതെങ്കിലും ഇൻസ്റ്റൻസ് വേരിയബിളുകൾ ആരംഭിക്കുന്നതിന് മുമ്പ് ഈ വേരിയബിളുകൾ ആദ്യം ആരംഭിക്കണം.

ഉദാഹരണം: ജാവയിലെ വേരിയബിളുകളുടെ തരങ്ങൾ

class Guru99 ( int data = 99; //instance variable static int a = 1; //static variable void method() ( int b = 90; //local variable ) )

ജാവയിലെ ഡാറ്റ തരങ്ങൾ

ഡാറ്റ തരങ്ങൾ വേരിയബിളിൽ സംഭരിക്കേണ്ട വ്യത്യസ്ത മൂല്യങ്ങളെ തരംതിരിക്കുന്നു. ജാവയിൽ, രണ്ട് തരം ഡാറ്റാ തരങ്ങളുണ്ട്:

1. പ്രാഥമിക ഡാറ്റ തരങ്ങൾ
2. നോൺ-പ്രിമിറ്റീവ് ഡാറ്റ തരങ്ങൾ

പ്രാഥമിക ഡാറ്റ തരങ്ങൾ

പ്രിമിറ്റീവ് ഡാറ്റ തരങ്ങൾ ജാവ ഭാഷയിൽ മുൻകൂട്ടി നിശ്ചയിച്ചിട്ടുള്ളതും ലഭ്യമാണ്. പ്രാകൃത മൂല്യങ്ങൾ മറ്റ് പ്രാകൃത മൂല്യങ്ങളുമായി അവസ്ഥ പങ്കിടുന്നില്ല.

8 പ്രാകൃത തരങ്ങളുണ്ട്: ബൈറ്റ്, ഷോർട്ട്, ഇന്റ്, ലോംഗ്, ചാർ, ഫ്ലോട്ട്, ഡബിൾ, ബൂളിയൻ പൂർണ്ണസംഖ്യ ഡാറ്റ തരങ്ങൾ

ബൈറ്റ് (1 ബൈറ്റ്) ചെറുത് (2 ബൈറ്റുകൾ) int (4 ബൈറ്റുകൾ) നീളം (8 ബൈറ്റുകൾ)

ഫ്ലോട്ടിംഗ് ഡാറ്റ തരം

ഫ്ലോട്ട് (4 ബൈറ്റുകൾ) ഇരട്ടി (8 ബൈറ്റുകൾ)

ടെക്‌സ്‌ച്വൽ ഡാറ്റ തരം

ചാർ (2 ബൈറ്റുകൾ)

ബൂളിയൻ (1 ബൈറ്റ്) (ശരി/തെറ്റ്)

ഡാറ്റ തരം	സ്ഥിര മൂല്യം	സ്ഥിര വലുപ്പം
ബൈറ്റ്	0	1 ബൈറ്റ്
ചെറുത്	0	2 ബൈറ്റുകൾ
int	0	4 ബൈറ്റുകൾ
നീളമുള്ള	0L	8 ബൈറ്റുകൾ
ഫ്ലോട്ട്	0.0f	4 ബൈറ്റുകൾ
ഇരട്ടി	0.0ഡി	8 ബൈറ്റുകൾ
ബൂളിയൻ	തെറ്റായ	1 ബിറ്റ്
ചാർ	"\u0000"	2 ബൈറ്റുകൾ

ഓർമ്മിക്കേണ്ട പോയിന്റുകൾ:

• എല്ലാ സംഖ്യാ ഡാറ്റ തരങ്ങളും ഒപ്പിട്ടിരിക്കുന്നു(+/-).
• എല്ലാ പ്ലാറ്റ്‌ഫോമുകളിലും ഡാറ്റാ തരങ്ങളുടെ വലുപ്പം ഒരേപോലെ നിലനിൽക്കും (നിലവാരമുള്ളത്)
• ജാവയിലെ ചാർ ഡാറ്റ തരം 2 ബൈറ്റുകൾ ആണ്, കാരണം അത് ഉപയോഗിക്കുന്നു യൂണികോഡ്പ്രതീക സെറ്റ്. അതിന്റെ ബലത്തിൽ, ജാവ അന്താരാഷ്ട്രവൽക്കരണത്തെ പിന്തുണയ്ക്കുന്നു. ലോകത്തിലെ അറിയപ്പെടുന്ന എല്ലാ ലിപികളും ഭാഷയും ഉൾക്കൊള്ളുന്ന ഒരു പ്രതീക സെറ്റാണ് UNICODE

ജാവ വേരിയബിൾ ടൈപ്പ് കൺവേർഷനും ടൈപ്പ് കാസ്റ്റിംഗും

ഒരു തരത്തിന്റെ വേരിയബിളിന് മറ്റൊരു തരത്തിന്റെ മൂല്യം ലഭിക്കും. ഇവിടെ 2 കേസുകൾ ഉണ്ട് -

കേസ് 1)ചെറിയ കപ്പാസിറ്റിയുടെ വേരിയബിൾ വലിയ കപ്പാസിറ്റിയുടെ മറ്റൊരു വേരിയബിളിലേക്ക് നൽകിയിട്ടുണ്ട്.

ഈ പ്രക്രിയ സ്വയമേവയാണ്, വ്യക്തമല്ലാത്തത് എന്ന് അറിയപ്പെടുന്നു പരിവർത്തനം

കേസ് 2)വലിയ കപ്പാസിറ്റിയുടെ വേരിയബിൾ ചെറിയ ശേഷിയുടെ മറ്റൊരു വേരിയബിളിലേക്ക് നൽകിയിരിക്കുന്നു

അത്തരം സന്ദർഭങ്ങളിൽ, നിങ്ങൾ വ്യക്തമായി വ്യക്തമാക്കേണ്ടതുണ്ട് തരം കാസ്റ്റ് ഓപ്പറേറ്റർ. ഈ പ്രക്രിയ അറിയപ്പെടുന്നത് കാസ്റ്റിംഗ് എന്ന് ടൈപ്പ് ചെയ്യുക.

സാഹചര്യത്തിൽ, നിങ്ങൾ ഒരു തരം കാസ്റ്റ് ഓപ്പറേറ്റർ വ്യക്തമാക്കുന്നില്ല; കമ്പൈലർ ഒരു പിശക് നൽകുന്നു. ഈ നിയമം കംപൈലർ നടപ്പിലാക്കുന്നതിനാൽ, താൻ ചെയ്യാൻ പോകുന്ന പരിവർത്തനം ഡാറ്റയിൽ കുറച്ച് നഷ്ടമുണ്ടാക്കിയേക്കാമെന്ന് പ്രോഗ്രാമറെ ഇത് ബോധവാന്മാരാക്കുന്നു. ആകസ്മികമായ നഷ്ടങ്ങൾ.

ഉദാഹരണം: ടൈപ്പ് കാസ്റ്റിംഗ് മനസ്സിലാക്കാൻ

ഘട്ടം 1)ഇനിപ്പറയുന്ന കോഡ് എഡിറ്ററിലേക്ക് പകർത്തുക.

ക്ലാസ് ഡെമോ (പബ്ലിക് സ്റ്റാറ്റിക് ശൂന്യമായ മെയിൻ (സ്ട്രിംഗ് ആർഗ്സ്) (ബൈറ്റ് x; int a = 270; ഇരട്ട ബി = 128.128; System.out.println ("int ബൈറ്റിലേക്ക് പരിവർത്തനം ചെയ്തു"); x = (ബൈറ്റ്) a; System.out. println("a and x " + a + " " + x); System.out.println("ഇരട്ടയായി int ആയി പരിവർത്തനം ചെയ്തു"); a = (int) b; System.out.println("b and a " + b " )

ഘട്ടം 2)കോഡ് സംരക്ഷിക്കുക, കംപൈൽ ചെയ്യുക & റൺ ചെയ്യുക.

Int ബൈറ്റ് എ ആയും x 270 14 ഇരട്ടി int b ആയും 128.128 128 ഇരട്ടി ബൈറ്റ് b ആയും x 128.128 -128 ആയും പരിവർത്തനം ചെയ്തു