Java Interfaces - මොනවද මේ? | SC Guide

කොහොමද ඉතින් යාළුවනේ, SC Guide එකට ආයෙත් ආදරෙන් පිළිගන්නවා! අපි හැමෝම දන්නවනේ ලෝකෙ දියුණු වෙනකොට හැමදේම automate කරන්න, පහසු කරන්න තමයි අපි software හදන්නේ කියලා. ගෙයක් හදනකොට design එක, plans නැතුව හරියට වැඩේ කරන්න බැරි වගේම, software හදනකොටත් හොඳ සැලැස්මක්, හොඳ architecture එකක් අත්‍යවශ්‍යයි. විශේෂයෙන්ම Java වගේ Object-Oriented Programming (OOP) භාෂාවකදී, අපේ code එක හරියට structure කරගන්න එක ගොඩක් වැදගත් වෙනවා. අන්න ඒ වගේ වැදගත් concept එකක් ගැන තමයි අපි අද කතා කරන්න යන්නේ – ඒ තමයි Java වල Interfaces.

Interfaces කියන්නේ මොනවද? ඇයි මේවා අපිට ඕනේ? මේවා නැතුව බැරිද? මේ වගේ ප්‍රශ්න ගොඩකට අද අපි උත්තර හොයාගමු. Interfaces කියන්නේ Java වල code එක loose coupling කරගෙන, high cohesion තියාගෙන, flexible සහ extensible code ලියන්න උදව් වෙන නියම tool එකක්. ඒක හරියට universal remote එකක් වගේ. remote එකට මොන TV එකද සම්බන්ධ වෙලා තියෙන්නේ කියලා වැඩක් නෑ, ඒකට පුළුවන් TV එක 'On' කරන්න, 'Off' කරන්න, 'Channel' මාරු කරන්න. මොකද හැම TV එකකම මේ 'On', 'Off', 'Change Channel' කියන 'interface' එක තියෙනවා.

මොකද මේවා නැතුව ලොකු, දියුණු applications හදන්න බෑ කියලා කිව්වොත් ඒක වැරදිත් නෑ. අපි අද මේ interfaces කියන දේ ගැන මුල ඉඳන්ම සරලව, උදාහරණ එක්ක කතා කරමු. එහෙනම් අපි පටන් ගමු!

මොනවද මේ Interface කියන්නේ?

සරලව කිව්වොත්, interface එකක් කියන්නේ Java වල object එකක් 'මොන වගේ වැඩ කරන්න පුලුවන්ද' කියලා කියන 'contract' එකක්. හිතලා බලන්නකෝ, අපිට මොකක් හරි device එකක් හදන්න ඕනේ, ඒකට power supply එකක් දෙන්න ඕනේ කියලා. මේ power supply එකට අනිවාර්යයෙන්ම current එක දෙන්න පුළුවන් වෙන්න ඕනේ, voltage එක maintain කරන්න පුළුවන් වෙන්න ඕනේ. මේ 'current දෙන එක' සහ 'voltage maintain කරන එක' කියන්නේ ඒ power supply එකෙන් කරන්න ඕන වැඩ. මේ වැඩ ටික තමයි interface එකක් විදියට define කරන්නේ.

Class එකක් වගේම තමයි, හැබැයි පොඩි වෙනස්කම් ගොඩක් තියෙනවා. Interface එකක සාමාන්‍යයෙන් තියෙන්නේ:

• Abstract Methods: මේවාට body එකක් (implementation) නෑ. ඒ කියන්නේ මේවා වැඩේ කරන හැටි කියන්නේ නෑ, 'කරන්න ඕනේ වැඩේ' විතරයි කියන්නේ. Java 8 කලින් හැම method එකක්ම public abstract විදියට තමයි තිබුනේ.
• Constants: Interface එකක අපිට public static final variables විතරයි declare කරන්න පුළුවන්. ඒ කියන්නේ මේවා වෙනස් කරන්න බැරි constants.

