Java Packages: කෝඩ් සිස්ටම් එක සංවිධානය කරමු! SC Guide

ආයුබෝවන් යාළුවනේ, කොහොමද ඉතින්? Tech ලෝකේ දවසින් දවස අලුත් දේවල් එකතු වෙනවා. විශේෂයෙන්ම අපි වගේ Software Engineers ලා විදියට, දවසින් දවස Code ලියන අපිට, ලොකු Project එකක් කරද්දි එහෙම කෝඩ් ටික organize කරගන්න එක ලොකු අභියෝගයක් වෙනවා, නේද? සමහර වෙලාවට Code එක දැක්කම ඔළුව අවුල් වෙන්නත් පුළුවන්. "මේක කොහෙද තියෙන්නේ?", "මේ class එකේ නම වෙන class එකකත් තියෙනවද?" වගේ ප්‍රශ්න එන්න පුළුවන්.

හැබැයි මේකට Java වල සුපිරිම විසඳුමක් තියෙනවා – ඒ තමයි Packages. හරියට අපේ ගෙදර තියෙන රාක්ක වගේ, නැත්නම් පොත් වර්ග කරලා තියෙන අල්මාරියක් වගේ, මේ Packages කියන්නේ අපේ Java Source Code එක පිළිවෙලට, ලස්සනට වර්ග කරලා තියන්න පුළුවන් ක්‍රමයක්. ඒකෙන් අපිට Code එක ලේසියෙන් හොයාගන්න, Manage කරන්න, තව කට්ටිය එක්ක Share කරන්න පුළුවන් වෙනවා.

අද අපි මේ ලිපියෙන් කතා කරන්නේ Java Packages කියන්නේ මොනවද? ඒවා ඇයි අපිට වැදගත් වෙන්නේ? ඒවා හදාගන්නේ කොහොමද? ඒ වගේම ඒවා පාවිච්චි කරන්නේ කොහොමද කියන එක ගැන. ඉතින්, කෝපි කප් එකක් එහෙම අරන් ලෑස්ති වෙන්න, අද අපි Java Packages ගැන මුල ඉඳලම ඉගෙන ගමු!

Java Packages කියන්නේ මොනවද?

සරලවම කියනවනම්, Java Package එකක් කියන්නේ එකිනෙකට සම්බන්ධ Classes, Interfaces, Enums සහ Annotations එක තැනකට එකතු කරන group එකක්. මේක හරියට Computer එකේ Files organize කරන්න අපි Folders පාවිච්චි කරනවා වගේ වැඩක්. අපි Folder එකක් ඇතුළේ ඒකට අදාළ Files ටික දානවා වගේම, Package එකක් ඇතුළේ ඒකට අදාළ Java Code Files (Classes, etc.) ටික දානවා.

Java වල මේ Packages හඳුන්වන්න package කියන keyword එක පාවිච්චි කරනවා. හැම Java Source File එකකම මුලින්ම Package එක declare කරන්න ඕනේ (අපි unnamed package එකක් පාවිච්චි කරනවා නම් ඇරෙන්න). ඒක මෙහෙමයි පේන්නේ:

package com.mycompany.myapp.model;

// මෙතනින් පස්සේ ඔයාගේ Class එක පටන් ගන්නවා
public class User {
    // ... class content ...
}

උඩ තියෙන උදාහරණයේ com.mycompany.myapp.model කියන්නේ Package Name එක. මේක හරියට Domain Name එකක් වගේ reverse කරලා තමයි Naming Convention එක විදියට පාවිච්චි කරන්නේ. මේ Package Name එකට Full Qualified Name (FQN) කියලා කියනවා. ඒ කියන්නේ Package එකේ නම සහ Class එකේ නම එකතු කරාම සම්පූර්ණ නම හැදෙනවා. උදාහරණයක් විදියට, User කියන Class එකේ FQN එක වෙන්නේ com.mycompany.myapp.model.User.

පැකේජ් පාවිච්චි කරන්නේ ඇයි? (Benefits)

හරි, දැන් Packages කියන්නේ මොනවද කියලා පොඩි අවබෝධයක් ලැබුණානේ. දැන් බලමු ඇයි අපි මේවා පාවිච්චි කරන්න ඕනේ කියලා. මේකෙන් ලැබෙන ප්‍රධාන වාසි 3ක් තියෙනවා:

Naming Conflicts නැතිකරන්න

මේක තමයි Package පාවිච්චි කරන්න තියෙන ලොකුම හේතුවක්. හිතන්නකෝ, ඔයා ලොකු Project එකක් කරනවා කියලා. ඒකෙදි Librarys ගොඩක් පාවිච්චි කරනවා. දැන් එක Library එකක Date කියන නමින් Class එකක් තියෙනවා. තව Library එකකත් Date කියන නමින්ම තව Class එකක් තියෙනවා. මේ දෙකම ඔයාගේ Project එකට ගත්තම Java Compilier එකට තේරෙන්නේ නැහැ ඔයාට ඕනේ මොන Date Class එකද කියලා. එතකොට Code එක Compile කරද්දි Error එනවා.

