Java for beginners – CodemasterLK

භාෂා හැඳින්වීම

භාෂාවක් යනු කුමක් ද?

360_F_560914980_RFWsXdFwya6AsStVvOfspETt2CVEFIOx

මිනිසා ඇතුළුව සෑම සත්වයකුටම එකිනෙකා හා සන්නිවේදන කිරීමට භාෂාව වැදගත් වේ. සජීවී ලෝකය සැලකූ විට භාෂාවක් යනු සත්වයකුගේ සිතෙහි හට ගන්නා හැඟීමක් තවත් සත්වයෙකුට තේරුම් ගත හැකි ආකාරයට ප්‍රචාරනය කිරීමට යොදාගන්නා මාධ්‍යයකි.

උදාහරණ:

මිනිසා, මිනිසා අතර සන්නිවේදනය කිරීමට භාෂා තිබේ. (සිංහල,ඉංග්‍රිසි ,ජර්මන්, හින්දි)
සතුන් සතුන් අතර සන්නිවේදන යටද භාෂා තිබේ. ( කපුටන්, බල්ලන්, පූසන්, තල්මසුන් සියලුම සතුන් ගත් විට ඔවුන් ට ආවේණික භාෂාවක් ඇත)
එසේම මිනිසුන් සහ හීලෑ සතුන් අතර සන්නිවේදනයට ද භාෂා ඇත.(පූසෙකුට කතා කිරීමට සේ..සේ..සේ.. යන්න භාවිතා කරන අතර බල්ලන්ට කතා කිරීමට ඉඦු ඉඦු යන්න භාවිතා කරයි)

භාෂාව සඳහා භාවිතා වන්නේ කථනය පමණක් ම නොවේ. කථනයට අමතරව අක්ෂර, සංකේත හා ඉඟි භාවිතා කළ හැකිය.

භාෂාවක වචන අර්ථවත් ආකරයට පිළියෙල කිරීමෙන් වාක්‍ය නිර්මාණය වේ. මේ සඳහා ව්‍යාකරණ නීති වැදගත් වේ.

මිනිසා සහ යන්ත්‍ර අතර සන්නිවේදනය

මිනිසා සහ යන්ත්‍ර අතර සන්නිවේදන ගොඩ නැගීම පහසු කාර්‍යක් නොවේ. මිනිසෙකු විසින්, පෙර කී සිංහල, ඉංග්‍රීසි වැනි භාෂාවකින් කතා කරන දෙය යන්ත්‍රයකට නොතේරේ.

යන්ත්‍ර සමග සන්නිවේදනයේ මූලිකම අවස්ථාවක් ලෙස බල්බ් එකක් දැල්වීම දැක්විය හැකිය. නමුත් මිනිස් භාෂා කිසිවක් විදුලි බුබුළට නොතේරේ.

එනම් විදුලි බුබුල දැල්විය යුතු බව විදුලි බුබුලට දැන්වීමට මිනිසාටත් විදුලි බුබුලත් තේරෙන පොදු අතුරුමුණතක්(interface) අවශ්‍ය වේ. මේ සඳහා අපි ස්වීචය නම් යාන්ත්‍රික අතුරුමුණත(interface) භාවිතා කරයි. එනම් යන්ත්‍ර සමග සන්නිවේදනයේදී පොදු අතුරුමුණතක් අනිවාර්යයෙන්ම අවශ්‍ය වේ.

පරිගණක අතුරුමුණත්

මිනිසා සහ පරිගණක අතර සන්නිවේදනය සඳහා භාවිතා කරන අතුරුමුහුණත් කිහිපයක් පහත දැක්වේ

1. Command line interface

keyboard එක මගින් පරිගණකයට විධාන ලබාදීම සඳහා මෙය භාවිතා කරයි. Windows command prompt, Mac OS terminal සහ Linux terminal උදාහරණ ලෙස දැක්විය හැකිය.

2. Graphical user interface(GUI)

WIN_Start_GenZ_Light_16x10_en-US-1024x640

ඵලදායිතාවය වැඩිකිරීම උදෙසා නවීන පරිගණක වල GUI භාවිත වේ. GUI එකෙහි ඇති icons/buttons click කිරීම මගින් පරිගණකයට input දීමටත් screen එකේ දිස් වෙන රූප මගින් ලබා දුන් input එකට අදාල ක්‍රියාවලිය දර්ශනය කිරීමත් සිදු වේ.

3. Touch-sensitive interface

Smart phone වල සහ ඇතැම් පරිගණක වලද touch sensitive display දක්නට ඇත. මේ මගින් GUI එක පෙන්වීමට අමතරව user input ඉතා කාර්‍යක්ෂමව ග්‍රහණය කර ගැනීමට හැකිය. Input එකක් ලබා දීමට අදාල icon/ button එක ඇඟිල්ලෙන් touch කිරීම ප්‍රමාණවත් වේ.

4. Voice interface

මිනිස් කථනය මගින් පරිගණකයට උපදෙස් ලබා දිය හැකි interface ද අද වන විට දක්නට ඇත. උදාහරණ: Apple Siri, Google assistant, Amazon alexa

4. Gestures-based user interface(GBUI)

Apple-Watch-double-tap-gesture-lp.jpg.landing-big_2x

GBUI යනු අද ප්‍රායෝගික ව භාවිත කිරීමට ඇති යන්ත්‍ර සමග සංවේදනයට ඇති දියුණුම ක්‍රමවේදයකි. මිනිසුන්ගෙ අත්, ඇඟිලි, ඇස්, හිස වැනි අවයව භාවිතයෙන් ඒවා චලනය මගින් යන්ත්‍රයකට විධාන ලබා දීමට මෙය භාවිතා කරයි. සිනා වීම, ඇස් චලනය, සතුට අසතුට, අත්පුඩි ගැසීම, හිස සෙලවීම වැනි දේවල් යන්ත්‍රය මගින් හඳුනාගෙන ඒ සඳහා අවශ්‍ය ප්‍රතිචාරය දැක්වීම සිදු වේ.

පරිගණක භාෂා බිහිවීම සහ විකාශනය

1940 සිට 1949 දක්වා කාලයේ එක් එක් කාර්‍ය සඳහා පරිගණක භාවිත කළේ එම එක් එක් කර්‍යයට අවශ්‍ය hardware කොටස් වයර් මගින් අවස්ථනුකූලව සම්බන්ධ කිරීම මගිනි. එනම් එක් කර්‍යකට පසු ඊට වඩා වෙනස් කාර්‍යක් සිදු කිරීමට වූ විට වයර් ගැලවීම සහ නිවැරදිව සවි කිරීමට සිදු විය.

පසුව මේවා switch board එකකට සවි කිරීම මගින් එක් එක් switch/ switch combination on off කිරීම මගින් පරිගණකයට අවශ්‍ය instructions දීම සිදු විය.

1950 – 1956 වකවානුව වන විට Assembly language නම් පරිගණක භාෂාවක් බිහි විය. මෙය බිහිවීමත් සමග පරිගණකයට ලිඛිත උපදෙස් ලබා දීමේ ලේඛන කලාවක් හෙවත් පරිගණක ක්‍රමලේඛනය(computer programming) බිහි විය.

1957 – 1965 කාලයේදී විද්‍යා , ගණිත සහ ව්‍යාපාරික කටයුතු සඳහා පරිගණක භාවිතය ඇරඹුනි. මෙම අවශ්‍යතා ඉටු කිරීම සඳහා මිනිස් භාෂාවලට සමීපතාවයක් දක්වන පරිගණක භාෂා බිහිවිය.

අද වන විට භාවිත වන c, c++,c#,Java, Python, Kotlin ඇතුළු සියලුම පරිගණක භාෂා වල උපත එසේ සිදු විය

Java program එකක් run වන ආකාරය

මෙහි ප්‍රධාන කොටස් 3ක් දැකිය හැකිය. මුලින්ම ඇත්තේ අප විසින් ලියන ලද .java extension එක සහිත file සමූහයකි. Code එක build කරන විට javac(java compiler) එක මහින් byte code සහිත .class extension සහිත class සමූයකට පරිවර්ථනය කරයි. Application එක run කළ විට එය run වන්නේ java virtual machine එක තුළයි. එනම් JVM යනු application එක සහ hardware අතර ඇති ස්ථරයකි.

Java හි මූලාරම්භය සහ විකාෂනය

Java පරිගණක භාෂාවේ පියා ලෙස සැලකෙන්නේ ආචාර්‍ය ජේම්ස් ගොස්ලින් ය. එකල භාවිතා කළ පරිගණක භාෂාවල තිබූ අඩුපාඩු වලට විසඳුමක් ලෙස ඔහු java නිර්මාණය කළේ ය. මේ සඳහා ප්‍රධාන කරුණු 3ක් පාදක විය.

1. Platform independence

Platform independancy යනු එක් පරිගණක පද්ධතියක් තුළ develop කරන ලද programm එකක් වෙනත් පරිගණක පද්ධතියක සෘජුව ධාවනය කිරීමට ඇති හැකියාවයි. මේ නිසා device නිෂ්පාදකයින්ට ඔව්න්ගේ විවිධ ආකරයේ device තුළ එකම භාෂාවක් පහසුවෙන් භාවිතා කළ හැකි විය.

2. Compactness

ඉතා අඩු memory එකක් තුළ programm එක ක්‍රියාත්මක කිරීමට හැකි විය. මේ නිසා උපකරණ මිළ සාපේක්ෂව අඩු විය. එම නිසා සරල භාණ්ඩ වල පවා computer prograam දක්නට ලැබුණි.

3. Reliability

දෝෂ සහ දෝෂ ඇති වීමේ ප්‍රවණතාව ඉතා අඩු විය. මේ නිස java run වන උපකරණ වලට ඇති විෂ්වාසය පාරිභෝගිකයන්ගේ වැඩි විය

Java මෙතරම් ජනප්‍රිය වීමට හේතු

1. Simple ( සරලයි)

Java වල භාවිත වන syntax සියල්ලම ඉංග්‍රීසි භාෂාවේ වචන හෝ වචන කෙටි කර දක්වන ඒවා වේ.

උදාහරණ: String, int, public, private, final, static, char

