මාතෘකාව 2: Java මූලිකාංග - අත්තිවාරම ශක්තිමත් කිරීම

2.1 Variables, Data Types, සහ Operators

ඕනෑම පරිගණක වැඩසටහනක මූලිකම කාර්යය වන්නේ දත්ත හැසිරවීමයි. **Variables** යනු එම දත්ත ගබඩා කර තබාගන්නා නමක් සහිත බහාලුම් (containers) වේ. සෑම variable එකකටම **data type** එකක් තිබිය යුතුය. එමගින් Java වෙත එම variable එකෙහි ගබඩා කළ හැකි දත්ත වර්ගය සහ ඒ සඳහා වෙන් කළ යුතු මතක ප්‍රමාණය (memory) පිළිබඳව දැනුම් දෙයි.

Primitive Data Types (මූලික දත්ත වර්ග)

මේවා Java හි ඇති සරලම දත්ත වර්ග වේ:

• int: පූර්ණ සංඛ්‍යා සඳහා (උදා: 10, -50, 42).
• double: දශම සංඛ්‍යා සඳහා (උදා: 3.14, -0.001).
• char: තනි අක්ෂරයක් සඳහා (උදා: 'A', '$').
• boolean: true (සත්‍ය) හෝ false (අසත්‍ය) යන අගයන් සඳහා.

Operators

Operators යනු variables සහ අගයන් මත විවිධ මෙහෙයුම් සිදු කරන විශේෂ සංකේත වේ.

// Variable එකක් ප්‍රකාශ කර අගයක් ලබා දීම
int age = 30;
double accountBalance = 1250.75;
char accountType = 'S'; // 'S' යනු Savings සඳහා
boolean isActive = true;

// Operators භාවිතා කිරීම
double depositAmount = 500.25;
double newBalance = accountBalance + depositAmount; // newBalance හි අගය 1751.0 වේ

System.out.println("නව ශේෂය 1500ට වඩා වැඩිද? " + (newBalance > 1500)); // ප්‍රතිදානය: true

2.2 Control Structures (පාලන ව්‍යුහයන්)

Control structures මගින් ඔබගේ වැඩසටහන ක්‍රියාත්මක වන ආකාරය පාලනය කරයි. තීරණ ගැනීමට සහ ක්‍රියාවන් නැවත නැවත සිදු කිරීමට මේවා ඉඩ සලසයි.

if-else ප්‍රකාශය

යම් කොන්දේසියක් සත්‍ය නම් පමණක් කේත කොටසක් ක්‍රියාත්මක කිරීමට භාවිතා කරයි.

double withdrawalAmount = 200.0;
if (accountBalance >= withdrawalAmount) {
    accountBalance = accountBalance - withdrawalAmount;
    System.out.println("මුදල් ලබා ගැනීම සාර්ථකයි.");
} else {
    System.out.println("ගිණුමේ ප්‍රමාණවත් මුදලක් නොමැත.");
}

for Loop

নির্দিষ্ট වාර ගණනක් කේත කොටසක් නැවත නැවත ක්‍රියාත්මක කිරීමට භාවිතා කරයි.

// 1 සිට 5 දක්වා සංඛ්‍යා මුද්‍රණය කිරීම
for (int i = 1; i <= 5; i++) {
    System.out.println("ගණනය: " + i);
}

2.3 Classes, Objects, සහ Methods

මෙය Object-Oriented Programming (OOP) හි හදවතයි. මෙය සැබෑ ලෝකය ආදර්ශයට ගනිමින් ක්‍රමලේඛනය ගැන සිතීමේ ක්‍රමයකි.

• Class යනු සැලැස්මක් (blueprint) හෝ අච්චුවකි. අපගේ ව්‍යාපෘතිය සඳහා, අපට Account class එකක් සෑදිය හැකිය. එය සියලුම ගිණුම් වලට පොදු ගුණාංග (දත්ත) සහ හැසිරීම් (ක්‍රියා) නිර්වචනය කරයි.
• Object යනු class එකකින් සාදන ලද නිදසුනකි (instance). අපට ඇත්තේ එක Account class එකක් (සැලැස්ම) වුවද, අපට එයින් බොහෝ Account objects (නිදසුන්) සෑදිය හැකිය (කමල්ගේ ගිණුම, නිමලිගේ ගිණුම). ඒ සෑම එකකටම තමන්ගේම දත්ත ඇත.
• Methods යනු object එකක හැසිරීම් විස්තර කරන, class එකක් තුළ නිර්වචනය කරන ලද functions වේ.

// මෙය සියලුම බැංකු ගිණුම් සඳහා වන සැලැස්මයි (blueprint)
public class Account {
    
    // ගුණාංග (Properties / Data)
    String accountNumber;
    String accountHolderName;
    double balance;

    // හැසිරීම් (Behaviors / Methods)
    public void deposit(double amount) {
        if (amount > 0) {
            balance = balance + amount;
            System.out.println("තැන්පත් කළා: " + amount);
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance = balance - amount;
            System.out.println("ආපසු ගත්තා: " + amount);
        } else {
            System.out.println("මුදල් ලබා ගැනීම අසාර්ථකයි.");
        }
    }

