أنواع البيانات في جافا: الأنواع البدائية وأنواع المرجع والقيم الافتراضية

عائلتان: الأنواع البدائية وأنواع المرجع

لكل قيمة في جافا نوع، وهذا النوع يقع ضمن إحدى عائلتين. الأنواع البدائية تخزّن قيمة خامًا مباشرةً - عددًا، أو حرفًا واحدًا، أو صحيحًا/خطأ. أما أنواع المرجع فتخزّن مرجعًا (مؤشرًا) إلى كائن يقيم في مكان آخر من الذاكرة: String، والمصفوفات، وكل صنف تُعرّفه أنت أو المكتبات.

هذا التمييز مهم لأن الأنواع البدائية خفيفة وتُنسخ بالقيمة، بينما تشير متغيرات المرجع إلى كائنات مشتركة. ابدأ بالأنواع البدائية الثمانية - فهي الأساس الذي يُبنى عليه كل ما سواها.

الأنواع البدائية الثمانية

تحتوي جافا على ثمانية أنواع بدائية مدمجة بالضبط. ستة منها أعداد، وواحد حرف، وواحد قيمة منطقية:

public class Main {
    public static void main(String[] args) {
        byte   b = 100;          // عدد صحيح بـ 8 بت,  -128 .. 127
        short  s = 30000;        // عدد صحيح بـ 16 بت
        int    i = 2_000_000;    // عدد صحيح بـ 32 بت (الافتراضي للأعداد الصحيحة)
        long   big = 9_000_000_000L; // عدد صحيح بـ 64 بت - لاحظ الحرف L

        float  f = 3.14f;        // عدد عشري بـ 32 بت - لاحظ الحرف f
        double d = 3.141592653589793; // عدد عشري بـ 64 بت (الافتراضي للأعداد العشرية)

        char   c = 'A';          // حرف يونيكود واحد بـ 16 بت
        boolean flag = true;     // قيمة true أو false فقط

        System.out.println(b + " " + s + " " + i + " " + big);
        System.out.println(f + " " + d);
        System.out.println(c + " " + flag);
    }
}

بضعة أمور ينبغي ملاحظتها منذ البداية: الشُّرَط السفلية في 2_000_000 مجرد فواصل بصرية يتجاهلها المُترجِم، واللاحقتان L وf إلزاميتان (المزيد عن ذلك أدناه)، وchar يستخدم علامتي اقتباس مفردتين بينما يستخدم String علامتي اقتباس مزدوجتين.

اختيار نوع رقمي

نادرًا ما تحتاج إلى byte أو short - فهما لا يوفّران الذاكرة إلا في المصفوفات الضخمة. القرارات الحقيقية تكون بين int/long للأعداد الصحيحة وfloat/double للأعداد العشرية.

النوع	الحجم	استخدمه عندما
int	32 بت	الافتراضي للأعداد الصحيحة (حتى نحو 2.1 مليار)
long	64 بت	القيم التي تتجاوز نحو ملياري وحدة: الطوابع الزمنية بالمللي ثانية، أحجام الملفات
double	64 بت	الافتراضي للأعداد العشرية - دقة جيدة
float	32 بت	فقط عندما تكون الذاكرة شحيحة ويمكن التضحية بالدقة

الفخّ هو الفيضان (overflow). يلتفّ int بصمت عندما يتجاوز نطاقه - بلا أي خطأ، بل مجرد إجابة خاطئة:

public class Main {
    public static void main(String[] args) {
        int maxInt = Integer.MAX_VALUE; // 2147483647
        System.out.println(maxInt);
        System.out.println(maxInt + 1); // يلتفّ إلى عدد سالب!

        long safe = (long) maxInt + 1;  // نرفعه إلى long أولًا
        System.out.println(safe);
    }
}