Garbage collectors මගින් ස්වයංක්‍රීයව memory management කරන නිසා develops ලා ඒ ගැන වද විය යුතු නැත.

2. Free and open-source ( නොමිලේ භාවිතා කළ හැක)

Free : කිසිම license fee එකක් නොමැතිව භාවිතා කිරිමට හැකිය. කිසිම restriction එකක් නැතුව program කිරීමට නිදහස developer ට ලබා දී ඇත.
Open-source: Developers ලට බැලීමට හැකි වන පරිදි source code එක publicly available කර ඇත. එමගින් ඕනැම අයෙකුට code එක study කිරීමට, Analyze කිරීමට සහ තේරුම් ගැනීමට හැකිය. එසේම යම් අඩු පාඩු තිබේ නම් ඒව සැකසීමට හා අළුත් features එකතු කිරීමට පවා හැකියාව ඇත.

3. Huge community support ( මිලියන 10කට වඩා java developers ල සිටී)

මේ නිසා developers ලට ඉගෙනීම සහ ගැටළු නිරාකරණය කර ගැනීම සඳහා අවස්ථාව උදා වී ඇත. කුමක් හෝ ගැටළුවක් පැමිණි විට එය අසා දැන ගැනීමට හා , මෙතෙක් පැමිණි ගැටළු වලට ලැබූ පිළිතුරු අධ්‍යනය කිරීමට forums විශාල ප්‍රමාණයක් ඇත. එසේම වැඩ කාර්යක්ෂම සහ පහසු කරගැනීම සඳහා භාවිතා කළ හැකි tools, libraries සහ plugins විශාල ප්‍රමාණයක් ඇත. මේ නිසා අලුතින් පටන් ගන්න අයට පවා Java ඉගෙනීම ඉතා පහසු වේ.

5. Powerful (බලසම්පන්නයි)

Large scale data handle කිරීමට, සන්කීර්ණ ක්‍රියාවලි තර්කානුකූල ව මෙහෙයවීමට Java වලින් සාදන ලද software වලට හැකියාව ඇත.

6. Secure (ආරක්ෂාව)

Encryption, authentication සහ safety protocol භාවිතයෙන් දත්ත පද්ධති වලට අවශ්‍ය ආරක්ෂාව සලසයි. මේ නිසා සංවේදී දත්ත සොරුන්ගෙන් පරිස්සම් වේ.

7. Reliable (විශ්වසනීයත්වය)

Reliability යනු system එක fail නොවී අඛණ්ඩව වැඩ කිරීමයි. System down time එකක් නැති වීම සහ නිවැරදි accuracy එකෙන් වැඩ කරයි. මේ නිසා users ලා හට critical task විශ්වාසයෙන් යුතුව කරගත හැකිය.

8. Object–oriented

අද අප භාවිත කරන සියලු software වල object oriented programming දක්නට ඇත. පෙර පැවති language වල තිබූ functions සහ logic පමණක් handle කිරීමට තිබූ හැකියාවට අමතරව මෙහිදී data සහ object භාවිතයෙන් වඩා ප්‍රායෝගික software නිර්මාණය කළ හැකිය.

Java හි භාවිත

1. Desktop Computers සඳහා Application සෑදීම.

Platform independence එක, rich libraries සහ ශක්තිමත් community support එක නිසා Desktop application සෑදීමට java බහුලවම භාවිතා කරයි. සියලුම ආකාර පරිශීලක අවශ්‍යතා සපුරාලමින් අලංකාර User interfaces ඇති ආකර්ෂණීය යෙදුම් නිර්මාණය කළ හැකිය.

2. Server සඳහා back-end application සෑදීම.

Secure බව, Scalability, powerful බව වැනි කරුණු නිසා java, back end application සෑදීමට යොදා ගනී. Spring සහ JavaEE framework භාවිතයෙන් developers ලා හට ඉතා ඉහළ ගුණාත්මක භාවයකින් යුතු, පහසුවෙන් නඩත්තු කළ හැකි හා ආරක්ෂිත back end services java මගින් සෑදිය හැකිය.

3. Mobile application සෑදීමට භාවිතා කිරීම

Mobile application සෑදීමට ඇති Android platform එක java භාවිතයෙන් සෑදූ එකකි. Android studio සහ Android SDK එක භාවිතයෙන් ඉතා පහසුවෙන් mobile application සෑදීම developers ලා හට හැකියාව ලැබී ඇත.

Install Java (JDK)

1. Install Java

මුලින්ම ඔබේ පරිඝණකයේ java install කර තිබේදැයි පරීක්ෂා කළ යුතුය. එය windows පරිඝණකය නම් Command promt එකේ හෝ Linux හෝ Mac පරිඝණකය terminal එකේ පහත code run කිරීම මගින් පරීක්ෂා කළ හැකිය.

C:\Users\<Your Name>java -version

එවිට පහත පරිදි java version එක display කරනු ලැබේ.

java version “17.0.1” 2021-10-19 LTS

Java(TM) SE Runtime Environment 18.9 (build 17.0.1+12-LTS)

