Java Operators Explained: A SC Guide

කොහොමද යාලුවනේ! ඔයාලා හැමෝම හොඳින් ඉන්නවා කියලා හිතනවා. අද අපි කතා කරන්න යන්නේ Java Programming වල ඉතාම වැදගත්, ඒ වගේම අපිට දවසින් දවසට වැඩ කරනකොට නැතුවම බැරි වෙන essential part එකක් ගැන – ඒ තමයි Operators! නිකමට හිතන්නකෝ, අපිට මොනවා හරි ගණනය කරන්න (calculations), දේවල් සංසන්දනය කරන්න (comparisons), එහෙමත් නැත්නම් තර්කානුකූලව තීරණ ගන්න (logical decisions) ඕන වුණොත්? එතකොට තමයි මේ Operators අපේ වැඩේට එළිවහින දේවල් වෙන්නේ.

සරලව කිව්වොත්, Java Operators කියන්නේ programming language එකක values, variables, එහෙමත් නැත්නම් expressions මත operations කරන්න පාවිච්චි කරන special symbols වලට. ගණිතයේ '+' '-' වගේම, අපිට programming වලදීත් මේ වගේ symbols පාවිච්චි කරන්න වෙනවා. Java වල විවිධ Operator වර්ග තියෙනවා, ඒ හැම එකක්ම වෙනස් වැඩක් කරනවා. අද අපි ප්‍රධාන වශයෙන් Arithmetic, Comparison (Relational) සහ Logical Operators ගැන කතා කරමු, ඒ වගේම ඒවා practical විදියට කොහොමද පාවිච්චි කරන්නේ කියලා බලමු.

හරි, එහෙනම් වැඩේ පටන් ගමු!

1. Arithmetic Operators (ගණිතමය ක්‍රියාකරුවන්)

නම ඇහුව ගමන්ම තේරෙනවා නේද මේවා මොනවටද කියලා? මේ Operators පාවිච්චි කරන්නේ numerical values මත mathematical operations කරන්න. අපි දන්න simple ගණන් හැදීම් ටිකට මේවා නැතුවම බෑ. Java වල ප්‍රධාන Arithmetic Operators ටික තමයි මේ:

• + (Addition) - එකතු කිරීම
• - (Subtraction) - අඩු කිරීම
• * (Multiplication) - වැඩි කිරීම
• / (Division) - බෙදීම
• % (Modulus) - ඉතිරි වන අගය (remainder) සොයා ගැනීම

ඔන්න බලන්නකෝ මේ simple example එකක්!

public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 20;
        int b = 5;

        // Addition
        System.out.println("a + b = " + (a + b)); // Output: 25

        // Subtraction
        System.out.println("a - b = " + (a - b)); // Output: 15

        // Multiplication
        System.out.println("a * b = " + (a * b)); // Output: 100

        // Division
        System.out.println("a / b = " + (a / b)); // Output: 4 (integer division)

        // Modulus
        System.out.println("a % b = " + (a % b)); // Output: 0 (20 divided by 5 gives a remainder of 0)

        int c = 17;
        int d = 5;
        System.out.println("c / d = " + (c / d)); // Output: 3
        System.out.println("c % d = " + (c % d)); // Output: 2 (17 divided by 5 gives 3 with a remainder of 2)

        // Division with floating point numbers
        double x = 20.0;
        double y = 5.0;
        System.out.println("x / y = " + (x / y)); // Output: 4.0
    }
}

මේකේ වැදගත් point එකක් තමයි integer division. int වර්ගයේ variables දෙකක් බෙදනකොට, ප්‍රතිඵලයත් int එකක් විදියට තමයි එන්නේ. ඒ කියන්නේ දශම ස්ථාන ඉවත් වෙනවා (truncation). හැබැයි double වගේ floating-point numbers එක්ක වැඩ කරනකොට, ප්‍රතිඵලය දශම තියාගෙනම එනවා.

ඒ වගේම % (Modulus) operator එක ගැනත් විශේෂයෙන් මතක තියාගන්න. මේක පාවිච්චි කරන්නේ බෙදීමකදී ඉතිරි වෙන අගය (remainder) හොයාගන්න. ගොඩක් වෙලාවට සංඛ්‍යාවක් ඉරට්ටේද (even) හෝ ඔත්තේද (odd) කියලා බලන්න, එහෙමත් නැත්නම් යම් චක්‍රයක් (cycle) ඇතුලේ ඉන්නවද කියලා බලන්න වගේ දේවල් වලට මේක ප්‍රයෝජනවත් වෙනවා.

2. Comparison (Relational) Operators (සංසන්දනාත්මක ක්‍රියාකරුවන්)