හැබැයි Packages පාවිච්චි කරනකොට මේ ප්‍රශ්නය විසඳෙනවා. මොකද හැම Class එකකටම unique FQN එකක් තියෙනවා. ඒ නිසා අපි java.util.Date සහ java.sql.Date වගේ FQN එක එක්ක Class එක specify කරන්න පුළුවන්. එතකොට Java Compilier එකට හරියටම තේරෙනවා ඔයාට ඕනේ මොන Class එකද කියලා. මේක හරියට එකම නමේ යාළුවෝ දෙන්නෙක් ඉන්නකොට, එක්කෙනෙක්ව "කොළඹ ඉන්න සනත්" අනිත් එක්කෙනාව "ගාල්ලේ ඉන්න සනත්" කියලා අඳුරගන්නවා වගේ වැඩක්.

Access Control

Packages වලින් අපිට Class වලට සහ ඒවායේ Members (Methods, Variables) වලට Access Control කරන්න පුළුවන්. ඒ කියන්නේ, Package එකකින් එළියේ තියෙන Classes වලට අපි හදපු Class එකේ Method එකකට Access වෙන්න දෙනවද නැද්ද කියලා අපිට පාලනය කරන්න පුළුවන්. මේ සඳහා අපි public, protected, default (package-private) කියන Access Modifiers පාවිච්චි කරනවා.

• public: ඕනෑම තැනක ඉඳන් Access කරන්න පුළුවන්.
• protected: එකම Package එක ඇතුළේ සහ Subclasses වලට Access කරන්න පුළුවන්.
• default (package-private): එකම Package එක ඇතුළේ විතරක් Access කරන්න පුළුවන්.
• private: Class එක ඇතුළේ විතරක් Access කරන්න පුළුවන් (Packages එක්ක කෙලින්ම සම්බන්ධ නැතත්, මෙයත් Access Modifier එකක්).

මේ Access Control එක නිසා අපිට අපේ Code එකේ Internal Implementation එක හංගලා, අවශ්‍ය දේ විතරක් එළියට expose කරන්න පුළුවන් වෙනවා. මේක Software එකක ආරක්ෂාවටත්, Maintainability එකටත් ගොඩක් වැදගත්.

Modularity and Maintainability

විශාල Project එකකදී Code එක මොඩියුලර් (Modular) විදියට තියාගන්න Packages මාරම වැදගත්. හිතන්නකෝ, ඔයාගේ Project එකේ User Management, Product Catalog, Order Processing වගේ වෙනස් Modules තියෙනවා කියලා. මේ හැම Module එකකටම වෙනම Package එකක් හදලා, ඒකට අදාළ Classes ටික ඒ Package එක ඇතුළට දාන්න පුළුවන්.

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

• com.myapp.user Package එකේ User Login, Registration වගේ දේවල් තියෙන්න පුළුවන්.
• com.myapp.product Package එකේ Product Details, Inventory Management වගේ දේවල් තියෙන්න පුළුවන්.
• com.myapp.order Package එකේ Order Creation, Order Tracking වගේ දේවල් තියෙන්න පුළුවන්.

මේ විදියට Code එක Organize කරාම, අලුතින් Project එකට එන Developer කෙනෙක්ට වුණත් Code එකේ Structure එක ලේසියෙන් තේරුම් ගන්න පුළුවන්. ඒ වගේම, මොකක් හරි Bug එකක් හරි Feature එකක් හරි හදන්න ඕනේ වුණොත්, අදාළ Package එකට ගිහින් ඉක්මනටම අවශ්‍ය Code එක හොයාගන්න පුළුවන්. Project එකේ Scalability එකටත් මේක ගොඩක් හොඳයි. මොකද එක Module එකක වෙනසක් කරා කියලා මුළු Project එකටම බලපාන්නේ නැහැ.

පැකේජ් හදමු! (Creating Packages)

Java වල Package එකක් හදන එක ඇත්තටම මාරම ලේසි වැඩක්. ඔයාට කරන්න තියෙන්නේ ඔයාගේ Source File එකේ (.java file) මුලින්ම package කියන keyword එකත් එක්ක Package Name එක දාන එක විතරයි. හැබැයි මේක අපි file system එකේ organize කරන විදියට බලපානවා. අපි දැන් උදාහරණයක් බලමු:

හිතන්න අපිට com.example.ecommerce.model කියන Package එක හදන්න ඕනේ කියලා. ඒක ඇතුළේ Product.java කියන Class එකක් හදන්න ඕනේ.

