0Pricing
Java Academy · درس

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

افهم الفرق الأساسي بين الأنواع البدائية والأنواع المرجعية في Java

الأنواع البدائية مقابل الأنواع المرجعية درس مجاني في Java Academy على CoddyKit. هذا هو الدرس 1 من أصل 4. يمكنك قراءة الدرس كاملاً أدناه مجاناً — ثم تمرن عليه مباشرة في المتصفح باستخدام محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7. هذا الدرس جزء من مسار التعلم في Java Academy، وتقدمك يتزامن عبر الويب وتطبيق CoddyKit. تتضمن دورة Java Academy 4 دروس في المجموع.

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

يحتوي Java على فئتين أساسيتين من أنواع البيانات: الأنواع البدائية والأنواع المرجعية. ويُعد فهم الفرق بينهما ضرورياً لكتابة شفرة Java صحيحة وفعّالة.

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

يحتوي Java على ثمانية أنواع بدائية تحديداً:

  • byte (عدد صحيح من 8 بت)
  • short (عدد صحيح من 16 بت)
  • int (عدد صحيح من 32 بت)
  • long (عدد صحيح من 64 بت)
  • float (عدد عشري من 32 بت)
  • double (عدد عشري من 64 بت)
  • char (محرف Unicode من 16 بت)
  • boolean (صحيح/خطأ)

تخزّن الأنواع البدائية القيمة مباشرةً في الذاكرة، من دون الحمل الإضافي للكائنات.

int age = 25;
double price = 19.99;
boolean active = true;
char grade = 'A';
long population = 8_000_000_000L;

System.out.println(age);       // 25
System.out.println(price);     // 19.99
System.out.println(active);    // true

الأنواع المرجعية

يخزّن النوع المرجعي عنواناً في الذاكرة (مرجعاً) يشير إلى كائن في الذاكرة المُكدّسة. ويشمل ذلك:

  • الفئات (مثل String وScanner)
  • المصفوفات (مثل int[])
  • الواجهات
  • التعدادات والسجلات

لا يخزّن المتغيّر الكائن نفسه، بل يخزّن مؤشراً إليه.

String name = "Alice";       // reference to a String object
int[] scores = {90, 85, 92}; // reference to an array object

// name holds a reference, not the characters directly
System.out.println(name.length());   // 5
System.out.println(scores.length);   // 3

ذاكرة المكدس مقابل الذاكرة المُكدّسة

تُخزّن المتغيرات البدائية في المكدس، وهو نوع سريع وقصير العمر من الذاكرة يرتبط باستدعاءات الطرائق.

تعيش كائنات الأنواع المرجعية في الذاكرة المُكدّسة، وهي ذاكرة أكبر وأطول عمراً تديرها عملية جمع البيانات المهملة. أما المرجع (العنوان) نفسه فيوجد في المكدس.

// Stack: holds the int value directly
int x = 42;

// Stack: holds reference; Heap: holds the Person object
class Person {
    String name;
    int age;
}

Person p = new Person(); // p is a reference on stack, object on heap
p.name = "Bob";
p.age = 30;

null: المرجع الغائب

يمكن إسناد null إلى المتغيرات المرجعية، ما يعني أنها لا تشير إلى أي كائن. أما الأنواع البدائية فلا يمكن أن تكون null، إذ تملك دائماً قيمة.

يؤدي الوصول إلى مرجع null إلى NullPointerException (NPE)، وهو أحد أكثر أخطاء وقت التشغيل شيوعاً في Java.

String s = null;
// int n = null; // Compile error — primitives can't be null

try {
    System.out.println(s.length()); // NullPointerException!
} catch (NullPointerException e) {
    System.out.println("Caught NPE: reference was null");
}

دلالات النسخ: الأنواع البدائية

عند إسناد متغيّر بدائي إلى متغيّر آخر، ينسخ Java القيمة. ولا يؤثر تغيير أحدهما في الآخر، إذ إنهما مستقلان تماماً.

int a = 10;
int b = a;  // b gets a copy of the value 10

b = 20;     // changing b does NOT affect a

System.out.println(a); // 10
System.out.println(b); // 20

دلالات النسخ: المراجع

عند إسناد متغيّر مرجعي إلى متغيّر آخر، يشير المتغيران إلى الكائن نفسه. ويظهر تعديل الكائن من خلال أحد المرجعين عند الوصول إليه من خلال المرجع الآخر.

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 points to the SAME array

arr2[0] = 99; // modifies the shared array

System.out.println(arr1[0]); // 99 — arr1 sees the change too!
System.out.println(arr2[0]); // 99

الفئات المغلّفة: تغليف الأنواع البدائية

لكل نوع بدائي فئة مغلّفة مقابلة في java.lang:

  • int → Integer
  • double → Double
  • boolean → Boolean
  • char → Character

تتيح لكم الفئات المغلّفة استخدام الأنواع البدائية ككائنات، وهو أمر مطلوب لمجموعات مثل List<Integer>.

Integer boxed = Integer.valueOf(42); // explicit boxing
int unboxed = boxed.intValue();       // explicit unboxing