Java HotSpot(TM) 64-Bit Server VM 18.9 (build 17.0.1+12-LTS-39, mixed mode

Java install කර නොමැතිනම් Oracle website එක මගින් එය download කර install කරගත හැක.

2. Path එක සැකසීම

Step 1

This PC ගොස් සුදු පාට පසුබිම right click කර properties යන්න. එවිට පහත දැක්වෙන පරිදි window එකක් open වෙනු ඇත. එහි Advanced system settings click කරන්න.

Step 2

පහත රූපයේ දැක්වෙන පරිදි window එකක් open වනු ඇත. එම රූපයේ පරිදි එහි දකුණු පස පහළ ඇති Environment Variable button එක click කරන්න.

Step 3

ඉන් පසු පහත රූපයේ දැක්වෙන window එක open වනු ඇත. එහි System variables යටතේ ඇති Path යන්න select කර Edit button එක click කරන්න.

Step 5

පරිඝණකය restart කර නැවතත් command promt එකෙහි පහත code එක run කිරීමෙන් java නිවැරදිව install උන බව තහවුරු කරගත හැක.

C:\Users\Your Name>java -version

එවිට පහත පරිදි java version එක display කරනු ලැබේ.

java version “17.0.1” 2021-10-19 LTS

Java(TM) SE Runtime Environment 18.9 (build 17.0.1+12-LTS)

Java HotSpot(TM) 64-Bit Server VM 18.9 (build 17.0.1+12-LTS-39, mixed mode)

Java editor එක install කිරීම

ඕනෑම programming language එකකින් code කිරීම සඳහා එයට අදාල Text editor එකක් අවශ්‍ය වේ. මෙය IDE(Integrated development environment)එක ලෙස හඳුන්වයි.

එක් එක් programming language වලට ගැලපෙන පරිදි විවිද IDE පවතී. Java සඳහා Eclipse, IntelliJ IDEA, NetBeans බහුලව භාවිතා කරයි.

මෙම පාඨමාලාව තුළදී Text editor එක වශයෙන් InterlliJ IDEA භාවිතා කරනු ලබයි. පහත link එක click කිරීමෙන් InterlliJ IDEA download කරගත හැක. Download IntelliJ IDEA

පළමු Java program එක ලිවීම

InterliJ IDE එක open කර, menu එකෙහි File click කර New වල ඇති Project click කරන්න.

ඉන්පසු පහත ආකාරයේ window එකක් open වෙයි. (1) හි Java යන්න select විය යුතුය. (2) Project එකේ නම් සඳහන් කරන්න. (3) Create button එක click කරන්න.

ඉන් පසු පහත ආකාරයට sample code එකක් සමග project එක create වේ.

Project එක run කිරීමට පහත ආකාරයට (1) හි සඳහන් play button එක click කළ යුතුය. මෙහිදී පළමුව run වනුයේ (2) හි සඳහන් main නම් method එකයි. Methods අපි ඉදිරියේ දී ඉගෙන ගන්නා අතර දැනට main method එක පළමුව run වන බව දැන සිටීම ප්‍රමාණවත් වේ.

මී ළඟට අපි කළ යුත්තේ console එකෙයි Hello world යන්න print කිරීමයි. මේ සඳහා අපට java SDK එකේ ඇති System.out.println() නම් method එක භාවිත කළ යුතුය. පහත පරිදි System.out.println() method එක තුළට “Hello world!” යන්න pass කර Application එක run කළ විට console එකෙයි Hello world! යන්න display වේ.

අප මෙහිදී ඉගෙන ගත යුතු වැදගත්ම දෙය වන්නේ console application වල output ලබා ගැනීමට System.out.println() method එක භාවිත කරන බවයි.

Java syntax (වාක්‍ය ඛණ්ඩ / වචන)

Syntax යනු මොනවාද?

Syntax යනු පරිගණකය විසින් වැඩසටහන් තේරුම් ගන්නා අකාරය නිර්වචනය කරන රීති සමූහයකි. එය මානව භාෂා වල ව්‍යාකරණ වලට සමානය. ව්‍යාකරණ වරදවා ලියන ලිපියක් අපට තේරුම් ගන්නවා අපහසු වන සේම පරිගණකයටද syntax නිවැරදිව භාවිතා නොකළ program එකක් තේරුම් ගත නොහැක.

Syntax වැදගත් වන්නේ ඇයි?

Consistency(අනුකූලතාව): Syntax නියම පරිදි භාවිතා කරන විට java code කියවීම සහ තේරුම් ගැනීම පහසුයි.

Error Prevention(දෝෂ වැළැක්වීම): Syntax errors මගින් program එක run වීම වළක්වයි. එමගින් දෝෂය කල්තියා නැවැරදි කරගත හැකිය.

Communication(සන්නිවේදනයට): සිංහල භාෂාවේ ව්‍යාකරණ අපට නිවැරදි සන්නිවේදනයට ඉඩ සලසන ආකරයටම java syntax අපට පරිගණකයට සන්නිවේදනය කිරීමට ඉඩ සලසයි.

Syntax වල ලක්ෂණ

1. Case Sensitivity

Hello සහ hello යන්න වෙනස් වචන දෙකක් ලෙස අඳුරගනී.

2. Statements and Semicolons

සෑම statement(ප්‍රකාශයක්ම) එකක්ම semicolon(;) එකකින් ඉවර කළ යුතුය. සිංහල භාෂාවේ නම් වාක්‍යකට පසුව නැවතීමේ තිත(.) තැබීමට සමානය.

3. Curly Braces {}

Curly braces { } භාවිතා කරන්නේ class එකක හෝ method එකක ආරම්භය සහ අවසානය කොතනද යන්න නිර්වචනය කිරීමටයි. එනම් statements group කිරිමටයි. Code block එකක ආරම්භය { කින් පටන් ගන්නා අතර } කින් අවසන් වේ.

Java Program Structure (Java program එකක ව්‍යුහය)

Statement: පරිගණකයට දෙන උපදෙසක් statement එකක් ලෙස හැඳින්විය හැකිය. සෑම statement එකක්ම semicolon එකකින් අවසන් කළ යුතුය.

Method: Method යනු නිශ්චිත කර්‍යක් ඉටුකිරීම වෙනුවෙන් ලියන ලද code group එකකි. එනම් statement වල එකතුවකි. Main method එක යනු program එක පටන් ගන්නා විට run වන මුල්ම method එකයි.

Classes : Classes යනු java program එකක ප්‍රදාන ව්‍යහය වේ. සෑම java program එකකම අඩුම වශයෙන් එක class එකක් හෝ තිබිය යුතුය.

Types of Java Syntax

Java code එකක තැනුම් ඒකකය වනේ syntax ය. එබැවින් syntax ගැන අවබෝධය ඉතා වැදගත් වේ. Identifiers සහ keyword නමින් syntax කොටස් දෙකකට බෙදේ.

Java Identifiers

Identifiers හැඳින්වීම

Developers ල විසින් classes, methods සහ variable සඳහා යොදන නම් identifies ලෙස හඳුන්වයි. Identifier එකකට නමක් තබන විට meaningful ඒවා තැබිය යුතුය. එවිට code එක පසුව කියවන විට තේරුම් ගැනීම පහසු වේ.

Rules for Identifiers

Identifier එකකට නමක් දීමේදී නීති සහ රීති සමූහයක් ඇත.

identifier එකක මුල් අකුර A-Z , a-z. හෝ $ හෝ _ මගින් පමණක් යුක්ත විය යුතුය.
Variables එකක මැදට හෝ අගට numbers භාවිතා කළ හැක.
Java keyword identifies ලෙස භාවිතා කළ නොහැක.

වලංගු සහ වලංගු නැති keyword වලට උදාහරණ

වලංගු identifiers	පැහැදිලි කිරීම
age	සියලුම අකුරු simple
studentName	කියවීමේ පසසුව සඳහා camelCase.
MAX_SCORE	සියල්ලම capital
_tempValue	Underscore එක මගින් ආරම්භය
$total	Starts with a dollar sign.

අවලංගු identifiers	පැහැදිලි කිරීම
2name	ඉලක්කමකින් පටන් ගැනීම
student-name, @count	Special characters එකක් අඩංගු වීම
class	class යනු java keyword එකකි.

Identifies නම් කිරීමේ සම්මුතීන්

Classes: Capital අකුරකින් පටන් ගෙන camelCase වලින් ලිවීම. (උදා: StudentRecord)

Methods and Variables: Simple අකුරකින් පටන් ගෙන camelCase වලින් ලිවීම. (උදා: ගණනය ලකුණු)

Constant: සියළුම අකුරු capital වලින් ලියා underscore (_) මගින් වචන වෙන් කිරීම. (උදා: MAX_SPEED).

Java Keywords

Keyword හැඳිවීම

Keyword යනු java programming සඳහා වෙන්කරන ලද වචන සමූහයකි. Keyword identifies ලෙස භාවිතා කළ නොහැක. පහත තද අකුරින් දැක්වෙන keyword අප විසින් ඉදියේ භාවිතා කරන බැවින් ඒව කුමක් සඳහා භවිතා කරන්නෙද යන්න දැනගෙන සිටීම වැදගත් වේ.

abstract	assert	boolean	break
byte	case	catch	char
class	const	continue	default
do	double	else	enum
for	goto	if	implements
import	instanceof	int	interface
long	native	new	package
private	protected	public	return
short	static	strictfp	super
switch	synchronize	this	throw
throws	transient	try	void
volatile	while	extends	final
finally	float

Comments in Java

Comment හැඳිවීම

Comment යනු code එකට එකතු කරන ලද එහෙත් java complier එක මගින් නොසලකා හරින ලද අකුරි, වචනන හෝ ඡෙද වේ. Code එකේ කාර්‍ය පැහැදිලි කිරීම සඳහා comment වැදගත් වේ. විශාල පිරිසක් එක් වී විශාල system එකක් develop කරන විට comments ඉතා වැදගත් වේ. Single line සහ multi line යනුවෙන් comment වර්ග 2ක් ඇත.

1. Single-Line Comments

Single line comments slashes දෙකකින් (//) පටන් ගත යුතුය. // දෙකට පසුව ඇති සියලුම දේ comment එකක් ලෙස සලකා compiler එක මගින් නොසලකා හරිනු ලබයි.

2. Multi-Line Comments

Multi line comment /* කින් පටන් ගෙන */ කින් අවසන් වේ. වාක්‍ය කිහිපයකින් යුක්ත ඡෙදයක් එකතු කිරීම සඳහා මෙය භාවිත වේ.

Comments යෙදීමේ ප්‍රයෝජන

Explaining Code: Code එකෙහි එක් එක් කොටසින් සිදුවන දෙය විස්තර කිරීමට.

Improving Readability: තමන්ටම මෙන්ම අනෙක් developers ලටත් code එක අවබෝධ කිරිම පහසු කරවීමට.

Debugging: Error එකක් ආ විට code එක තාවකාලිකව comment කරමින් වැරැද්ද හරියටම තියෙන තැන සොයා ගැනීමට.

Java Variables

Variables හැඳින්වීම

Variables යනු සෑම programming language එකකම තාවකාලිකව දත්ත ගබඩා කර තබා ගැනීමට භාවිත කරන ඇසුරුමක් (container) ලෙස හැඳින්විය හැකිය. එක් එක් variable එක සතුව එවාහි ගබඩා කළ හැක්කෙ කුමන වර්ගයේ data ද යන්න එම variable එකේ data type එක මගින් තීරණය වේ.

ප්‍රායෝගික උදාහරණයක් මගින් variables හැඳින්වීම

මෙය වඩාත් පැහැදිලි කර ගැනීම සඳහා අප සාමන්‍ය ජීවිතයේ උදාහරණ කිහිපයක් බලමු.

පෙදරේරුවෙකු විසින් නිවසක් සාදන ආකරය අප කවුරුත් දැක ඇත. එහිදී බදාම ඇනීමේදී මුළින්ම වැලි තාච්චියකට පුරවා එයින් කිහිපයක් එකතු කරයි. ඉන් පසු එයට සිමෙන්ති තාච්චි කිහිපයක් එකතු කරනු ලබන අතර පසුව ජලය බාල්දි කිහිපයක් එකතු කරයි. පසුව Mixer එකක් මගින් කවලම් කර විල් බැරෝවක පුරවා ගෙන ගොස් තහඩුවකට හෝ යම් කිසි මට්ටම් මතුපිටකට හලයි.

ඉන් පසු මේෂන් හැන්ඳ භාවිතයෙන් බදාම ගෙන බිත්තිය බඳිනු ලබයි. මෙහිදී පෙදරේරුවා විසින් විවිධ දේට ගැළපෙන විවිධ වර්ගයේ භාජන භාවිත කරන ආකරය අපි දැක්කෙමු.

එක් එක් වර්ගයේ දේවල් ගබඩා කිරීමට අප භාවිත කරන දේවල් පහත දක්වා ඇත.

ද්‍රවයක් ගබඩා කිරීමට හෝ රැගෙන යාමට ඊට උචිත බෝතලයක්, බාල්දියක් හෝ ටැංකියක් වැනි දෙයක් භාවිත කරයි.

පාසල් ළමුන් පොත් දාගෙන යාමට බෑග් එකක් භාවිත කරයි.

ඇඳුම් ගබඩා කර තැබීම සඳහා අල්මාරියක් භාවිත කරයි.

Java Variables සඳහා උදාහරණ

String – Text store කිරීම සඳහා මෙය භාවිත කරයි. Eg:- “Hello”

Int – දශම නැති numbers store කිරීම සඳහා මෙය භාවිත කරයි. Eg:- 1, -5

float – දශම සංඛ්‍යයා store කිරීම සඳහා මෙම data type එක භාවිත කරයි. Eg:- 1.25, -2.5

char – Single characters store කිරීම සඳහා මෙය භාවිත කරයි. Eg:- ‘c’, ‘d’

boolean – true සහ false යන status store කිරීම සඳහා මෙය භාවිත කරයි.

Define/Declaring (Creating) a variable (Variable එකක් සෑදීම)

Understanding the Syntax of Variable Declaration

ඕනෑම Variable එකක් define කරන ආකාරය පොදුවේ පහත පරිදි දැක්විය හැකිය.

dataType: Variable එක තුල store කරන data එක කුමක්ද යන්න විස්තර කරයි. ( උදාහරණ: පූර්ණ සංඛ්‍යා සඳහා int, දශම සංඛ්‍යා සඳහා double, text සඳහා String)

variableName: අදාල දත්ත කොටස හඳුනා ගැනීම සඳහා යොදන unique වූ නම. (identifier එක)

දශම නොමැති ඉලක්කම් ගබඩා කිරීමට variable එකක් අවශ්‍ය නම් එය පහත පරිදි define කළ හැක.

Variables define කිරීම සඳහා ආකාර කිහිපයක් ඇත. අවස්ථාව අනුව වඩාත් සුදුසු ක්‍රමය තෝරාගත යුතුය.

1. Initial value එකක් නොමැතිව define කිරීම.

Program එක run කරන විට අගයක් ආදේශ කරන අවස්ථා වලදී මෙම ක්‍රමය භාවිතා වේ.

2. Initial value එකක් සමග variable එකක් define කිරීම

3. Declare Multiple Variables (Variable කිහිපයක් එකවර සෑදීම)

එකම වර්ගයේ variable කිහිපයක් define කරන විට ඒවා comma separated list එකක් ලෙස define කළ හැක.

ඉහත ආකාරයට ලියනවා වෙනුවට සරලව මෙසේ ලිවිය හැක.

පහත ආකාරයට Initial value එකක් සමග define කිරීම ද කළ හැක.

පහත ආකාරයට Initial value එකක් සමග define කිරීම ද කළ හැක.

Print a variable (Variable එකක් console එකේ print කිරීම)

ඕනෑම පරිඝණක භාෂාවක console එකේ print කිරීමට පහසුකම් සලසා ඇත. Command line application සෑදීමට සහ developer ට අවශ්‍ය log print කිරීමට මෙය භාවිතා කරයි. Java වල යමක් display කිරීමට println() යන method එක use කරයි. එනම් variable එකක් print කිරීම පහත පරිදි සිදුකළ හැක.

Java Data types

Data Types හැඳින්වීම

Data types යනු java variable වල store කළ හැකි data වර්ග විස්තර කිරීම සඳහා යොදාගන්නා ක්‍රමවේදයකි. මෙය නිවැරදි වර්ගයෙන් සහ ප්‍රමාණයෙන් memory allocate කිරීමට උදව් වෙයි. නිවැරදි program එකක් ලිවීම සඳහා data types පිළිබඳව අවබෝධය ඉතා වැදගත් වේ.

Data types වර්ග දෙකකට බෙදනු ලබයි.

Primitive data types – byte, short, int, long, float, double, boolean, char
Non-primitive data types – Strings, Arrays, HashMap, Classes

Primitive Data Types

Primitive data types variable එකක දත්ත වර්ගය සහ size එක නිර්ණය කරයි. Java හි primitive data types 8ක් ඇත.

1. boolean

Conditions සඳහා භාවිත වේ.

2. byte

-128 ත් 127 ත් අතර data store කිරීමට වැදගත් වේ. මෙම range එක තුළ values පවතින arrays store කිරීමේදී byte data type එක ඉතා වැදගත් වේ.

3. char

තනි අකුරු ඉලක්කම් සංඛේත ගබඩා කිරීමට භාවිතා කරයි. Unicode format එකෙන් byte 2ක් පමණක් store කළ හැක.

4. short

Byte data type එක ප්‍රමාණවත් නොවන නමුත් ඉතා විශාලත් නොවන values ගබඩා කිරීමට මෙය භාවිතා කරයි.

5. int

පූර්ණ සංඛ්‍යා වලින් සිදුකරනු ලබන සියලුම ගණිතකර්ම වලට බහුලවම භාවිත වන data type එකයි.

6. long

Astronomical calculations වැනි ඉතා විශාල සංඛ්‍යා සමග කරන ගණිත කර්ම සඳහා මේවා භාවිතා වේ. Long එකක් ලෙස වර්ග කිරීමට සංඛ්‍යාව අගට L අකුර භාවිතා කරයි.

7. float

දශම සංඛ්‍යා ගබඩා ක්‍රීමට යොදාගනී. Memory save කිරීම සඳහා යොදාගත හැකි data type එකකි.

8. double

නිරවද්‍යතාවය වැදගත් sciencetific calculations සහ financial calculations සඳහා භාවිතා කරයි.

Non-Primitive (Reference) Data Types

Strings, Arrays, Classes store කිරීමට යොදා ගනී. මෙම data types වල අපිට ඕනෑම ආකරයල සංකීර්ණ දත්ත ගබඩා කළ හැකි අතර memory එකේ වැඩි ඉඩක් මේවට වැය වේ.

1. String

වචනයක් වාක්‍යක් ඕනෑම text එකක් store කිරීමට මෙය භාවිතා කළ හැකිය.

3. Array

එකම type එකේ data collection එකක් store කරීමට Arrays භාවිතා වේ.

Choosing the Right Data Type

නිවැරදි data type එක තෝරා ගැනීම memory ඉතිරි කරගැනීමට මෙන්ම program එකේ කාර්‍යක්ෂමතාවය වැඩි කරගැනීමට අත්‍යාවශ්‍ය වේ. Memory ඉතිරි කරගැනීම සඳහා පහත ආකරයට ගැලපෙන data type එක තෝරාගත හැක.

පූර්ණ සංඛ්‍යා සඳහා

byte – කුඩා සංඛ්‍යා, short – මධ්‍යාම ප්‍රමාණයේ සංඛ්‍යා, int සාමාන්‍ය භාවිතයට, long – ඉතා විශාල සංඛ්‍යා

දෂම සංඛ්‍යා සඳහා

float – නිරවද්‍යතාවයන් අඩු සහ කුඩා සංඛ්‍යා, double – නිරවද්‍ය තාවයෙන් වැඩි විශාල සංඛ්‍යා

අකුරු සහ වචන

char – තනි අකුරු හෝ ඉලක්කම්, String – වචනය හෝ ඡේද

Logical value

boolean – true or false

Java Type casting

Java type casting හැඳින්වීම

Definition: Type casting යනු එක් data type එකක් තවත් data type එකකට පරිවර්තනය කිරීමයි. මෙය memory management වලට, data නිවැරදිව හැසිරවීමට සහ data type වෙනස් data type එකකින් තිබෙන කොටස් bridge කිරීමට උපකාරී වේ.

Importance: විශේෂයෙන් ම primitive data types වල double සහ float අතර මෙන්ම int , long අතර data types අතර smoothly interact වීම සඳහා type casting වැදගත් වේ.

Type of casting (Casting වර්ග)

Implicit Casting (Widening Casting/පුළුල්)
Explicit Casting (Widening Casting/පටු)

Implicit Casting (Widening Casting/පුළුල්)

Definition: Programatically සිදු කිරීමකින් තොරව කුඩා data type එකක් විශාල data type එකකට automatically පරිවර්තනය වීම මෙලෙස හඳුන්වයි. int variables එකක value එකක් double variable එකකට assign කිරිම උදාහරණ ලෙස දැක්විය හැකිය.

Rule: නිතරම කුඩා data type එකේ value එක විශාල data type එකට assign වන නිසා data loss වීමක් සිදු නොවේ.

byte -> short -> char -> int -> long -> float -> double

int num = 100;
double result = num;  // Widening casting (int to double)
System.out.println("Integer casted to double: " + result);

Java Strings

Strings හැඳින්වීම

Characters සමූහයක් ගබඩා කිරීමට Strings භාවිතා කරයි.

Eg:- නමක්, ලිපිනයක්, ඡේදයක්

String variable එකක් පහත පරිදි define කරයි.

String name = "Java";

Strings methods

Java String class එක තුළ methods 50 කට වඩා ඇත. මෙම methods මූලික වශයෙන් String data හැසිරවීමට සහ විශ්ලේෂණය කිරීමට දායක වේ. බහුලව භාවිතා වන methods සහ ඒවායේ අරමුණ පහත දක්වා ඇත.

1. Basic Methods

Method	හැඳින්වීම
`length()`	String එකක ඇති characters ගණන ලබා ගැනීම.
`isEmpty()`	String එකක් empty ද නැද්ද යන්න check කිරීම.
`charAt(int index)`	නිශ්චිත index එකක ඇති character එකක් ලබා ගැනීම.

උදාහරණ:

length()

String name = "Kamal Perera";
System.out.println(name.length());

isEmpty()

String name = "Kamal Perera";
System.out.println(name.isEmpty());

charAt(int index)

String name = "Kamal Perera";
System.out.println(name.charAt(4));

2. Comparison Methods

Method	හැඳින්වීම
`equals(Object obj)`	String 2ක් සමානද කියා බැලීම.
`equalsIgnoreCase(String anotherString)`	Case sensitive නොසලකා හැර String 2ක් සමානද කියා බැලීම.

equals(Object obj)

String name1 = "Kamal Perera";
String name2 = "kamal Silva";
System.out.println(name1.equals(name2));

equalsIgnoreCase(String anotherString)

String name1 = "KaMal";
String name2 = "kamal";
System.out.println(name1.equalsIgnoreCase(name2));

3. Searching and Indexing

Method	හැඳින්වීම
`indexOf(int ch)`	String එකක් ඇති character එකක් පළමුව හමුවන තැන index එක ලබා ගැනීම.
`indexOf(String str)`	String එකක් ඇති substring එකක් පළමුව හමුවන තැන index එක ලබා ගැනීම.
`lastIndexOf(int ch)`	String එකක් ඇති character එකක් අවසානයේදී හමුවන තැන index එක ලබා ගැනීම.
`lastIndexOf(String str)`	String එකක් ඇති substring එකක් අවසානයේදී හමුවන තැන index එක ලබා ගැනීම.
`startsWith(String prefix)`	String එකක් යම් කිසි prefix එකකින් පටන් ගන්නවාදැයි බැලීම.
`endsWith(String suffix)`	String එකක් යම් කිසි suffix එකකින් අවසන් වනවාදැයි බැලීම.
`contains(CharSequence cs)`	String එකක් තුළ යම් characters sequence එකක් අඩංගු වේ දැයි බැලීමට.

indexOf(int ch)

String name = "Kamal";
System.out.println(name.indexOf('m'));

indexOf(String str)

String name = "Kamal De Alvis";
System.out.println(name.indexOf("De"));

lastIndexOf(int ch)

String name = "Kamal De Alvis";
System.out.println(name.lastIndexOf('l'));

lastIndexOf(String str)

String name = "Kamal Nimal Alvis";
System.out.println(name.lastIndexOf("ma"));

startsWith(String prefix)

String name = "Kamal De Alvis";
System.out.println(name.startsWith("Ka"));

endsWith(String suffix)

String name = "Kamal De Alvis";
System.out.println(name.endsWith("is"));

contains(CharSequence cs)

String name = "Kamal De Alvis";
System.out.println(name.contains("is"));

4. Substring and Extraction

Method	හැඳින්වීම
`substring(int beginIndex)`	කිසියම් index එකක සිට String එකේ අවසානය දක්වා කොටස ලබා ගැනීමට.
`substring(int beginIndex, int endIndex)`	කිසියම් නිශ්චිත index 2ක් අතර ඇති කොටසක් ලබා ගැනීමට.

substring(int beginIndex)

String name = "Kamal De Alvis";
System.out.println(name.substring(2));

substring(int beginIndex, int endIndex)

String name = "Kamal De Alvis";
System.out.println(name.substring(2,5));

5. Modification

Method	හැඳින්වීම
`concat(String str)`	String එකකට තවත් string එකක් සම්බන්ධ කිරීමට යොදා ගනී.
`replace(char oldChar, char newChar)`	Strings එකක ඇති යම් character එකක, සියලුම occurrences අලුත් character එකකින් replace කිරීමට යොදා ගනී.
`replaceAll(String regex, String replacement)`	Strings එකක ඇති යම් substrings එකක, සියලුම occurrences අලුත් substrings එකකින් replace කිරීමට යොදා ගනී.
`replaceFirst(String regex, String replacement)`	Strings එකක ඇති යම් substrings එකක, පළමු occurrence එක පමණක් අලුත් substrings එකකින් replace කිරීමට යොදා ගනී.
`trim()`	String එකක මුළට හෝ අගට ඇති while space ඉවත් කිරීමට.
`toUpperCase()`	String එකක ඇති සියළුම characters uppercase කිරීමට.
`toLowerCase()`	String එකක ඇති සියළුම characters lowercase කිරීමට.

concat(String str)

String name = "Kamal De";
System.out.println(name.concat(" Alvis"));

replace(char oldChar, char newChar)

String name = "Kamal De Alvis";
System.out.println(name.replace('K','A'));

replaceAll(String regex, String replacement)

String name = "Kamal De Alvis";
System.out.println(name.replaceAll("De","P"));

replaceFirst(String regex, String replacement)

String names = "Kamal, Amal, Nimal, Pathum, Amal";
System.out.println(names.replaceFirst("Amal","Kasun"));

trim()

String name = "Kamal De Alvis ";
System.out.println(name.trim());

toUpperCase()

String name = "Kamal De Alvis";
System.out.println(name.toUpperCase());

toLowerCase()

String name = "Kamal De Alvis";
System.out.println(name.toLowerCase());

6. Splitting and Joining

Method	හැඳින්වීම
`split(String regex)`	String එකක් regex එකක් භාවිතයෙන් කොටස් වලට කපා String array එකක් තුළට දැමීමට.
`split(String regex, int limit)`	පෙර ආකරයටම නිශ්චිත සීමවක් සහිතව substring ප්‍රමාණයක් ලබා ගැනීමට.

split(String regex)

String name = "Kamal De Alvis";
String[] array = name.split(" ");

split(String regex, int limit)

String name = "Kamal De Alvis";
String[] array = name.split(" ",1);

String concatenation

Strings 2ක් එකට join කිරීම මෙලෙස හඳුවයි. ඉහත උදාහරණ වලදි අපි concat() method එක භාවිතයෙන් එය සිදු කළෙමු. මෙහිදී + ලකුණ(operator) භාවිතයන් strings join කරන විදිය බලමු. බහුලව භාවිතා වන්නේ මෙලෙස + ලකුණ භාවිතයෙන් string join කිරීමයි.

String name = "Kamal De Alvis";
String address = "12E, Kaduwela Rd, Battaramulla";
System.out.println(name+" "+address);

Numbers and Strings

Java වල ඉලක්කම් එකතු කිරීමට සහ String සංයුක්ත කිරීමට යන දෙකටම + operator එක භාවිත කරයි. මෙහිදී පහත සඳහන් අවස්තා 3 ගැන අවබෝධය වැදගත් වේ.

Numbers 2 ක් + operator එකෙන් සම්බන්ධ කිරීම.
String 2ක් + operator එකෙන් සම්බන්ධ කිරීම.
String එකක් සහ number එකක් + operator එකෙන් සම්බන්ධ කිරීම.

1. Numbers 2 ක් + operator එකෙන් සම්බන්ධ කිරීම.

int x = 10;
int y = 20;
System.out.println(x+y);

2. String 2ක් + operator එකෙන් සම්බන්ධ කිරීම.

String x = "10";
String y = "20";
System.out.println(x+y);

3. String එකක් සහ number එකක් + operator එකෙන් සම්බන්ධ කිරීම.

int x = 10;
String y = "20";
System.out.println(x+y);

Special Characters

Single quotes(‘), Double quotes(“), Backslash() වැනි special characters සෘජුවම strings තුළ අන්ථර්ගත කළ නොහැකිය. පහත ආකරයේ text එකක් සැලකීමේදී එය තුල double quotes දැනටමත් අන්තර්ගත වේ.

Many people say “java” is most popular programming language.

එම නිසා එය නිකන්ම පහත ආකරයට string variable එකකට assign කළ නොහැක.

String txt = "Many people say "java" is most popular programming language.";

මෙයට විසඳුමක් වශයෙන් special character එකට පෙර backslash (\) එක යෙදය හැක.

String txt = "Many people say \"java\" is most popular programming language.";

මෙය Escape character එක ලෙස හඳුනවයි.

Escape character	Result	Description
\’	`\'A\'` → `'A'`	Single quotes
\”	\”A\”→ “A”	Double quotes
\\	`C:\\Path` → `C:\Path`	Backslash
\n	`A\nB` → `A` `B`	Slash n

// Single and Double Quotes
System.out.println("He said, \"Java's awesome!\"");  // Output: He said, "Java's awesome!"

// Backslash
System.out.println("File path: C:\\Users\\John");  // Output: File path: C:\Users\John

// Newline
System.out.println("Line1\nLine2");  // Output:
// Line1
// Line2
        
// Unicode
System.out.println("\u2764");  // Output: ❤

Java if else

හැඳින්වීම

Java if else(conditions) decision making සඳහා භාවිතා වෙයි. Programming වලදී decision making වැදගත් වන්නේ ඇයි දැයි බලමු. සාමන්‍ය ජීවිතයේදී ද අප decision making බහුලව භාවිත කරයි.

උදාහරණ:

“වැස්සොත් කුඩයක් රැගෙන යන්න”
“බඩගිනි නම් කන්න”.

මේ ආකරයටම program එකක ගලා යාම(flow එක) control කිරීමට if else භාවිත කරයි.

අර්ථදැක්වීම:

if-else statements program එකෙහි conditions මත පදනම්ව තීරණ ගැනීම්ට උපකාරී වේ.

Syntax:

if (condition) {
    // Code to execute if condition is true
} else {
    // Code to execute if condition is false
}

Boolean conditions හැඳින්වීම

Boolean Expressions(ප්‍රකාශන):

true හෝ false යන්න තක්සේරු කරන conditions(කොන්දේසි) boolean expression එකක් ලෙස හඳුන්වයි.

උදාහරණ:

10 > 5 → true

5 == 6 → false

මෙහි conditions එක check කිරීම සඳහා යොදා ඇති “>” , “==” යෙදුම් operators ලෙස හඳුන්වයි. Operators වර්ග 2ක් ඇත.

1. Comparison Operators

Values 2ක් සන්සන්දනය කිරීම සඳහා මේවා භාවිත වේ.

Operator	Name	Example	Description
==	Equal to	`x == y`	x හා y සමාද බැලීම
!=	Not equal to	`x != y`	x හා y අසමාද බැලීම
>	Greater than	`x > y`	y ට x විශාලද බැලීම.
<	Less than	`x < y`	y ට වඩා x කුඩා ද බැලීම
=	Greater than or equal	`x >= y`	y ට වඩා x විශාල හෝ සමානද බැලීම
<=	Less than or equal	`x <= y`	y ට වඩ x කුඩා හෝ සමානද බැලීම

2 Logical Operators

statements 2ක් තනි statement එකක් ලෙස ඒකාබද්ධ කිරීමට මේවා යොදාගනී. Conditions කිහිපයක් සැලකිල්ලට ගෙන decision make කිරීමට මේවා භාවිතා වේ.

Operator	Name	Example	Description
&&	Logical AND	`x > 5 && y < 10`	`x > 5` සහ `y < 10` යන conditions දෙකම true (සත්‍ය) වන්නේනම් පමණක් සමස්ත condition එක true (සත්‍ය) වේ.
\|\|	Logical OR	`x > 5 \|\| y < 10`	`x > 5` සහ `y < 10` යන conditions දෙකෙන් එකක් හෝ true (සත්‍ය) වන්නේ නම් සමස්ත condition එකම true (සත්‍ය) වේ.
!	Logical NOT	`!(x > 5)`	x > 5 true (සත්‍ය) නම් යන්න false වේ. එනම් conditions එකට result එකේ විලෝමය මෙහිදී ගනී.

If Statement

if statement එකක් යනු නිශ්චිත condition එකක් true වන්නේ නම් පමණක් code block එකක් execute වීමට සලස්වන ව්‍යුහයකි. if Condition එක false නම් if condition එක තුළ ඇති code එක run නොවේ.

Structure

if (condition) {
    // Code to execute if condition is true
}

උදාහරණ:

අවුරුදු 18 සම්පූර්ණ වූ අයෙකුට ඡන්ද අයිතිය ඇති බව කීම.

int age = 18;
if (age >= 18) {
    System.out.println("You are eligible to vote.");
}

If-Else Statement

if – else statement එකක් යනු නිශ්චිත condition එකක් true වන්නේ නම් if block එක තුළ ඇති code එක run වන සහ condition එක false වන්නේ නම් else එක තුළ ඇති code එක run වෙන ව්‍යුහයකි.

Structure

if (condition) {
    // Code to execute if condition is true
} else {
    // Code to execute if condition is false
}

උදාහරණ:

යම් සංඛ්‍යාවක් 2න් බෙදූ විට ඉතිරිය 0 නම් පෙර සංඛ්‍යාව ඉරට්ට සංඛ්‍යාවක් බවත් එසේ නොමැති නම් ඔත්තේ සංඛ්‍යාවක් බවත් කීම

int number = 10;
if (number % 2 == 0) {
    System.out.println("Even number");
} else {
    System.out.println("Odd number");
}

Nested If-Else

Nested if – else statement එකක් යනු decision එක hierarchical හෝ layered අකාරයට ගැනීමට උපකාරී වන ව්‍යුහයකි. මෙහිදී if හෝ else statement එකක් තුළ තවත් if, if – else, if – else ladder statement එකක් හෝ කිහිපයක් තිබිය හැකිය.

Structure

if (condition1) {
    if (condition2) {
        // Code to execute if both conditions are true
    } else {
        // Code to execute if condition1 is true but condition2 is false
    }
} else {
    // Code to execute if condition1 is false
}

උදාහරණ:

වෙළඳසැලක යම් discount එකක් ලබා ගැනීමේ දී member කෙනෙක් වීම අත්‍යවශ්‍යය වේ. Member කෙනෙක් නම් ඔහු මිළදී ගත් භාණ්ඩ වල වටිනාකම 100ට වැඩි නම් ඔහුට discount එක හිමි වේ. එසේ නොමැති නම් තවදුරටත් මිළ දී ගත යුතු බව දැන්විය යුතුය. Member කෙනෙක් නොවේ නම් member කෙනෙක් විය යුතු බව දැන්විය යුතුය.

if (isMember) {
    if (purchaseAmount > 100) {
        System.out.println("Eligible for a discount!");
    } else {
        System.out.println("Purchase more to get a discount.");
    }
} else {
    System.out.println("Membership required for discounts.");
}

Else-If Ladder

if – else ladder යනු අනුපිළිවෙළින් conditions කිහිපයක් පරීක්ෂා කිරීමට භාවිතා වන ව්‍යුහයකි. අනු පිළිවෙලින් conditions check කරගෙන යාමේදී එක් condition එකක් හෝ true උව හොත් ඉතිරි conditions validate වීමක් සිදු නොවේ.

Structure

if (condition1) {
    // Code to execute if condition1 is true
} else if (condition2) {
    // Code to execute if condition2 is true
} else {
    // Code to execute if none of the above conditions are true
}

උදාහරණ:

විභාගයක ලකුණු අනුව grade ලබා දීම.

int marks = 75;
if (marks >= 90) {
    System.out.println("Grade: A");
} else if (marks >= 75) {
    System.out.println("Grade: B");
} else if (marks >= 50) {
    System.out.println("Grade: C");
} else {
    System.out.println("Fail");
}

Shorthand if – else

if – else statement එකක් තනි line එකකින්(කෙටි කර) ලිවීමට මෙය භාවිතා කරයි. මෙහෙදී if else යන දෙකම භාවිතා වේ. If යන්න පමණක් හෝ else if භාවිතා කළ නොහැක.

Syntax

result = (condition) ? valueIfTrue : valueIfFalse;

Condition: ඇගයීමට (evaluate) ලක් කරන boolean expression එක.

valueIfTrue: Condition එක true වේනම් return (ආපසු ලබා දෙන) වන value එක හෝ expression එක.

valueIfFalse: Condition එක false වේ නම් return (ආපසු ලබා දෙන) වන value එක හෝ expression එක.

උදාහරණ:

අවුරුදු 18 ට හෝ 18ට වැඩි නම් “Adult” යන්න return කිරීම සහ එසේ නොවේ නම් “Minor” යන්න return කිරීම.

int age = 18;
String status = (age >= 18) ? "Adult" : "Minor";
System.out.println(status); // Output: Adult

ඉලක්කම් දෙකකින් විශාල value එක තේරීම.

int x = 5, y = 10;
int max = (x > y) ? x : y;
System.out.println("Maximum: " + max); // Output: Maximum: 10

Java Switch

හැඳින්වීම

Switch යනු, Variable එකකට තිබිය හැකි විවිධ values check කරමින් code flow එක control කිරීමට යොදා ගන්නා ව්‍යුහයකි. Variable එකක් සඳහා විවිධ values තිබෙන විට decision making සරල කිරීම සඳහා මෙය උපකාරී වේ. එලෙසම ඉතා දීර්ඝ if else ladders සඳහා මෙය විකල්පයක් වේ.

Syntax

switch (expression) {
    case value1:
        // code block
        break;
    case value2:
        // code block
        break;
    default:
        // default code block
}

Expression: byte, short, int, char, enum, or String (since Java 7) විය යුතුය.

Case Values: Constants(නියත) හෝ literals(වචනාර්ථ) විය යුතුය.

Break Statement: Switch block එකෙන් exit වීම සඳහා භාවිතා කරයි. break statement එක භාවිතා නොකළ හොත් මීළඟ case එක ද execute වේ.

Default: කිසිම case එකක් නොගැලපුන හොත් default block එකේ ඇති code එක run වේ. මෙය අනිවර්‍ය නොවුනත් යෙදීම වැදගත් වේ.

උදාහරණ:

සතියේ දින සඳුදායින් පටන් ගන්නා බව සලකන්න. දින හත, 1 සිට 7 දක්වා වූ ඉලක්කම් වලින් නිරූපනය වේ. දිනයට අදාල ඉල්ලක්කම ලබා දුන් පසු දිනයේ නම ලබා දෙන්න. 1 ට අඩු හෝ 7ට වැඩි ඉලක්කමක් ලබා දුන් විට “Invalid day” ලෙස ලබා දෙන්න.

int day = 3; // Change this value to test different days (1 to 7)

switch (day) {
	case 1:
		System.out.println("Monday");
		break;
	case 2:
		System.out.println("Tuesday");
		break;
	case 3:
		System.out.println("Wednesday");
		break;
	case 4:
		System.out.println("Thursday");
		break;
	case 5:
		System.out.println("Friday");
		break;
	case 6:
		System.out.println("Saturday");
		break;
	case 7:
		System.out.println("Sunday");
		break;
	default:
		System.out.println("Invalid day");
}

Switch වල වාසි සහ අවාසි

වාසි:

Multiple conditions භාවිතයේදී හොඳින් readable (කියවිය හැකි) සහ structured (ව්‍යුහගත) වේ.
Compiler එක මගින් කරන optimization (ප්‍රශස්තීකරණ) නිසා if else chain එකකට වඩා වේගවත් වේ.

සීමාවන්:

Java switch වලදී case 1 – 10 හෝ case >= 5 වැනි range (පරාස) භාවිත කළ නොහැක.
Discrete values කිහිපයකට සීමා වේ (e.g., int, char, String, enum).
Comparison operators වන හෝ logical operators වන කිසිවක් switch සමඟ භාවිතා කළ නොහැක.

Java While Loop

හැඳින්වීම

දෙන ලද conditions එකක් true වන තුරු නැවත නැවතත් run වන control flow statement එකකි. (Code block එකකි)

While loop

Syntax

while (condition) {
    // Code block to be executed
}

While loop එක වැඩ කරන ආකරය

Loop එක run වීමට පෙර, condition එක evaluate කර බලයි.
Conditions එක true වන්නේ නම් පමණක් code block එක run වේ.
Condition එක true වන තාක් loop එක දිගටම run වේ.

උදාහරණ:

1 සිට 10 දක්වා ඉලක්කම් print කරන්න.

int i = 1; 
while (i <= 10) { 
    System.out.println(i); 
    i++; 
}

උදාහරණ:

මුලින්ම Application එක මගින් 1ත් 10ත් අතර number එකක් target number එක ලෙස තබා ගනී. මීළඟට 1ත් 10ත් අතර number එකක් gues කරන ලෙස user ට උපදෙස් දෙයි. User enter කරන number එක සහ application එක මගින් තෝරන ලද target number එක සමාන නම් Correct number! ලෙස display විය යුතුය. Gues කරන ලද number එක application එක මගින් තෝරන ලද target number එකට වඩා කුඩා නම් Too low! Try again යන්න display විය යුතුය. Gues කරන ලද number එක application එක මගින් තෝරන ලද target number එකට වඩා විශාල නම් Too high! Try again යන්න display විය යුතුය. User විසින් number එක නිවැරදිව gues කරනකන් application එක run විය යුතුය.

Scanner scanner = new Scanner(System.in);
Random random = new Random();

int targetNumber = random.nextInt(10) + 1; // Random number between 1 and 10
int guess = 0;

System.out.println("Welcome to the Number Guessing Game!");
System.out.println("Guess a number between 1 and 10");

while (guess != targetNumber) {
	System.out.print("Enter your guess: ");
	guess = scanner.nextInt();

	if (guess < targetNumber) {
		System.out.println("Too low! Try again.");
	} else if (guess > targetNumber) {
		System.out.println("Too high! Try again.");
	} else {
		System.out.println("Correct!");
	}
}

scanner.close();

Nested While Loops

While loop එකක් තුළ තවත් while loop එකක් ඇති අවස්ථා මෙලෙස හඳුන්වයි.

උදාහරණ:

පහත දැක්වෙන 15 x 15 ගුණන වගුව print කරන්න.

1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	
2	4	6	8	10	12	14	16	18	20	22	24	26	28	30	
3	6	9	12	15	18	21	24	27	30	33	36	39	42	45	
4	8	12	16	20	24	28	32	36	40	44	48	52	56	60	
5	10	15	20	25	30	35	40	45	50	55	60	65	70	75	
6	12	18	24	30	36	42	48	54	60	66	72	78	84	90	
7	14	21	28	35	42	49	56	63	70	77	84	91	98	105	
8	16	24	32	40	48	56	64	72	80	88	96	104	112	120	
9	18	27	36	45	54	63	72	81	90	99	108	117	126	135	
10	20	30	40	50	60	70	80	90	100	110	120	130	140	150	
11	22	33	44	55	66	77	88	99	110	121	132	143	154	165	
12	24	36	48	60	72	84	96	108	120	132	144	156	168	180	
13	26	39	52	65	78	91	104	117	130	143	156	169	182	195	
14	28	42	56	70	84	98	112	126	140	154	168	182	196	210	
15	30	45	60	75	90	105	120	135	150	165	180	195	210	225

int row = 1;
while (row <= 15) {
	// Loop through columns (1 to 15)
	int col = 1;
	while (col <= 15) {
		// Print product of row and column
		System.out.print(row * col + "\t");
		col++;
	}
	// Move to the next line after each row
	System.out.println();
	row++;
}

Do/While loop

Syntax

do {
    // Block of code to be executed
} while (condition);

Do/While loop එක වැඩ කරන ආකරය

Conditions එක evaluate කිරීමට පෙර loop එක එක් වරක් run කරයි.
දෙවැනි loop එකේ සිට ඉතිරි loop run වන්නේ condition එක true වන්නේ නම් පමණි.
Condition එක true වන තාක් loop එක දිගටම run වේ.

උදාහරණ:

User ට ධන සංඛ්‍යාවක් ඇතුළත් කරන ලෙස උපදෙස් දෙයි. User ධන සංඛ්‍යාවක් ඇතුළත් කරන් තුරු “Enter positive number: ” යන messages එක display විය යුතුය. ධන සංඛ්‍යාවක් ඇතුළත් කළ පසු “You entered correct value : <entered value>” ලෙස print විය යුතුය.

Scanner scanner = new Scanner(System.in);
int number;

// Do-while loop for input validation
do {
	System.out.print("Enter a positive number: ");
	number = scanner.nextInt();
} while (number <= 0);  // Condition to check if number is positive

System.out.println("You entered correct value: " + number);

උදාහරණ:

Scanner scanner = new Scanner(System.in);
Random random = new Random();

int targetNumber = random.nextInt(10) + 1; // Random number between 1 and 10
int guess;

System.out.println("Welcome to the Number Guessing Game!");
System.out.println("Guess a number between 1 and 10");

do {
	System.out.print("Enter your guess: ");
	guess = scanner.nextInt();

	if (guess < targetNumber) {
		System.out.println("Too low! Try again.");
	} else if (guess > targetNumber) {
		System.out.println("Too high! Try again.");
	} else {
		System.out.println("Correct!");
	}
} while (guess != targetNumber);

scanner.close();

Java For Loop

හැඳින්වීම

Loop එක කී වතාවක් run කළ යුතුද යන්න හරියටම දන්නා විට while loop වෙනුවට for loop භාවිතා වේ.

Syntax

for (initialization; condition; increment/decrement) {
    // Code to be executed
}

Initialization: code block එක run වීමට පෙර එක් වරක් execute වේ. මෙමගින් loop එකෙහි starting value එක assign වීම සිදු වේ.
Condition: For loop එක නැවතිය යුතු condition එක මෙමගින් define කරයි.
Increment/Decrement: Loop එක එක් වරක් run වන විට statement 1 හිදී initialize කරගත් variable එකේ value එක කීයකින් වැඩි විය යුතුද යන්න මෙමගින් define කරයි.

උදාහරණ:

1 සිට 10 දක්වා ඉලක්කම් print කරන්න.

for (int i = 1; i <= 10; i++) {
    System.out.println(i);
}

int i = 1: i , 1න් පටන් ගන්නා බව
i <= 10: i වල අගය 10 වන තෙක් loop එක run වීම.
i++: i එකින් එක increment (වැඩි) වන බව.

උදාහරණ:

10 සිට 1 දක්වා ඉලක්කම් print කරන්න.

for (int i = 10; i >= 1; i--) {
    System.out.println(i);
}

int i = 10: i , 10න් පටන් ගන්නා බව
i >= 1: i වල අගය 1 වන තෙක් loop එක run වීම.
i–: i එකින් එක increment (වැඩි) වන බව.

උදාහරණ:

5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95 100

ඉහත සඳහන් ආකාරයට 0 ත් 100(100 ඇතුළත්ව) අතර 5 ගුණාකාර ටික ලියා දක්වන්න.

for (int i = 5; i <= 100; i+=5) {
  System.out.print(i+" ");
}

උදාහරණ:

1 සිට 100 දක්වා ඉලක්කම් වල එකතුව ලබා දෙන්න.

int sum = 0;
for (int i = 1; i <= 100; i++) {
    sum += i;
}
System.out.println("Sum: " + sum);

Nested Loops

පිටත ඇති loop එකහි එක් iteration (පුනරාවර්ථයක්) එකක් සඳහා ඇතුලත loop එක එක් වරක් ක්‍රියාත්මක වීම සිදු වේ.

පහත දැක්වෙනුයේ nested for loop එකකට උදාහරණයකි.

for (int i = 1; i <= 2; i++) {
  System.out.println("Outer: " + i); // Executes 2 times
  
  // Inner loop
  for (int j = 1; j <= 3; j++) {
	System.out.println(" Inner: " + j); // Executes 6 times (2 * 3)
  }
}

ඉහත code එක මගින් පහත ආකරායේ output එකක් ලබා දේ.

Outer: 1
 Inner: 1
 Inner: 2
 Inner: 3
Outer: 2
 Inner: 1
 Inner: 2
 Inner: 3

උදාහරණ:

පහත දැක් වෙන * රටාව print කරන්න.

*
**
***
****
*****

int rows = 5;

// Outer loop for rows
for (int i = 1; i <= rows; i++) {
	// Inner loop for columns
	for (int j = 1; j <= i; j++) {
		System.out.print("*");
	}
	// Move to the next line after each row
	System.out.println();
}

උදාහරණ:

පහත දැක් වෙන * රටාව print කරන්න.

    *
   ***
  *****
 *******
*********

int n = 5;
// Outer loop.
for (int i = 1; i <= n; i++) {
	// Print spaces
	for (int j = n; j > i; j--) {
		System.out.print(" ");
	}
	// Print stars
	for (int k = 1; k <= (2 * i - 1); k++) {
		System.out.print("*");
	}
	System.out.println();
}

Java For Loop

Array එකක් ඇති elements read කිරීමට පමණක් for-each loop භාවිතා වේ.

Syntax

for (dataType element : collection) {
    // Code to be executed for each element
}

dataType: Collection එකේ හෝ Array elements වල data type එක.
element: මේ වෙලාවෙයි process වන element එක තබා ගන්නා variable එක.
collection: Array එක.

උදාහරණ:

පහත සඳහන් Array එකෙහි ඇති numbers print කරන්න.

int[] numbers = {10, 20, 30, 40, 50};

int[] numbers = {10, 20, 30, 40, 50};
for (int num : numbers) {
    System.out.println("Number: " + num);
}

Java Break and Continue

Control Flow

Programming වලදී Control flow යන්නෙන් අදහස් කරන්නේ program එකක instructions ක්‍රියාත්මක කරන අනුපිළිවෙළ තීරණය කරන ආකාරයයි.

උදාහරණ:

1. පොතක් කියවීම.

මුල් chapter එක කියවගෙන යන විට පොතෙහි ඇති කතාව සිත්ගන්නා සුළු නම් ඊළඟ chapter එකද කියවයි. Story එක boring නම් පොත කියවන එක නවත්වයි. Story එක හොඳයි නම් දිගටම කියවගෙන යයි.

2. Traffic lights

Green Light: ඉදිරියට යා හැක (continue the sequence).

Yellow Light: ඉදිරියට යනවාද නවත්වනවාද යන්න රියදුරන් තීරණය කළ යුතුය. (a decision).

Red Light: සියලුම වාහන නැවැත්විය යුතුයි. (end of the flow).

break Keyword

හැඳින්වීම

Loop එකකින්, method එකකින් හෝ code block එකකින් බලෙන් exit වීමට (ඉවර වීමට පෙර) beark keyword එක භාවිතා කරයි.

Syntax

break;

උදාහරණ:

1 සිට 10 දක්වා run වන loop එකකින් i = 5 වන විට exit වන්න.

for (int i = 1; i <= 10; i++) {
	if (i == 5) {
		break;
	}
	System.out.println(i);
}

continue Keyword

හැඳින්වීම

එක් iteration එකක් skip කර ඊළඟ iteration එකට යාමට මෙහ භාවිතා වේ.

Syntax

continue;

උදාහරණ:

1 ත් 100ත් අතර ඔත්තේ සංඛ්‍යා පමණක් print කරන්න.

for (int i = 1; i <= 100; i++) {
	if (i % 2 == 0) {
		continue;
	}
	System.out.println(i);
}

Java Arrays

හැඳින්වීම

Array එකක් යනු එකම data type එකේ element conditions එකක් store කර තාබා ගැනීමට සෑදූ data structure එකකි. Arrays නිසා data store කිරීමත්, process කිරීමත් පහසු වේ. විශාල data sets කාර්‍යක්ෂමව manage කිරීමට arrays උපකාරී වේ.

1. Array එකක් Declare කිරීම

dataType[] arrayName;

2. Array එකකට memory allocate කිරීම (Create)

arrayName = new dataType[size];

3. Memory allocation එකත් සමග Array එක declare කිරීම (Declaring/Creating)

dataType[] arrayName = new dataType[size];

4. එක පියවරෙන් Array එකක් declare, create සහ initialize කිරීම (Declaring, Creating, and Initializing)

dataType[] arrayName = {value1, value2, value3, ...};

Array එකක් visually තේරුම් ගැනීමට උත්සහා කරමු. පහත අකාරයට size එක 5ක් වූ empty array එකක් සලකමු.

String[] fruits = new String[5]

මෙය පහත පරිදි visualize කළ හැකිය. එනම් පරිඝණක මතකයෙහි (RAM) පහත ආකාරයට String values 5ක් ගබඩා කළ හැකි අයුරින් memory කොටසක් වෙන් වේ.

Value
Index	0	1	2	3	4

Array එකක index එක සෑම විටම 0න් පටන් ගෙන 1කින් එක වැඩි වෙයි. ඉහත array එකෙහි size එක 5 නිසා 0න් පටන් ගෙන 4න් අවසන් වේ. (size එක n නම් index පවතිනුයේ 0 සිට n-1 දක්වා වේ.)

Array එක්ක ඇති Elements access කිරීම

1. Read කිරීම

පහත සඳහන් Array එකෙහි Cherry යන්න print කරන්න.

String[] fruits = {"Apple", "Banana", "Cherry", "Orange", "Grapes"};

ඉහත Array එක පහත පරිදි visualize කළ හැක.

Value	Apple	Banana	Cherry	Orange	Grapes
Index	0	1	2	3	4

ඉහත රූප සටහනට අනුව Cherry යන්නෙහි imdex එක 2 වෙයි. එනම් අපට පහත පරිදි index එක භාවිතයෙන් Cherry යන්න print කළ හැකිය.

System.out.println(fruits[3]);

2. Write කිරීම

Size එක 5ක් වූ int array එකක් define කර එහි 4 වන index එකට 50 යන value එක write කරන්න.

int[] array = new int[5];
array[4] = 50;

එවිට පහත පරිදි 4 වන index එකට 50 යන value එක assign වේ.

Value					50
Index	0	1	2	3	4

Arrays සමඟ loop භාවිතය

Arrays භාවිත වන බොහෝ අවස්ථා වලදී array element write කිරීමට සහ read කිරීමට loops භාවිත කිරීම සිදු වේ.

Syntax

for (int i = 0; i < arrayName.length; i++) {
    // Access array elements using arrayName[i]
    System.out.println(arrayName[i]);
}

මෙහිදී array එකෙව් size එක එහෙමත් නැත්තම් length එක දැන ගත යුතුය. Array එකක length එක පහත පරිදි ලබා ගත හැකිය.

arrayName.length

උදාහරණ:

පහත Array එකෙහි ඇති පළතුරු වල නම් සියල්ල print කරන්න.

String[] fruits = {"Apple", "Banana", "Cherry", "Orange", "Grapes"};

for (int i = 0; i < fruits.length; i++) {
    // Access array elements using fruits[i]
    System.out.println(fruits[i]);
}

පහත සඳහන් Array එකේ විශාලම සංඛ්‍යාව සොයන්න.

int[] numbers = {10, 20, 5, 30, 50, 15};

int max = numbers[0]; // Assume the first element is the largest
for (int i = 1; i < numbers.length; i++) {
	if (numbers[i] > max) {
		max = numbers[i];
	}
}

System.out.println("Maximum value: " + max);

පහත int array එකේ ඇති valuse වල එකතුව ලබා ගන්න.

int[] numbers = {10, 20, 30, 40, 50};

int sum = 0;
for (int i = 0; i < numbers.length; i++) {
	sum += numbers[i];
}

System.out.println("Sum of elements: " + sum);

පහත සඳහන් Strings array එකෙහි “Orange” යන්නෙයි index එක සොයන්න. අදාල Value එක Array එක තුළ නොමැති නම් “Element not found in the array” යන්න print කරන්න.

String[] fruits = {"Apple", "Banana", "Cherry", "Orange", "Grapes"};
String target = "Orange";

int index = -1; // Initialize as -1 (not found)
for (int i = 0; i < fruits.length; i++) {
	if (fruits[i].equals(target)) {
		index = i;
		break; // Stop searching after finding the target
	}
}

if (index != -1) {
	System.out.println("Element " + target + " found at index " + index);
} else {
	System.out.println("Element " + target + " not found in the array.");
}

පහත සඳහන් array එකේ positive number පමණක් print කරන්න.

int[] numbers = {5, -3, 7, -1, 8, -2, 10};

System.out.print("Positive numbers: ");
for (int i = 0; i < numbers.length; i++) {
	if (numbers[i] < 0) {
		continue; // Skip negative numbers
	}
	System.out.print(numbers[i] + " ");
}

Multidimensional Arrays

Multidimensional array එකක් යනු array එකක් තුළ ඇති array එකකි. Table එකක් ආකාරයට දත්ත ගබඩා කිරීමට multidimensional arrays භාවිතා වේ. පහත ආකාරයට multidimensional array එකක් define කළ හැකියි.

int[][] numbers = {{1,2,3,4},{5,6,7}};

ඉහත array එක visually තේරුම් ගැනීමට බලමු.

Array – 1

Value	1	2	3	4
Index	0	1	2	3

Array – 2

Value	5	6	7
Index	0	1	2

Value	Array – 1	Array – 2
Index	0	1

Multidimensional arrays වල values access කරන කිරීම

උදාහරණ:

පහත දැක්වෙන multidimensional array එකෙහි 2 සහ 7 යන සංඛ්‍යා print කරන්න.

int[][] numbers = {{1,2,3,4},{5,6,7}};

// print 2
System.out.println(numbers[0][1]);

// print 7
System.out.println(numbers[1][2]);

Multidimensional Arrays සමඟ loop භාවිතය

Multidimensional arrays සමඟ nested loop භාවිතා වේ.

පහත සඳහන් multidimensional array එකේ ඇති සියලුම values පහත ආකරයට print කරන ආකරය සලකා බලමු.

int[][] numbers = {{1,2,3,4},{5,6,7}};

Output
1 2 3 4
5 6 7

	
int[][] numbers = {{1,2,3,4},{5,6,7}};

for(int i = 0; i < numbers.length; i++){
	for(int j = 0; j < numbers[i].length; j++){
		System.out.print(numbers[i][j]+" ");
	}
	System.out.println();
}

Java Methods

හැඳින්වීම

නිශ්චිත කාර්‍යක් ඉටු කිරීම සඳහා ලියන ලද code block එකක් method එකක් ලෙස හඳුන්වනු ලබයි. Code duplicate විම වැලැක්වීමට සහ program එක module කිරීමට methods උදව් වෙයි.

Methods භාවිතය නිසා පහත සඳහන් වාසි දක්නට ලැබේ.

Re-usability: එක් වරක් ලියූ code එක බොහෝ වතාවක් භාවිතා කළ හැකි වීම.
Readability: Code එක කුඩා සහ logical section වලට organize කළ හැකි වීම.
Modularity: විශාල program එකක් manage කළ හැකි කුඩා කොටස් වලට බෙදීමට හැකි වීම.

උදාහරණ:

Washing machine එකකින් රෙදි සෝදන අවස්ථාවක් සලකන්න.

Input: ඇඳුම්, වතුර, detergent.
Processing: රෙදි සේදීම.
Output: පිරිසිදු ඇඳුම්.

මෙලෙසම method එකක්ද input ලබාගෙන, යම් ක්‍රියාවලියක් සිදු කර, output එකක් ලබා දෙයි.

Method එකක් සෑදීම (return type එකක් සහ parameters නොමැතිව)

Syntax

void methodName(){
    // Method body
}

void : return type එක
methodName: method එකේ name එක
(): method එක තුලට parameters pass කරන්නෙ මෙම වරහන් දෙක තුළින්
{} : execute වීමට අවශ්‍ය code එක මෙම සඟල වරහන් දෙක තුළ ලිවිය යුතුය

වැදගත්: method එකක් create කිරීමේදී එය අනිවර්‍යෙන්ම java class එකක් තුළ define කල යුතුය.

උදාහරණ:

“This text print by java method” යන්න print කිරීම සඳහා method එකක් ලියන්න.

void printText(){
	System.out.println("This text print by java method");
}

Method එකක් call කිරීම (return type එකක් සහ parameters නොමැතිව)

Method එකක් තුළ ඇති code එක execute වීමට නම් method එක call කිරීම අනිවර්‍ය වේ. Java වලදී method එකක් call කිරීමට method එකේ නම වරහන් දෙකක්() සහ semicolon; එකක් භාවිතා වේ. ඉහත Method එකක් call කරන ආකරය පහත දැක්වේ.

printText();

වැදගත්: Method එකක් call කිරීමේදී එය අනිවර්‍යෙන්ම තවත් java method එකක් තුළ call කල යුතුය.

Method එකක් සෑදීම (return type එකක් සහ parameters ඇතිව)

Syntax

accessModifier returnType methodName(parameters) {
    // Method body
    return value; // (if returnType is not void)
}

accessModifier: public, private, or protected.
returnType: Process එක අවසානයේ method එක මගින් return කරන value එකේ Datatype එක. Value එකක් return නොකරන්නේ නම් void යන්න භාවිතා කරයි.
methodName: Method එකේ නම (camelCase භාවිත කරන්න).
parameters: Method එක තුළට pass කරන input values (මෙය අනිවාර්‍ය නොවේ).

Java වලදී method එකක් create කරන ආකාරය සහ call කරන ආකාරය සලකා බලමු.

උදාහරණ:

ඉලක්කම් දෙකක් එකතු කිරීමට method එකක් ලියන්න. (Method එක create කිරීම)

public int addNumbers(int a, int b) {
    return a + b;
}

public: Access modifier එක.
int: return type එක.
addNumbers: Method එකේ නම.
int a, int b: Method parameters.
return a + b: Return value එක.

Method එකක් call කිරීම (return type එකක් සහ parameters ඇතිව)

int result = addNumbers(5, 10);

Java වලදී method එකක් call කිරීමට method එකේ නම වරහන් දෙකක්() සහ semicolon; එකක් භාවිතා වේ. Method එකෙහි parameters තිබේ නම් වහරන් තුළට එම parameter වල data type වලට ගැලපෙන values අදාල පිළිවෙලට වරහන් දෙක() තුළට ඇතුළත් කළ යුතුය.

ඉහත උදාරණයේ addNumbers method එක, addNumbers(5, 10); ලෙස එක් වරක් main method එක තුළ call කල විට addNumbers තුළ ඇති code එක එක් වරක් execute වේ.

public static void main(String[] args) {
    int result = addNumbers(5, 10);
    System.out.println("Result is: " + result);
}

උදාහරණ:

සංඛ්‍යාවක් දුන් විට එහි ක්‍රමාරූපිත අගය (factorial) ලබා දීමට java method එකක් ලියන්න. ( 3! = 1 * 2 * 3) (n! = 1 * 2 * 3 * …..* n)

public int factorial(int n) {
    int result = 1;
    for (int i = 1; i <= n; i++) {
        result *= i;
    }
    return result;
}

ඉහත method එක පහත පරිදි main method එක තුළ call කළ යුතුය.

public static void main(String[] args) {
	int factorial3 = factorial(3);
	int factorial5 = factorial(5);
	int factorial100 = factorial(100);
}

උදාහරණ:

Celsius ,Fahrenheit බවට පරිවර්ථනය කරන සූත්‍රය පහත දැක්වේ.

fahrenheit = (celsius * 9/5) + 32

Celsius ,Fahrenheit බවට පරිවර්ථනය කිරීම සඳහා method එකක් ලියන්න.

public double celsiusToFahrenheit(double celsius) {
	return (celsius * 9/5) + 32;
}

ඉහත method එක පහත පරිදි main method එක තුළ call කළ යුතුය.

double fahrenheit  = celsiusToFahrenheit(100);