يفيض maxInt + 1 إلى -2147483648 لأن كلا المعاملَين من النوع int وتبقى النتيجة من النوع int. أما تحويل أحد الطرفين إلى long أولًا فيُجري الحساب بـ 64 بت. عندما يُحتمل أن تكون القيمة كبيرة - خصوصًا المللي ثوانٍ منذ عام 1970 - فالجأ إلى long.

الحرفيات ولواحقها

للحرفي الرقمي المجرّد نوع افتراضي، وهذا ما يوقع الناس في الخطأ. الرقم 100 هو int، والرقم 3.14 هو double. ولكتابة حرفي long أو float يجب أن تضيف لاحقة:

public class Main {
    public static void main(String[] args) {
        long population = 8_000_000_000L; // من دون L يكون هذا أكبر من أن يتسع لـ int -> خطأ
        float ratio = 0.5f;               // من دون f يكون الطرف الأيمن من النوع double -> خطأ
        double pi = 3.14;                 // لا بأس - الأعداد العشرية هي double افتراضيًا

        System.out.println(population);
        System.out.println(ratio + " " + pi);
    }
}

احذف الحرف L من 8_000_000_000L ولن تُترجَم الشيفرة، لأن الحرفي يتجاوز نطاق int قبل أن يصل أصلًا إلى متغير long. واحذف الحرف f من 0.5f فتشتكي جافا من أنه لا يمكن إسناد قيمة double إلى float من دون تحويل صريح. اللاحقة لا تفرّق بين الأحرف الكبيرة والصغيرة، لكن استخدم الحرف الكبير L - فالحرف الصغير l يشبه الرقم 1 تمامًا.

char عددٌ متنكّر

يخزّن char وحدة ترميز يونيكود بـ 16 بت، ما يعني أنه يؤدي أيضًا دور عدد صحيح صغير بلا إشارة. يمكنك إجراء عمليات حسابية عليه وتحويله ذهابًا وإيابًا عبر التحويل الصريح (cast):

public class Main {
    public static void main(String[] args) {
        char letter = 'A';
        int code = letter;          // 65 - قيمة يونيكود للحرف 'A'
        char next = (char) (letter + 1); // 'B'

        System.out.println(code);
        System.out.println(next);
    }
}

هذا مفيد أحيانًا لإزاحة الأحرف، لكن لا تعتمد عليه في معالجة النصوص - فلهذا الغرض وُجد String. لاحظ أن char يستخدم علامتي اقتباس مفردتين ('A')؛ أما علامتا الاقتباس المزدوجتان ("A") فتُنشئان String بحرف واحد، وهو نوع مختلف تمامًا.

القيم الافتراضية (وفخّ المتغيرات المحلية)

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

public class Main {
    static int counter;        // حقل -> القيمة الافتراضية 0
    static boolean ready;      // حقل -> القيمة الافتراضية false
    static String name;        // حقل -> القيمة الافتراضية null

    public static void main(String[] args) {
        System.out.println(counter); // 0
        System.out.println(ready);   // false
        System.out.println(name);    // null

        int[] nums = new int[3];     // عناصر المصفوفة قيمتها الافتراضية 0
        System.out.println(nums[0]); // 0
    }
}

لو كتبت بدلًا من ذلك int x; System.out.println(x); داخل main، لرفضها المُترجِم بالرسالة "variable x might not have been initialized". هذه الصرامة ميزة - فهي تمنعك من قراءة قيم عشوائية. القيم الافتراضية الجديرة بالتذكّر: الأنواع الرقمية 0، وboolean تساوي false، وchar تساوي ' '، وكل نوع مرجع يساوي null.

التالي: Strings

String هو نوع المرجع الذي ستتعامل معه أكثر من غيره - النصوص، والقيم المدمجة، ومدخلات المستخدم. وهو يتصرف بشكل مختلف عن الأنواع البدائية المذكورة هنا: فهو كائن، وهو غير قابل للتغيير (immutable)، ولمقارنة النصوص مزالقها الخاصة. الصفحة التالية تتناوله.