මුලින්ම, ඔයාගේ Project Folder එක ඇතුළේ මේ Folder Structure එක හදාගන්න:

/MyProject
    /src
        /com
            /example
                /ecommerce
                    /model
                        Product.java

දැන්, Product.java කියන File එක මේ විදියට ලියන්න:

// Product.java file

package com.example.ecommerce.model; // මෙන්න මෙතනින් තමයි Package එක declare කරන්නේ

public class Product {
    private String name;
    private double price;

    public Product(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "Product [Name: " + name + ", Price: " + price + "]";
    }
}

මේ Class එක Run කරන්න නම් අපිට Main Method එකක් ඕනේ. ඒක වෙන Package එකක හදමු. com.example.ecommerce.app කියන Package එක ඇතුළේ App.java කියන Class එකක් හදමු.

/MyProject
    /src
        /com
            /example
                /ecommerce
                    /app
                        App.java
                    /model
                        Product.java

Import Statement එක! (Using Packages)

හරි, දැන් අපි Product Class එක com.example.ecommerce.model Package එකේ හදලා ඉවරයි. දැන් අපිට මේ Product Class එක App.java කියන Class එක ඇතුළේ පාවිච්චි කරන්න ඕනේ නම්, අපි ඒක Import කරන්න ඕනේ. මේකට import කියන keyword එක පාවිච්චි කරනවා.

App.java file එක මෙහෙම ලියමු:

// App.java file

package com.example.ecommerce.app; // App Class එකේ Package එක

import com.example.ecommerce.model.Product; // මෙන්න මෙතනින් Product Class එක import කරනවා

public class App {
    public static void main(String[] args) {
        // Product Class එක දැන් අපිට කෙලින්ම නම විතරක් දීලා පාවිච්චි කරන්න පුළුවන්
        Product product1 = new Product("Laptop", 1200.00);
        Product product2 = new Product("Mouse", 25.50);

        System.out.println(product1);
        System.out.println(product2);

        // අපි import කරලා නැත්නම් Product Class එක පාවිච්චි කරන්න ඕනේ මෙහෙමයි:
        // com.example.ecommerce.model.Product product3 = new com.example.ecommerce.model.Product("Keyboard", 75.00);
        // System.out.println(product3);
    }
}

import com.example.ecommerce.model.Product; කියන Line එකෙන් කියන්නේ "com.example.ecommerce.model Package එකේ තියෙන Product Class එක මට මේ File එක ඇතුළේ පාවිච්චි කරන්න අවසර දෙන්න" කියන එකයි. මේක කරාම අපිට Product කියලා කෙලින්ම නම දීලා Class එක පාවිච්චි කරන්න පුළුවන්. නැත්නම් හැම වෙලාවෙම com.example.ecommerce.model.Product කියලා සම්පූර්ණ නම ලියන්න වෙනවා. ඒක ටිකක් අමාරුයි, නේද?

තව දෙයක්, java.lang කියන Package එක Java වල හැම විටම Default Import වෙනවා. ඒක නිසා තමයි අපිට System.out.println() කියන එකේ System Class එක Import නොකර පාවිච්චි කරන්න පුළුවන්. System Class එක තියෙන්නේ java.lang Package එකේ.

Wildcard Imports (*)

සමහර වෙලාවට, අපිට එකම Package එකකින් Classes ගොඩක් Import කරන්න වෙනවා. එතකොට අපිට එකින් එක Import කරනවා වෙනුවට * (asterisk) එක පාවිච්චි කරන්න පුළුවන්. උදාහරණයක් විදියට, java.util Package එකේ තියෙන හැම Class එකක්ම Import කරන්න නම්:

import java.util.*; // මේකෙන් java.util Package එකේ හැම Class එකක්ම import වෙනවා

public class Example {
    public static void main(String[] args) {
        java.util.ArrayList<String> list = new java.util.ArrayList<>(); // ArrayList now directly available
        java.util.Scanner scanner = new java.util.Scanner(System.in); // Scanner now directly available
        // ...
    }
}

හැබැයි මතක තියාගන්න, import java.util.* කියන එකෙන් java.util.concurrent වගේ Sub-Package එකක තියෙන Classes Import වෙන්නේ නැහැ. Sub-Package එකක Classes Import කරන්න නම් ඒ Package එකත් වෙනම Import කරන්න ඕනේ.

Static Imports

Java 5 වලින් පස්සේ static import කියන Concept එක ආවා. මේකෙන් පුළුවන් Class එකක තියෙන static members (static methods, static variables) කෙලින්ම Class Name එක නැතුව පාවිච්චි කරන්න. උදාහරණයක් විදියට, System.out.println() කියන එකේ System.out කියන එක වෙනුවට out.println() කියලා ලියන්න පුළුවන්:

