تقدير المشروع
← كل المقالات

Java 27: الأنواع الأولية في الأنماط وinstanceof وswitch

اطّلع على كيف يجلب Java 27 الأنواع الأولية إلى instanceof وswitch، مما يجعل الشيفرة أسهل قراءة

4 دقائق قراءة
Javauncoverjavaمطابقة الأنماطswitch

كل ستة أشهر يصل إصدار Java جديد وطازج ولذيذ. وهذه المرة هو Java 27، وسنستعرض في هذا المقال JEP-532، الذي يجلب الأنواع الأولية إلى الأنماط وinstanceof وswitch. وتذكّر أنها ميزة معاينة (preview).

قد يبدو عنوان JEP كأنه يقول كل شيء، لكن من المفيد التعمق قليلًا.

ملاحظة: ظهر هذا المقال أول مرة في سبتمبر 2024. وقد راجعته في سبتمبر 2026 ليتوافق مع إصدار Java 27، فهو يعكس أحدث التغييرات والتحسينات التي جاءت مع ذلك الإصدار.

قبل Java 25

لنرَ كيف كانت الأمور قبل هذا JEP. كان العمل مع switch أو instanceof يأتي بقيود كبيرة. ففي switch، لم يكن بالإمكان استخدام كل الأنواع المغلَّفة (boxed).

لو حاولت كتابة هذه الشيفرة،

Double d = 20.0d;
switch(d){
   case 20.0d -> log("double is 20");
   default -> log("wrong number" + d);
}

لحصلت على خطأ الترجمة هذا:

java: constant label of type double is not compatible with switch selector type java.lang.Double

والسبب أن أنواعًا معينة كانت مقيّدة. تنص JLS على:

“يُشار إلى هذا التعبير بتعبير المحدِّد (selector). ويجب أن يكون نوعه char أو byte أو short أو int أو نوع مرجعي؛ وإلا يُرفع خطأ وقت الترجمة.”

يخبرنا الاقتباس أن النوع int يمكن استخدامه في switch. وفعلًا، يمكنك كتابة شيفرة مثل:

int v = 20;
switch(v){
   case 20 -> log("int is 20");
   default -> log("wrong number" + v);
}

وكل شيء يعمل جيدًا. وكما تعلم، تلقى switch تحسينات كثيرة في Java 21، تتيح لك كتابة شيء مثل:

Integer v = 20;
switch(v){
   case Integer i when i < 20-> log("This value is too low: " + i );
   case Integer i -> log("This value is perfect: " + i );
}

جميل، أليس كذلك؟ لنحاول الشيء نفسه مع int أولي.

int v = 20;
switch(v){
   case int i when i < 20 -> log("This value is too low: " + i );
   case int i -> log("This value is perfect: " + i );
}

يؤدي تشغيل هذه الشيفرة إلى خطأ ترجمة:

java: unexpected type

  required: class or array

  found:    int

ما السبب؟ حتى JEP-507، كانت أنماط switch مدعومة جزئيًا فقط في Java.

وكان يمكن استخدام أنماط Switch هذه مع أنماط السجلات (Record Patterns).

record Value(int i){}
void test(){
   Value v = new Value(20);
   switch (v) {
       case Value(int i) when i < 20 -> log("This value is too low: " + i );
       case Value(int i) -> log("This value is perfect: " + i );
   }
}

يعمل هذا كما هو متوقع. أما instanceof، في المقابل، فلم يكن يدعم أي نوع أولي على الإطلاق.

بعد Java 25 - مع تفعيل ميزة المعاينة

يقبل switch الآن Long وFloat وDouble وBoolean، لذا يعمل المثال السابق مع Double.

ويتصرف instanceof بشكل مختلف أيضًا: يمكنك الآن التحقق مما إذا كان المتغير من نوع أولي.

ومن الآن فصاعدًا، سيؤدي تشغيل شيفرة كهذه:

int i = 42;
if(i instanceof int){
   log("i is an instance of int");
}

إلى طباعة “i is an instance of int” على وحدة التحكم. ممتاز! وماذا عن هذه الشيفرة؟

int i = 42;
if(i instanceof byte){
   log("i is an instance of byte?");
}

بسيط بما يكفي، أليس كذلك؟ لا شيء يُطبع، إذ إن int ليس نسخة من byte. إلا أننا، في هذا المثال، نحصل فعلًا على النص “i is an instance of byte?”

لماذا؟

كل شيء يعود إلى التحويل (casting) – الآلية الأساسية في Java لإسناد قيمة من نوع بيانات أولي إلى نوع آخر.

هل تعلم أن التحويل ليس آمنًا؟ ألقِ نظرة على هذا المثال:

int i = 42;
byte b = (byte) i;
log("b value is " + b);

سيحمل المتغير b القيمة 42، صحيح؟ والآن؟

int i = 128;
byte b = (byte) i;
log("b value is " + b);

على الأرجح تشعر بأن هناك فخًا في هذا السؤال، وأنت محق: ستكون قيمة b هي -128. يحدث هذا لأن النوع byte يغطي المدى من -128 إلى 127 شاملًا. يمكنك قراءة المزيد عن Integral Types and Values.

وهذا يثير سؤالًا: إذا كان التحويل يغيّر القيمة، فهل هو النوع الصحيح؟ بحسب JEP، ليس كذلك.

ولهذا لم يعد instanceof يتحقق فقط من صحة النوع بالنسبة للمراجع، بل يتحقق أيضًا بالنسبة للقيم الأولية مما إذا كان يمكن تحويل القيمة بأمان.

إلامَ يؤدي هذا؟

قبل Java 25، كانت محاولة شيفرة كهذه:

Integer i = 42;
switch (i) {
   case Double d -> log("i is " + d); 
}

تؤدي إلى خطأ:

error: incompatible types: Integer cannot be converted to Double

أما مع الأنواع الأولية، فإن شيفرة كهذه:

int i = 42;
switch (i) {
   case double d -> log("i is " + d)
}

تعمل دون مشاكل، لأن أي int يمكن تحويله إلى double بأمان. وإذا جربت الشيء نفسه مع أنواع أضيق، فيجب أن يكون switch شاملًا (exhaustive)، هكذا:

int i = 10_0000;
switch (i) {
   case short v -> log("i is " + v);
   default -> log("not in scope of short" + i);
}

وللتعرف على ما إذا كان تحويل نوع أولي إلى آخر آمنًا، راجع Casting Contexts in JLS.

الخلاصة

تواصل أنماط switch أن تصبح أكثر فائدة في العمل اليومي. ويتيح لنا Project Amber الآن التعامل مع الأنواع الأولية بسهولة أكبر وبطرق أقل إسهابًا.