Java 8 ඉඳන් Interfaces වලට default methods සහ static methods add වුණා. මේවාට implementation එකක් (body) තියෙන්න පුළුවන්. default methods කියන්නේ interface එක implement කරන classes වලට ඒවා override කරන්න පුළුවන්, නැත්නම් default implementation එක පාවිච්චි කරන්න පුළුවන්. static methods interface එකත් එක්කම operate වෙන methods, ඒවා object instance එකකට අයිති නෑ.

පැහැදිලිව කිව්වොත්, Interface එකක constructor එකක් නෑ, ඒ වගේම interface එකකින් object එකක් හදන්නත් බෑ (instantiate කරන්න බෑ).

Interface එකක් හදමුද? (Implementation)

අපි පොඩි උදාහරණයක් අරගෙන මේක තවදුරටත් පැහැදිලි කරගමු. අපි හිතමු අපිට විවිධ වර්ගයේ වාහන (vehicles) හසුරුවන්න පුළුවන් system එකක් හදන්න ඕනේ කියලා. වාහනයක් කිව්වම ඕනෑම වාහනයක් පාරේ ධාවනය වෙන්නත්, නවත්වන්නත් පුළුවන් වෙන්න ඕනේ. මේ 'ධාවනය වීම' සහ 'නැවැත්වීම' කියන දේවල් අපිට interface එකක් විදියට define කරන්න පුළුවන්.

1. Interface එක නිර්මාණය කිරීම:

interface Drivable {
    void drive(); // This is an abstract method
    void stop();  // This is another abstract method
}

මේ Drivable interface එක කියන්නේ 'ධාවනය විය හැකි' කියන හැකියාව. ඕනෑම වාහනයක් Drivable නම්, ඒකේ drive() සහ stop() කියන methods දෙක අනිවාර්යයෙන්ම තියෙන්න ඕනේ කියලා තමයි මේ interface එකෙන් කියන්නේ. මේ methods වලට implementation එකක් නෑ, ඒක අදාල class එකට භාරයි.

2. Interface එකක් implement කිරීම:

දැන් අපි මේ Drivable interface එක අපේ Car (කාර්) class එකෙන් implement කරමු. implements කියන keyword එක තමයි මේකට පාවිච්චි කරන්නේ.

class Car implements Drivable {
    @Override
    public void drive() {
        System.out.println("කාර් එක ධාවනය වේ.");
    }

    @Override
    public void stop() {
        System.out.println("කාර් එක නතර කරන ලදී.");
    }
}

class Truck implements Drivable {
    @Override
    public void drive() {
        System.out.println("ට්‍රක් රථය ධාවනය වේ.");
    }

    @Override
    public void stop() {
        System.out.println("ට්‍රක් රථය නතර කරන ලදී.");
    }
}

මෙහිදී Car සහ Truck කියන classes දෙකම Drivable interface එකේ තියෙන drive() සහ stop() methods අනිවාර්යයෙන්ම implement කළ යුතුයි. implements කළාට පස්සේ, interface එකේ තියෙන හැම abstract method එකකටම implementation එකක් (body) දෙන්නම ඕනේ, නැත්නම් compile error එකක් එනවා. @Override annotation එක optional වුණත්, හොඳ practice එකක් විදියට හැමවිටම භාවිතා කරන එක හොඳයි.

3. Interface එක භාවිතා කිරීම:

දැන් අපි බලමු මේවා program එකක් ඇතුළේ කොහොමද පාවිච්චි කරන්නේ කියලා:

public class VehicleSimulator {
    public static void main(String[] args) {
        Drivable myCar = new Car();
        Drivable myTruck = new Truck();

        System.out.println("කාර් එකේ ක්‍රියාකාරිත්වය:");
        myCar.drive();
        myCar.stop();

        System.out.println("\nට්‍රක් රථයේ ක්‍රියාකාරිත්වය:");
        myTruck.drive();
        myTruck.stop();

        // You can also pass Drivable objects to methods
        startVehicle(myCar);
        startVehicle(myTruck);
    }

    public static void startVehicle(Drivable vehicle) {
        System.out.println("\nවාහනයක් ආරම්භ වේ...");
        vehicle.drive();
    }
}

