ജാവയിലെ ജാവ ക്ലാസ്, പ്രധാന രീതി, ലൂപ്പ് നിയന്ത്രണം എന്നിവ മനസ്സിലാക്കുക - ഭാഗം 3
ഞങ്ങളുടെ അവസാന പോസ്റ്റായ 'ജാവയുടെ പ്രവർത്തനവും കോഡ് ഘടനയും' ജാവ, ജാവ സോഴ്uസ് ഫയൽ, ജാവ ക്ലാസ് ഫയൽ, ക്ലാസ് (പബ്ലിക്/പ്രൈവറ്റ്), രീതി, സ്റ്റേറ്റ്uമെന്റ്, നിങ്ങളുടെ ആദ്യ ജാവ പ്രോഗ്രാം, ജാവയുടെ കംപൈലേഷൻ, റണ്ണിംഗ് എന്നിവയുടെ പ്രവർത്തനത്തിന്റെ വിശദാംശങ്ങൾ ഞങ്ങൾ ഊന്നിപ്പറഞ്ഞിട്ടുണ്ട്. പ്രോഗ്രാം.
ഇവിടെ ഈ ജാവ ലേണിംഗ് സീരീസ് ഗൈഡിൽ, ജാവ ക്ലാസ്, മെയിൻ മെത്തേഡ്, ലൂപ്പ് കൺട്രോൾ എന്നിവ എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഞങ്ങൾ മനസ്സിലാക്കും കൂടാതെ പ്രധാന രീതിയും ലൂപ്പ് നിയന്ത്രണവും ഉള്ള ജാവ ക്ലാസ് ഉപയോഗിക്കുന്ന അടിസ്ഥാന കോഡുകളും ഞങ്ങൾ കാണും.
ജാവയിലെ എല്ലാം ഒരു ഒബ്uജക്റ്റും ക്ലാസ് ഒബ്uജക്റ്റിന്റെ ബ്ലൂപ്രിന്റുമാണ്. ജാവയിലെ ഓരോ കോഡും ക്ലാസിന്റെ ചുരുണ്ട ബ്രേസുകൾക്ക് കീഴിലാണ് സ്ഥാപിച്ചിരിക്കുന്നത്. നിങ്ങൾ ഒരു ജാവ പ്രോഗ്രാം കംപൈൽ ചെയ്യുമ്പോൾ അത് ഒരു ക്ലാസ് ഫയൽ നിർമ്മിക്കുന്നു. നിങ്ങൾ ജാവ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുമ്പോൾ, നിങ്ങൾ യഥാർത്ഥത്തിൽ പ്രോഗ്രാം ഫയൽ പ്രവർത്തിപ്പിക്കുന്നില്ല, മറിച്ച് ക്ലാസിലാണ്.
നിങ്ങൾ Java Virtual Machine-ൽ (JVM) ഒരു പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുമ്പോൾ, അത് ആവശ്യമായ ക്ലാസ് ലോഡ് ചെയ്യുകയും തുടർന്ന് പ്രധാന ()
രീതിയിലേക്ക് നേരിട്ട് പോകുകയും ചെയ്യുന്നു. മെയിൻ() രീതിയുടെ ക്ലോസിംഗ് ബ്രേസുകൾ വരെ പ്രോഗ്രാം പ്രവർത്തിക്കുന്നത് തുടരുന്നു. മെയിൻ() രീതിക്ക് ശേഷം പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്യാൻ തുടങ്ങുന്നു. ഒരു ക്ലാസിന് ഒരു പ്രധാന() രീതി ഉണ്ടായിരിക്കണം. എല്ലാ ക്ലാസിനും (സ്വകാര്യ ക്ലാസ്) ഒരു പ്രധാന() രീതി ആവശ്യമില്ല.
മാജിക് ആരംഭിക്കുന്ന സ്ഥലമാണ് ഒരു പ്രധാന() രീതി. സ്റ്റേറ്റ്uമെന്റ്/നിർദ്ദേശങ്ങൾ, ലൂപ്പുകൾ എന്നിവ വഴി മെയിൻ() രീതിക്കുള്ളിൽ എന്തും ചെയ്യാൻ നിങ്ങൾക്ക് JVM-നോട് ആവശ്യപ്പെടാം.
ലൂപ്പ് എന്നത് ഒരു നിർദ്ദേശം അല്ലെങ്കിൽ വ്യവസ്ഥയിലെത്തുന്നത് വരെ ആവർത്തിച്ച് കൊണ്ടിരിക്കുന്ന ക്രമത്തിലുള്ള നിരവധി നിർദ്ദേശങ്ങളാണ്. ഒരു പ്രോഗ്രാമിംഗ് ഭാഷയുടെ ലോജിക്കൽ ഘടനയാണ് ലൂപ്പുകൾ. ലൂപ്പ് ലോജിക്കൽ ഘടന സാധാരണയായി ഒരു പ്രോസസ്സ് ചെയ്യാനും, അവസ്ഥ പരിശോധിക്കാനും, ഒരു പ്രോസസ്സ് ചെയ്യാനും, അവസ്ഥ പരിശോധിക്കാനും,..... വ്യവസ്ഥ ആവശ്യകതകൾ നിറവേറ്റുന്നത് വരെ ഉപയോഗിക്കുന്നു.
ജാവയിലെ ലൂപ്പുകൾ
ജാവയിൽ മൂന്ന് വ്യത്യസ്ത ലൂപ്പ് മെക്കാനിസങ്ങളുണ്ട്.
ബൂളിയൻ എക്സ്പ്രഷനിൽ നിർവചിച്ചിരിക്കുന്നതുപോലെ, എക്uസ്uപ്രഷൻ ടെസ്റ്റ് ഫലം ശരിയാകുന്നതുവരെ, ഒരു നിശ്ചിത എണ്ണം തവണ ആവർത്തിച്ച് ഒരു ടാസ്uക് ചെയ്യാൻ ഉപയോഗിക്കുന്ന ഒരു നിയന്ത്രണ ഘടനയാണ് ജാവയിലെ ലൂപ്പ്. ബൂളിയൻ എക്uസ്uപ്രഷൻ ടെക്uസ്uറ്റ് റിസൾട്ട് തെറ്റാണെങ്കിൽ, ഒരു പ്രാവശ്യം പോലും എക്uസിക്യൂട്ട് ചെയ്യാതെ ലൂപ്പ് പൂർണ്ണമായും അവഗണിക്കപ്പെടും.
while ലൂപ്പിന്റെ വാക്യഘടന:
while (boolean expression) { statement/instructions }
ജാവയിലെ ലൂപ്പിന്റെ ഒരു ഉദാഹരണം:
public class While_loop { public static void main(String[] args) { int A = 100; while(A>0) { System.out.println("The Value of A = " +A); A=A-10; } } }
$ java While_loop The Value of A = 100 The Value of A = 90 The Value of A = 80 The Value of A = 70 The Value of A = 60 The Value of A = 50 The Value of A = 40 The Value of A = 30 The Value of A = 20 The Value of A = 10
അതേസമയം_ലൂപ്പ് പ്രോഗ്രാമിന്റെ അനാട്ടമി
// Public Class While_loop public class While_loop { // main () Method public static void main(String[] args) { // declare an integer variable named 'A' and give it the value of 100 int A = 100; // Keep looping as long as the value of A is greater than 0. 'A>0' here is the boolean expression while(A>0) { // Statement System.out.println("The Value of A = " +A); // Post Decrement (by 10) A=A-10; } } }
do...while loop എന്നത് while ലൂപ്പുമായി വളരെ സാമ്യമുള്ളതാണ്, അതിൽ ഒരു do അടങ്ങിയിരിക്കുന്നു എന്നതൊഴിച്ചാൽ... ലൂപ്പ് ഒരിക്കലെങ്കിലും എക്സിക്യൂട്ട് ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുന്നതിന് മുമ്പ്.
while ലൂപ്പിന്റെ വാക്യഘടന:
do { statement/instructions } while (boolean expression);
ബൂളിയൻ എക്uസ്uപ്രഷൻ ശരിയോ തെറ്റോ ആണെങ്കിൽ അത് പരിശോധിക്കുന്നതിന് മുമ്പ് ലൂപ്പിന്റെ do..
ഭാഗം എക്uസിക്യൂട്ട് ചെയ്uതതായി വ്യക്തമായി കാണിക്കുന്ന മുകളിലെ വാക്യഘടന നിങ്ങൾ കണ്ടേക്കാം. അതിനാൽ ബൂളിയൻ പദപ്രയോഗത്തിന്റെ ഫലം (ശരി/തെറ്റ്) എന്തായാലും, ലൂപ്പ് എക്സിക്യൂട്ട് ചെയ്യുന്നു. ശരിയാണെങ്കിൽ, വ്യവസ്ഥ തൃപ്തികരമാകുന്നതുവരെ അത് നടപ്പിലാക്കും. തെറ്റാണെങ്കിൽ ഒരിക്കൽ എക്സിക്യൂട്ട് ചെയ്യും.
ജാവയിൽ do…while ലൂപ്പിന്റെ ഒരു ഉദാഹരണം:
public class do_while { public static void main(String[] args) { int A=100; do { System.out.println("Value of A = " +A); A=A-10; } while (A>=50); } }
$ java do_while Value of A = 100 Value of A = 90 Value of A = 80 Value of A = 70 Value of A = 60 Value of A = 50
do_while പ്രോഗ്രാമിന്റെ അനാട്ടമി:
// public class do_while public class do_while { // main () Method public static void main(String[] args) { // Declare a Integer Variable 'A' and assign it a value = 100 int A=100; // do...while loop starts do { // execute the below statement without checking boolean expression condition if true or false System.out.println("Value of A = " +A); // Post Decrement (by 10) A=A-10; } // Check condition. Loop the execute only till the value of Variable A is greater than or equal to 50. while (A>=50); } }
ആവർത്തന നിയന്ത്രണത്തിനായി ജാവയിലെ for_loop വ്യാപകമായി ഉപയോഗിക്കുന്നു. ഒരു ടാസ്uക്ക് നിർദ്ദിഷ്ട തവണ ആവർത്തിക്കാൻ ഇത് ഉപയോഗിക്കുന്നു. ഒരു ടാസ്uക് നിർവഹിക്കുന്നതിന് ലൂപ്പ് എത്ര തവണ എക്uസിക്യൂട്ട് ചെയ്യണമെന്ന് നിയന്ത്രിക്കാൻ ഫോർ ലൂപ്പ് ഉപയോഗിക്കുന്നു. ലൂപ്പ് എത്ര തവണ എക്സിക്യൂട്ട് ചെയ്യണമെന്ന് നിങ്ങൾക്കറിയാമെങ്കിൽ മാത്രമേ ലൂപ്പ് ഉപയോഗപ്രദമാകൂ.
ലൂപ്പിന്റെ വാക്യഘടന:
for (initialization; boolean-expression; update) { statement } An example of the for loop in Java public class for_loop { public static void main(String[] arge) { int A; for (A=100; A>=0; A=A-7) { System.out.println("Value of A = " +A); } } }
$ java for_loop Value of A = 100 Value of A = 93 Value of A = 86 Value of A = 79 Value of A = 72 Value of A = 65 Value of A = 58 Value of A = 51 Value of A = 44 Value of A = 37 Value of A = 30 Value of A = 23 Value of A = 16 Value of A = 9 Value of A = 2
ഫോർ_ലൂപ്പ് പ്രോഗ്രാമിന്റെ അനാട്ടമി:
// public class for_loop public class for_loop { // main () Method public static void main(String[] arge) { // Declare a Integer Variable A int A; // for loop starts. Here Initialization is A=100, boolean_expression is A>=0 and update is A=A-7 for (A=100; A>=0; A=A-7) { // Statement System.out.println("Value of A = " +A); } } }
ജാവയിലെ ലൂപ്പുകൾക്കുള്ള ബ്രേക്ക്, കൺടിന്യൂ കീവേഡുകൾ
പേര് സൂചിപ്പിക്കുന്നത് പോലെ മുഴുവൻ ലൂപ്പും ഉടനടി നിർത്താൻ ബ്രേക്ക് കീവേഡ് ഉപയോഗിക്കുന്നു. ബ്രേക്ക് കീവേഡ് എല്ലായ്പ്പോഴും ലൂപ്പിലോ സ്വിച്ച് സ്റ്റേറ്റ്മെന്റിലോ ഉപയോഗിക്കണം. ബ്രേക്ക് ഉപയോഗിച്ച് ലൂപ്പ് പൊട്ടിയാൽ ഒരിക്കൽ; JVM ലൂപ്പിന് പുറത്ത് കോഡിന്റെ അടുത്ത വരി നടപ്പിലാക്കാൻ തുടങ്ങുന്നു. ജാവയിലെ ബ്രേക്ക് ലൂപ്പിന്റെ ഒരു ഉദാഹരണം ഇതാണ്:
public class break { public static void main(String[] args) { int A = 100; while(A>0) { System.out.println("The Value of A = " +A); A=A-10; if (A == 40) { break; } } } }
$ java break The Value of A = 100 The Value of A = 90 The Value of A = 80 The Value of A = 70 The Value of A = 60 The Value of A = 50
ജാവയിലെ ഏത് ലൂപ്പിലും തുടരുക കീവേഡ് ഉപയോഗിക്കാം. തുടരുക കീവേഡ് ഉടൻ തന്നെ അടുത്ത ആവർത്തനത്തിലേക്ക് പോകാൻ ലൂപ്പിനോട് ആവശ്യപ്പെടുക. എന്നിരുന്നാലും, ലൂപ്പ്, വേൾ/ഡൂ... വൈൽ ലൂപ്പ് എന്നിവയാൽ ഇത് വ്യത്യസ്തമായി വ്യാഖ്യാനിക്കപ്പെടുന്നു.
അടുത്ത അപ്uഡേറ്റ് പ്രസ്താവനയിലേക്ക് ലൂപ്പ് ജമ്പുകൾക്കായി കീവേഡ് തുടരുക.
ലൂപ്പിനായി തുടരുന്നതിന്റെ ഒരു ഉദാഹരണം:
public class continue_for_loop { public static void main(String[] arge) { int A; for (A=10; A>=0; A=A-1) { if (A == 2) { continue; } System.out.println("Value of A = " +A); } } }
$ java continue_for_loop Value of A = 10 Value of A = 9 Value of A = 8 Value of A = 7 Value of A = 6 Value of A = 5 Value of A = 4 Value of A = 3 Value of A = 1 Value of A = 0
നിങ്ങൾ ശ്രദ്ധിച്ചോ, ഇത് A = 2 ന്റെ മൂല്യം ഒഴിവാക്കി. അടുത്ത അപ്uഡേറ്റ് സ്റ്റേറ്റ്uമെന്റിലേക്ക് ഡംപ് ചെയ്തുകൊണ്ടാണ് ഇത് ചെയ്യുന്നത്.
ശരി, നിങ്ങൾക്കത് സ്വയം ചെയ്യാൻ കഴിയും. ഇത് വളരെ എളുപ്പമാണ്. മുകളിലുള്ള ഘട്ടങ്ങൾ പിന്തുടരുക.
ഇപ്പോൾ എന്റെ ഭാഗത്തുനിന്നും അത്രമാത്രം. ജാവ സീരീസിൽ ഞാൻ നന്നായി പ്രവർത്തിക്കുന്നുവെന്നും നിങ്ങളെ സഹായിക്കുമെന്നും പ്രതീക്ഷിക്കുന്നു. ഇത്തരം കൂടുതൽ പോസ്റ്റുകൾക്കായി ബന്ധം നിലനിർത്തുക. ചുവടെയുള്ള അഭിപ്രായങ്ങളിൽ നിങ്ങളുടെ വിലയേറിയ ഫീഡ്uബാക്ക് ഞങ്ങൾക്ക് നൽകാൻ മറക്കരുത്.