// Autoboxing / auto-unboxing (Java does this automatically)
Integer auto = 100;  // autoboxed
int val = auto;      // auto-unboxed

System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Double.MIN_VALUE);   // 5.0E-324

مخاطر التغليف التلقائي

يُعد التغليف التلقائي مريحاً، لكنه قد يسبب أخطاء دقيقة. إذ يخزّن Integer القيم من -128 إلى 127 مؤقتاً؛ وخارج هذا النطاق، تقارن == المراجع لا القيم.

استخدموا دائماً .equals() لمقارنة الكائنات المغلّفة.

Integer a = 127;
Integer b = 127;
System.out.println(a == b);      // true (cached)

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false (different objects!)
System.out.println(c.equals(d)); // true (correct comparison)

تمرير القيم إلى الطرائق: التمرير بالقيمة

يستخدم Java دائماً التمرير بالقيمة. بالنسبة إلى الأنواع البدائية، تُنسخ القيمة. أما بالنسبة إلى المراجع، فيُنسخ المرجع (العنوان)، فيشير كلاهما إلى الكائن نفسه، لكن لا يمكنكم إعادة إسناد متغيّر المستدعي من داخل الطريقة.

static void doubleValue(int n) {
    n = n * 2; // only modifies the local copy
}

static void clearArray(int[] arr) {
    arr[0] = 0; // modifies the shared object
}

int x = 5;
doubleValue(x);
System.out.println(x); // still 5

int[] nums = {10, 20, 30};
clearArray(nums);
System.out.println(nums[0]); // 0 — object was mutated

جدول الملخص العملي

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

  • التخزين: البدائي → قيمة في المكدس؛ المرجعي → عنوان في المكدس + كائن في الذاكرة المُكدّسة
  • القيمة الافتراضية: البدائي → 0/false/\u0000؛ المرجعي → null
  • هل يمكن أن يكون null: البدائي → لا؛ المرجعي → نعم
  • ما تنسخه عملية الإسناد: البدائي → القيمة؛ المرجعي → العنوان
  • في المجموعات: تحتاج الأنواع البدائية إلى فئات مغلّفة

فحص سريع

ماذا يحدث عند تنفيذ الشفرة التالية؟

Integer x = 200;
Integer y = 200;
System.out.println(x == y);

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

أهم النقاط المستخلصة من هذا الدرس:

  • يحتوي Java على 8 أنواع بدائية تُخزّن مباشرةً في المكدس
  • تخزّن الأنواع المرجعية عنوان كائن في الذاكرة المُكدّسة؛ ويحتفظ المتغيّر بالعنوان
  • تُنسخ الأنواع البدائية بالقيمة، بينما تُنسخ المراجع بالعنوان
  • يمكن أن تكون المتغيرات المرجعية null، ولا يمكن للأنواع البدائية ذلك
  • تغلّف الفئات المغلّفة (Integer وDouble وغيرهما) الأنواع البدائية في صورة كائنات
  • يستخدم Java دائماً التمرير بالقيمة، حتى عند تمرير المراجع

الأسئلة الشائعة

هل درس «الأنواع البدائية مقابل الأنواع المرجعية» مجاني؟

نعم — نص درس «الأنواع البدائية مقابل الأنواع المرجعية» كامل متاح مجاناً هنا على الويب. لتمرينه بشكل تفاعلي (محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7) وفتح باقي دورة Java Academy، انتقل إلى CoddyKit PRO. تتضمن دورة Java Academy 4 دروس في المجموع.

ماذا ستتعلم في «الأنواع البدائية مقابل الأنواع المرجعية»؟

افهم الفرق الأساسي بين الأنواع البدائية والأنواع المرجعية في Java تتمرن على Java Academy مع أكواد عملية تشغلها مباشرة في المتصفح، ومدرس ذكاء اصطناعي متاح 24/7 يجيب على أسئلتك أثناء عملك.

هل أحتاج إلى خبرة سابقة لأبدأ Java Academy؟

لا تُشترط خبرة سابقة. Java Academy على CoddyKit منظم للمبتدئين حتى المتقدمين، لذا يمكنك البدء من هنا أو من البداية والتقدم بسرعتك الخاصة. هذا هو الدرس 1 من أصل 4.

كم من الوقت يستغرق درس «الأنواع البدائية مقابل الأنواع المرجعية»؟

معظم دروس CoddyKit تستغرق حوالي 5–10 دقائق. كل منها موجز وتفاعلي، لذا تحرز تقدماً مستمراً وتستأنف من حيث توقفت عبر الويب والتطبيق.

هل يمكنني كتابة وتشغيل أكواد في درس Java Academy هذا؟

نعم. كل درس في Java Academy يتضمن محرر أكواد مدمج، لذا تكتب وتشغل أكواداً حقيقية مباشرة في متصفحك وتحصل على تعليقات فورية من الذكاء الاصطناعي — بدون إعداد محلي.

جميع الدروس في هذه الدورة

  1. الأنواع البدائية مقابل الأنواع المرجعية
  2. تحويلات التوسيع والتضييق
  3. العامل instanceof
  4. تحويل الأنواع عمليًا
← العودة إلى Java Academy