මේ code එකේ main method එක ඇතුලේ අපි Drivable type එකේ variables හදලා, ඒවට Car සහ Truck objects assign කරලා තියෙනවා. ඒක නියමයි නේද? අපිට Drivable කියන පොදු type එකෙන් Car එකක්ද Truck එකක්ද කියලා බලන්නේ නැතුව ඒවට drive() සහ stop() කියන methods call කරන්න පුළුවන්. මේක තමයි Polymorphism.

Interface වලින් ලැබෙන වාසි (Advantages)

Interfaces භාවිතා කිරීමෙන් අපේ code එකට ගොඩක් වාසි ලැබෙනවා. මේවා තමයි ඕනෑම දියුණු application එකකට අත්‍යවශ්‍ය කරුණු:

1. Polymorphism (බහුරූපීත්වය)

උඩ උදාහරණයෙන් අපි දැක්කා වගේ, interface එකක් අපිට Polymorphism achieve කරන්න උදව් කරනවා. ඒ කියන්නේ, අපිට පොදු type එකක් (interface) භාවිතා කරලා විවිධ classes වල objects handle කරන්න පුළුවන්. Drivable type එකෙන් අපිට Car, Truck, Motorcycle වගේ ඕනෑම Drivable object එකක් handle කරන්න පුළුවන්. මේක code එක flexibble කරනවා වගේම, නඩත්තු කරන්නත් පහසුයි.

2. Multiple Inheritance Simulation (බහු උරුමය අනුකරණය කිරීම)

Java වල class වලට multiple inheritance නැහැ කියලා ඔයාලා දන්නවනේ (එක class එකකට එක superclass එකක් විතරයි extend කරන්න පුළුවන්). ඒත් interface වලට පුළුවන්. එක class එකකට interfaces කීපයක් implement කරන්න පුළුවන්. මේකෙන් අපිට class එකක functionality එකට interfaces කීපයකින් එන behaviour එකතු කරන්න පුළුවන්. උදාහරණයක් විදියට, Hybrid Car එකක් Drivable වගේම Chargeable (බැටරි ආරෝපණය කළ හැකි) වෙන්නත් පුළුවන්.

interface Chargeable {
    void charge();
}

class HybridCar implements Drivable, Chargeable {
    @Override
    public void drive() {
        System.out.println("Hybrid car is driving.");
    }

    @Override
    public void stop() {
        System.out.println("Hybrid car has stopped.");
    }

    @Override
    public void charge() {
        System.out.println("Hybrid car is charging.");
    }
}

3. Loose Coupling (ලිහිල් සම්බන්ධතාවය)

Interface එකක් භාවිතා කරනකොට, අපේ code එක වෙනත් class එකක implementation details වලට බැඳිලා නැහැ. ඒක හරියට phone charger එකක් වගේ. Phone එකට ඕනේ USB-C port එකක් විතරයි. ඒ charger එක Samsung ද, Apple ද, නැත්නම් චීනේද කියලා වැඩක් නෑ. මේකෙන් වෙනස්කම් කරන්න, test කරන්න පහසු වෙනවා. Class දෙකක් අතර තියෙන dependency එක අඩු වෙනවා.

4. Achieving Abstraction (වියුක්තකරණය සාක්ෂාත් කර ගැනීම)

Abstraction කියන්නේ 'implementation details' හංගලා 'essential features' විතරක් පෙන්නන එක. Interfaces මේකට නියමයි. අපිට object එකකින් කරන්න පුළුවන් දේවල් define කරන්න පුළුවන්, හැබැයි ඒ දේවල් කරන හැටි (internal logic) සම්පූර්ණයෙන්ම හංගලා තියන්න පුළුවන්. මේකෙන් system එකේ complexity එක අඩු වෙනවා.

5. Designing APIs (API නිර්මාණය කිරීම)

