أصناف جافا: تعريف الحقول والدوال والكائنات

الصنف مخطط

حتى الآن كانت شيفرتك تعيش داخل دوال تتبادل قيمًا بسيطة فيما بينها. يتيح لك الصنف أن تجمع البيانات المترابطة والسلوك الذي يعمل عليها في نوع واحد يحمل اسمًا. الصنف هو المخطط، أمّا الأشياء الفعلية التي تتعامل معها فهي الكائنات المنشأة منه.

يُعلِن الصنف نوعين من الأعضاء: الحقول (البيانات التي يحملها كل كائن) والدوال (ما يستطيع كل كائن فعله).

class Dog {
    String name;          // حقل: كل Dog له اسم
    int age;              // حقل آخر

    void bark() {         // دالة: سلوك يمتلكه كل Dog
        System.out.println(name + " says woof!");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog();    // أنشئ كائنًا من المخطط
        d.name = "Rex";       // عيّن حقوله
        d.age = 3;
        d.bark();             // استدعِ دالته
    }
}

يبني new Dog() كائنًا في الذاكرة ويمنحك مرجعًا إليه. ويصل d.name وd.bark() إلى ذلك الكائن المحدّد.

لكل كائن حالته الخاصة

جوهر الصنف هو أنّك تستطيع إنتاج كائنات مستقلة كثيرة، يحمل كلٌّ منها قيم حقوله الخاصة. تغيير أحدها لا يمسّ الآخر أبدًا.

class Dog {
    String name;

    void bark() {
        System.out.println(name + " barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog rex = new Dog();
        rex.name = "Rex";

        Dog bella = new Dog();
        bella.name = "Bella";

        rex.bark();     // Rex barks
        bella.bark();   // Bella barks
    }
}

rex وbella كائنان منفصلان. لكلٍّ منهما حقل name خاص به، لذا يطبع كل استدعاء لـ bark() قيمة مختلفة. تُسمّى هذه البيانات الخاصة بكل كائن حالة النسخة.

الحقول والدوال تعمل معًا

تستطيع الدوال داخل الصنف أن تقرأ حقول الكائن نفسه وتحدّثها مباشرة، دون الحاجة إلى تمريرها كمُعامِلات. فالدالة "تعيش أصلًا على" الكائن الذي تمسّ بياناته.

class Counter {
    int count;            // يبدأ من 0 افتراضيًا

    void increment() {
        count++;          // يحدّث حقل هذا الكائن
    }

    int value() {
        return count;
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        c.increment();
        c.increment();
        System.out.println(c.value());   // 3
    }
}

لاحظ أنّ increment() لا تأخذ أيّ وسائط. إنّها تعمل على الحقل العائد إلى الـ Counter الذي استدعيتها عليه. هذا هو الفرق بين دالة الصنف والدالة الساكنة المستقلة: للدالة كائن ضمني تعمل عليه.

الكلمة المفتاحية this

داخل الدالة، this مرجع إلى الكائن الذي استُدعيت الدالة عليه. عادةً لا تحتاج إليها، فكتابة count تعني this.count بالفعل. لكنّ this تصبح ضرورية عندما يتعارض اسم مُعامِل مع اسم حقل، وهو ما يحدث باستمرار في دوال الضبط والبنّاءات.

class Point {
    int x;
    int y;

    void move(int x, int y) {
        this.x = x;       // this.x هو الحقل؛ x هو المُعامِل
        this.y = y;
    }

    void show() {
        System.out.println("(" + x + ", " + y + ")");
    }
}

public class Main {
    public static void main(String[] args) {
        Point p = new Point();
        p.move(4, 7);
        p.show();         // (4, 7)
    }
}

من الأخطاء الشائعة لدى المبتدئين كتابة x = x; داخل move. هذا يسند المُعامِل إلى نفسه فقط ويترك الحقل دون مساس: لن يحذّرك المترجم، وسيحتفظ كائنك بقيمه القديمة بصمت. أمّا this.x = x; فهو ما يحدّث الحقل فعليًا.

القيم الافتراضية للحقول والمراجع null

عندما تنشئ كائنًا، لا تبقى حقوله بقيم عشوائية، بل تهيّئها جافا بقيم افتراضية: 0 للأعداد، وfalse لـ boolean، وnull لمراجع الكائنات مثل String. هذه القيمة الافتراضية null هي مصدر انهيار كلاسيكي.

class User {
    String name;          // غير مُعيَّن، لذا قيمته الافتراضية null
}

public class Main {
    public static void main(String[] args) {
        User u = new User();
        System.out.println(u.name.length());   // NullPointerException
    }
}

قيمة u.name هي null لأنّ أحدًا لم يضبطها، لذا فإنّ استدعاء .length() عليها يرمي NullPointerException. أسنِد دائمًا قيمًا ذات معنى إلى الكائن قبل استخدام حقوله، وهذه بالضبط المشكلة التي تحلّها البنّاءات.

تنظيم الشيفرة حول الأصناف

تنمذج البرامج الحقيقية مجالها كأصناف تجمع البيانات والعمليات التي تطرأ عليها معًا. هنا يحتفظ صنف BankAccount واحد برصيد ويضبط كيفية تغيّره:

class BankAccount {
    String owner;
    double balance;

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;     // رصيد غير كافٍ
    }
}

public class Main {
    public static void main(String[] args) {
        BankAccount acc = new BankAccount();
        acc.owner = "Sam";
        acc.deposit(100.0);
        boolean ok = acc.withdraw(30.0);

        System.out.println(acc.owner + " balance: " + acc.balance);  // 70.0
        System.out.println("withdrawal succeeded: " + ok);
    }
}

تعيش البيانات (balance) وقواعد تغييرها (deposit وwithdraw) في مكان واحد. وتطلب الشيفرة في مواضع أخرى من الحساب أن يقوم بأشياء بدلًا من العبث بأرقامه مباشرة، وهذا أساس التصميم النظيف القابل للصيانة.

التالي: البنّاءات

ضبط كل حقل يدويًا بعد new أمر مُمِلّ وسهل النسيان، وكما رأيت للتو، فإنّ حقلًا منسيًّا يترك null ينتظر ليسبّب انهيارًا. يتيح لك البنّاء أن تشترط حقول الكائن وتهيّئها في لحظة إنشائه نفسها، بحيث لا يمكن أن يوجد BankAccount أبدًا دون مالك. هذا هو موضوع الصفحة التالية.