    public double getBalance() {
        return balance;
    }
}

2.4 Constructors සහ Encapsulation

Constructor යනු object එකක් නිර්මාණය කරන විට ක්‍රියාත්මක වන විශේෂ method එකකි. එහි අරමුණ වන්නේ object එකේ ගුණාංග (properties) ආරම්භ කිරීමයි.

Encapsulation යනු දත්ත (ගුණාංග) සහ එම දත්ත මත ක්‍රියාත්මක වන methods එකම ඒකකයක් (class එක) තුළට ඇසුරුම් කිරීමේ මූලික OOP මූලධර්මයයි. අපි දත්ත පිටතින් වෙනස් කිරීම වැලැක්වීමට private වැනි access modifiers භාවිතා කරන අතර, එම දත්ත වෙත පාලිත ප්‍රවේශයක් ලබා දීමට public methods (getters සහ setters) සපයන්නෙමු.

public class Account {
    // ගුණාංග දැන් ආරක්ෂා කිරීම සඳහා 'private' කර ඇත
    private String accountNumber;
    private String accountHolderName;
    private double balance;

    // මෙය නව Account object එකක් ආරම්භ කිරීමට භාවිතා කරන constructor එකකි
    public Account(String accNumber, String holderName, double initialDeposit) {
        this.accountNumber = accNumber;
        this.accountHolderName = holderName;
        this.balance = initialDeposit;
    }

    // ශේෂය ආරක්ෂිතව ලබා ගැනීමට public "getter" method එකක්
    public double getBalance() {
        return this.balance;
    }
    
    // deposit සහ withdraw methods මෙහි තිබිය යුතුය...
}

2.5 Collections (List, Map, Set)

Java Collections Framework මගින් object කාණ්ඩ ගබඩා කිරීම සඳහා බලවත් සහ කාර්යක්ෂම දත්ත ව්‍යුහයන් සපයයි.

• List: පිළිවෙලක් සහිත එකතුවකි. සිදු වූ අනුපිළිවෙලට ගනුදෙනු ලැයිස්තුවක් ගැන සිතන්න. අපි ArrayList භාවිතා කරන්නෙමු.
• Map: යතුරක් සහ අගයකින් (key-value pairs) යුත් එකතුවකි. ගිණුම් අංකය (String) key එක ලෙසත්, Account object එක value එක ලෙසත් ගබඩා කිරීමට මෙය ඉතා සුදුසුයි. අපි HashMap භාවිතා කරන්නෙමු.
• Set: අනුපිටපත් නොමැති (unique) දේවල් පමණක් දරණ එකතුවකි.

2.7 කුඩා ව්‍යාපෘතිය: Console Bank App

අපි මේ සියල්ල එකට එකතු කරමු! මෙම කුඩා ව්‍යාපෘතිය මගින්, අපි මෙම මාතෘකාවේදී ඉගෙන ගත් සියල්ල භාවිතා කර console එකේ ක්‍රියාත්මක වන සරල, අන්තර්ක්‍රියාකාරී බැංකු යෙදුමක් නිර්මාණය කරමු. එය පරිශීලකයෙකුට මුදල් තැන්පත් කිරීමට, ආපසු ගැනීමට සහ ශේෂය පරීක්ෂා කිරීමට ඉඩ සලසයි.

import java.util.Scanner;

public class ConsoleBankApp {

    public static void main(String[] args) {
        // constructor එක භාවිතා කර ගිණුම් object එකක් සාදමු
        Account myAccount = new Account("12345", "Kamal Perera", 1000.0);
        Scanner scanner = new Scanner(System.in);
        
        int choice = 0;
        
        while (choice != 4) {
            System.out.println("\n--- Bank Menu ---");
            System.out.println("1. ශේෂය පරීක්ෂා කරන්න");
            System.out.println("2. මුදල් තැන්පත් කරන්න");
            System.out.println("3. මුදල් ආපසු ගන්න");
            System.out.println("4. පිටවන්න");
            System.out.print("ඔබගේ තේරීම ඇතුළත් කරන්න: ");
            
            choice = scanner.nextInt();
            
            switch (choice) {
                case 1:
                    System.out.println("ඔබගේ ගිණුමේ ශේෂය: රු. " + myAccount.getBalance());
                    break;
                case 2:
                    System.out.print("තැන්පත් කළ යුතු මුදල ඇතුළත් කරන්න: ");
                    double depositAmount = scanner.nextDouble();
                    myAccount.deposit(depositAmount);
                    break;
                case 3:
                    System.out.print("ආපසු ගත යුතු මුදල ඇතුළත් කරන්න: ");
                    double withdrawAmount = scanner.nextDouble();
                    myAccount.withdraw(withdrawAmount);
                    break;
                case 4:
                    System.out.println("අප සමග ගනුදෙනු කළාට ස්තූතියි!");
                    break;
                default:
                    System.out.println("වැරදි තේරීමක්. කරුණාකර නැවත උත්සාහ කරන්න.");
            }
        }
        scanner.close();
    }
}
// සටහන: මෙය ක්‍රියාත්මක වීමට, කලින් නිර්වචනය කළ 'Account' class එකද අවශ්‍ය වේ.