ලොකු libraries සහ frameworks හදනකොට API (Application Programming Interface) design කරන්න interface බහුලව පාවිච්චි කරනවා. Interfaces මගින් programmers ලට තමන්ගේ code එකත් එක්ක interact කරන්න පුළුවන් Standardized contract එකක් හදනවා. ඒකෙන් වෙනත් developers ලට තමන්ගේ code එක පහසුවෙන් භාවිතා කරන්න පුළුවන් වෙනවා.

Interface vs. Abstract Class – පටලවාගන්න එපා!

ගොඩක් වෙලාවට beginners ලා interfaces සහ abstract classes පටලවා ගන්නවා. මේ දෙකම abstraction achieve කරන්න භාවිතා කරනවා වුණත්, ඒවට තියෙන්නේ වෙනස් purpose. අපි මේ දෙකේ ප්‍රධාන වෙනස්කම් ටිකක් බලමු:

• Multiple Inheritance: Class එකකට interfaces කීපයක් implement කරන්න පුළුවන්. හැබැයි class එකකට extend කරන්න පුළුවන් එක abstract class එකක් විතරයි.
• Variables: Interface එකක තියෙන්නේ public static final constants විතරයි. Abstract class එකක ඕනෑම type එකක variables තියෙන්න පුළුවන්.
• Constructors: Interface එකක constructor එකක් නෑ. Abstract class එකක constructor එකක් තියෙන්න පුළුවන්.
• Method Types: Java 8 කලින් interface එකක තිබ්බේ abstract methods විතරයි. Java 8 ඉඳන් default සහ static methodsත් add වුණා. Abstract class එකක abstract methods වගේම concrete methods (implementation තියෙන methods) තියෙන්නත් පුළුවන්.
• Purpose: Interface එකක් කියන්නේ 'what an object can do' (හැකියාව). Abstract class එකක් කියන්නේ 'what an object is' (වර්ගය). උදාහරණයක් විදියට, Flyable කියන්නේ interface එකක් වෙන්න පුළුවන් (ගුවන් යානයකට Flyable වෙන්න පුළුවන්, කුරුල්ලෙකුට Flyable වෙන්න පුළුවන්). Animal කියන්නේ abstract class එකක් වෙන්න පුළුවන් (බල්ලෙක් Animal කෙනෙක්, බළලෙක් Animal කෙනෙක්).

ඔයාලට මේ දෙකම අවශ්‍යතාවය අනුව පාවිච්චි කරන්න වෙනවා. සාමාන්‍යයෙන්, යම්කිසි behavior එකක් define කරන්න ඕනේ නම් interface එකක් භාවිතා කරන්න. පොදු functionality එකක් share කරන, එකම වර්ගයේ objects group කරන්න ඕනේ නම් abstract class එකක් භාවිතා කරන්න.

අවසානයට...

ඉතින් යාළුවනේ, මේ interfaces කියන concept එක Java වල object-oriented programming වල ගොඩක් වැදගත් කොටසක්. මේවා අපේ code එක flexible, modular, සහ maintainable කරන්න උදව් කරනවා. Polymorphism, multiple inheritance simulation, loose coupling, සහ abstraction achieve කරන්න interfaces නැතුවම බෑ. මේවා හරියටම තේරුම් අරගෙන project වලට apply කරන එකෙන් ඔයාලට professional level වල software හදන්න පුළුවන් වෙනවා.

මම හිතනවා මේ ලිපියෙන් ඔයාලට interfaces ගැන හොඳ අවබෝධයක් ලැබෙන්න ඇති කියලා. හැමදාම වගේ, මේ concept එක ගැන තවදුරටත් explore කරලා, පොඩි පොඩි program ලියලා බලන්න. Practice කරන තරමට තමයි ඕනෑම දේක expert කෙනෙක් වෙන්න පුළුවන්.

මේ ලිපිය ගැන ඔයාලගේ අදහස් පහලින් comment section එකේ කියන්න. තව මොන වගේ topics ගැනද දැනගන්න ඕනේ කියලත් කියන්න. ඔයාලගේ අදහස් අපිට ගොඩක් වටිනවා! ඊළඟ ලිපියෙන් හම්බවෙමු! සුභ දවසක්!