දැන් අපි බලමු Comparison Operators ගැන. මේ Operators පාවිච්චි කරන්නේ values දෙකක් අතර තියෙන සම්බන්ධතාවය (relationship) සංසන්දනය කරන්න. මේවායේ ප්‍රතිඵලය හැමවෙලේම boolean (ඒ කියන්නේ true හෝ false) එකක් විදියට තමයි එන්නේ. Programming වලදී තීරණ ගන්න (decision making) මේ Operators අත්‍යවශ්‍යයි.

ප්‍රධාන Comparison Operators ටික මේවාය:

• == (Equal to) - සමානද?
• != (Not equal to) - අසමානද?
• > (Greater than) - වඩා විශාලද?
• < (Less than) - වඩා කුඩාද?
• >= (Greater than or equal to) - වඩා විශාලද හෝ සමානද?
• <= (Less than or equal to) - වඩා කුඩාද හෝ සමානද?

පටලවා ගන්න එපා, = කියන්නේ Assignment Operator (අගයක් ලබා දීම). == කියන්නේ Comparison Operator (අගයන් සමානදැයි බැලීම).

මෙන්න පොඩි උදාහරණයක්!

public class ComparisonDemo {
    public static void main(String[] args) {
        int p = 10;
        int q = 20;
        int r = 10;

        // Equal to
        System.out.println("p == q: " + (p == q)); // Output: false
        System.out.println("p == r: " + (p == r)); // Output: true

        // Not equal to
        System.out.println("p != q: " + (p != q)); // Output: true
        System.out.println("p != r: " + (p != r)); // Output: false

        // Greater than
        System.out.println("p > q: " + (p > q));   // Output: false
        System.out.println("q > p: " + (q > p));   // Output: true

        // Less than
        System.out.println("p < q: " + (p < q));   // Output: true
        System.out.println("q < p: " + (q < p));   // Output: false

        // Greater than or equal to
        System.out.println("p >= r: " + (p >= r)); // Output: true
        System.out.println("q >= p: " + (q >= p)); // Output: true

        // Less than or equal to
        System.out.println("p <= r: " + (p <= r)); // Output: true
        System.out.println("p <= q: " + (p <= q)); // Output: true
    }
}

මේ operators if statements, while loops වගේ තීරණ ගැනීමේ සහ නැවත නැවත ක්‍රියාත්මක කිරීමේ (looping) structures වලදී බහුලව පාවිච්චි වෙනවා. මොකද අපිට යම්කිසි තත්ත්වයක් (condition) සත්‍යද (true) හෝ අසත්‍යද (false) කියලා දැනගන්න ඕන වෙනවා.

3. Logical Operators (තාර්කික ක්‍රියාකරුවන්)

Logical Operators කියන්නේ boolean expressions (එනම් true හෝ false අගයන් දෙන expressions) combine කරන්න පාවිච්චි කරන ඒවා. මේවා පාවිච්චි කරලා අපිට complex conditions හදන්න පුළුවන්. Simple conditions කිහිපයක් එකතු කරලා ඒ හැම එකක්ම සත්‍යද, එහෙමත් නැත්නම් ඉන් එකක් හෝ සත්‍යද වගේ දේවල් බලන්න මේවා පාවිච්චි කරනවා.

ප්‍රධාන Logical Operators ටික මේවාය:

• && (Logical AND) - මේක සත්‍ය වෙන්නේ expressions දෙකම true නම් විතරයි.
• || (Logical OR) - මේක සත්‍ය වෙන්නේ expressions වලින් එකක් හෝ true නම්.
• ! (Logical NOT) - මේක boolean value එකක විරුද්ධ අගය දෙනවා (true නම් false, false නම් true).

ඔන්න උදාහරණයක්!

public class LogicalDemo {
    public static void main(String[] args) {
        boolean isStudent = true;
        boolean hasID = false;
        int age = 18;
        int requiredAge = 18;

        // Logical AND (&&)
        // isStudent සහ hasID දෙකම true නම් පමණක් true
        System.out.println("Can enter (isStudent && hasID): " + (isStudent && hasID)); // Output: false (because hasID is false)

        // Logical OR (||
        // isStudent හෝ hasID එකක් true නම් true
        System.out.println("Eligible for discount (isStudent || hasID): " + (isStudent || hasID)); // Output: true (because isStudent is true)

        // Logical NOT (!)
        // isStudent එකේ opposite එක දෙනවා
        System.out.println("Not a student (!isStudent): " + (!isStudent)); // Output: false
        System.out.println("Has no ID (!hasID): " + (!hasID)); // Output: true

        // Combining multiple conditions
        // වයස 18ට වැඩිද සහ ශිෂ්‍යයෙක්ද
        boolean canVote = (age >= requiredAge) && isStudent; // Let's assume students can vote if >=18
        System.out.println("Can vote: " + canVote); // Output: true

        // වයස 18ට වැඩිද හෝ හැඳුනුම්පතක් තියෙනවාද
        boolean hasAccess = (age > 18) || hasID;
        System.out.println("Has access: " + hasAccess); // Output: false (age is not > 18, and hasID is false)
    }
}