import static java.lang.System.out; // System Class එකේ out කියන static variable එක import කරනවා

public class StaticImportExample {
    public static void main(String[] args) {
        out.println("Hello from static import!"); // System.out.println() වෙනුවට
        out.println("This is much shorter.");
    }
}

static import එකෙන් Code එක කෙටි කරගන්න පුළුවන් වුණත්, ඕනවට වඩා පාවිච්චි කරන එකෙන් Code එක කියවන්න අමාරු වෙන්න පුළුවන්. ඒ නිසා අවශ්‍ය තැන්වල විතරක් පාවිච්චි කරන එක තමයි හොඳ.

ප්‍රායෝගික උදාහරණ සහ ටිප්ස්

Naming Conventions

පැකේජ් නම් කරනකොට හොඳ Naming Conventions පාවිච්චි කරන එක ගොඩක් වැදගත්. Java වල Standard එක තමයි Domain Name එක reverse කරලා පාවිච්චි කරන එක. ඒ කියන්නේ example.com කියන Domain එකක් තියෙනවා නම්, Package එක පටන් ගන්න ඕනේ com.example කියලා. ඊට පස්සේ Project එකේ Module එක අනුව, com.example.myproject.module වගේ නමක් දෙනවා.

• හැම අකුරක්ම Small Letters වලින් (lowercase).
• බහු වචන (plural) වලින් නම් නොකරන්න (e.g., models, controllers වෙනුවට model, controller).
• අංක වලින් පටන් ගන්න එපා.
• Short, descriptive names.

උදාහරණ: com.mycompany.project.utility, org.apache.commons.io.

Unnamed Packages

අපි Package declaration එකක් නොකර Class එකක් ලිව්වොත්, ඒක unnamed package එකකට අයත් වෙනවා. මේක කුඩා, සරල Programs වලට ප්‍රශ්නයක් නැති වුණත්, ලොකු Project වලට නම් මේක කිසිසේත්ම හොඳ පුරුද්දක් නෙවෙයි. මොකද Naming Conflicts වගේ ප්‍රශ්න එන්න පුළුවන්.

IDE Support

IntelliJ IDEA, Eclipse, VS Code වගේ Integrated Development Environments (IDEs) වලින් Packages හසුරුවන එක මාරම ලේසි කරනවා. ඔයාට පුළුවන් IDE එක ඇතුළේ New Package කියලා හදන්න. එතකොට IDE එකෙන් අදාළ Folder Structure එක සහ Package declaration එක automatically දාලා දෙනවා. ඒ වගේම, අවශ්‍ය Classes Import කරන්නත් IDE එකෙන් Suggestion දෙනවා. මේ නිසා වැඩේ ගොඩක් වේගවත් වෙනවා.

Build Tools and Packages

Maven, Gradle වගේ Build Tools පාවිච්චි කරනකොටත් Packages මාරම වැදගත්. මේ Tools වලින් Source Code, Resources, Test Files වගේ දේවල් Organize කරන්න Standard Directory Layout එකක් පාවිච්චි කරනවා. ඒකත් Package Structure එකට අනුකූලව තමයි හැදෙන්නේ. ඒ නිසා Project එක Build කරන එක, Dependency Management එක වගේ දේවල් මාරම ලේසි වෙනවා.

නිගමනය

ඉතින් යාළුවනේ, දැන් ඔයාලට පැහැදිලියි නේද Java Packages කියන්නේ මොනවද? ඒවා ඇයි අපිට වැදගත් වෙන්නේ? ඒවා කොහොමද පාවිච්චි කරන්නේ කියලා. සාරාංශයක් විදියට කිව්වොත්, Packages කියන්නේ අපේ Java Code එක ලස්සනට, පිළිවෙලට, කාර්යක්ෂමව organize කරගන්න තියෙන සුපිරිම මෙවලමක්. Naming Conflicts වලින් බේරෙන්න, Code එකේ Access Control කරන්න, ඒ වගේම Project එකේ Modularity එක සහ Maintainability එක වැඩි කරන්න Packages නැතුවම බැහැ.

ඔයාලා දැන්මම මේ Concept එක ඔයාගේ පොඩි Project එකක හරි Implement කරලා බලන්න. එතකොට තව දුරටත් පැහැදිලි වෙයි. මතක තියාගන්න, හොඳින් organize කරපු Code එකක් කියන්නේ හොඳ Software Developer කෙනෙක්ගේ ලක්ෂණයක්.

මේ ලිපිය ගැන ඔයාගේ අදහස්, ප්‍රශ්න, යෝජනා පහළින් comment එකක් දාලා යන්න. තවත් මේ වගේ Tech ලිපි වලින් හමුවෙමු. එතකන් හැමෝටම ජයවේවා!