Logical Operators වලදී Short-Circuit Evaluation කියන concept එකත් වැදගත්. && operator එකේදී, පළවෙනි expression එක false වුණොත්, දෙවෙනි expression එක evaluate කරන්නේ නෑ, මොකද මුළු එකේම ප්‍රතිඵලය false වෙන එක confirm නිසා. ඒ වගේම || operator එකේදී, පළවෙනි expression එක true වුණොත්, දෙවෙනි expression එක evaluate කරන්නේ නෑ, මොකද මුළු එකේම ප්‍රතිඵලය true වෙන එක confirm නිසා. මේක program එකේ performance එකටත් පොඩි බලපෑමක් කරනවා.

4. Operator Precedence and Associativity (ක්‍රියාකරුවන්ගේ ප්‍රමුඛතාවය සහ සම්බන්‍ධතාවය)

අපි එකම expression එකක operators කිහිපයක් එකට පාවිච්චි කරනකොට, Java ඒවා evaluate කරන්නේ යම්කිසි පිළිවෙලකට. මේක තමයි Operator Precedence කියන්නේ. උදාහරණයක් විදියට, ගණිතයේදී වගේම Java වලදීත් ගුණ කිරීම (*) සහ බෙදීම (/) එකතු කිරීමට (+) සහ අඩු කිරීමට (-) වඩා ප්‍රමුඛයි.

Associativity කියන්නේ එකම Precedence තියෙන Operators evaluate කරන පිළිවෙල (වමේ සිට දකුණටද, නැත්නම් දකුණේ සිට වමටද). ගොඩක් operators වමේ සිට දකුණට තමයි evaluate වෙන්නේ.

උදාහරණයක් විදියට:

public class PrecedenceDemo {
    public static void main(String[] args) {
        int result = 5 + 3 * 2; // (3 * 2) = 6, then 5 + 6 = 11
        System.out.println("Result 1: " + result); // Output: 11

        int result2 = (5 + 3) * 2; // (5 + 3) = 8, then 8 * 2 = 16
        System.out.println("Result 2: " + result2); // Output: 16
    }
}

පළමු උදාහරණයේදී, * operator එකට + operator එකට වඩා precedence වැඩි නිසා 3 * 2 මුලින්ම ගණනය වෙනවා. දෙවෙනි එකේදී, වරහන් (parentheses) යොදාගැනීමෙන් අපිට ගණනය කිරීමේ පිළිවෙල වෙනස් කරන්න පුළුවන්. Complex expressions ලියනකොට වරහන් පාවිච්චි කිරීම හොඳ practice එකක්, මොකද එතකොට code එක තේරුම් ගන්න පහසු වෙනවා.

නිගමනය (Conclusion)

ඉතින් යාලුවනේ, අද අපි Java වල තියෙන ප්‍රධාන Operators වර්ග තුනක් ගැන කතා කළා: Arithmetic, Comparison, සහ Logical Operators. මේවා තමයි ඕනෑම Java programmer කෙනෙක් දැනගෙන ඉන්න ඕන කරන මූලිකම concepts. මොකද අපි මොන තරම් සංකීර්ණ program එකක් හැදුවත්, ඒ හැම එකකම යම් තැනකදී මේ Operators පාවිච්චි වෙනවාමයි. තීරණ ගන්න, ගණන් හදන්න, කොන්දේසි පරීක්ෂා කරන්න මේවා අත්‍යවශ්‍යයි.

මතක තියාගන්න, Programming කියන්නේ පොත් වලින් කියවලා විතරක් ඉගෙන ගන්න පුළුවන් දෙයක් නෙමෙයි. ඒක වැඩ කරලා, errors හදාගෙන, practice කරලාම තමයි හොඳට පුරුදු වෙන්න ඕන. ඉතින් අද අපි කතා කරපු operators ඔයාලාගේම පොඩි programs වලට දාලා experiment කරලා බලන්න. මොනවා හරි ප්‍රශ්නයක් තියෙනවා නම්, තේරුම් නොගිය තැනක් තියෙනවා නම්, පහළ තියෙන comment section එකේ අහන්න අමතක කරන්න එපා! පුළුවන් ඉක්මනටම මම උත්තර දෙන්නම්.

ඊළඟ post එකෙන් හම්බවෙමු! ඔබට ජය!