الأنواع العامة في جافا: أصناف وطرق آمنة من حيث النوع

لماذا توجد الأنواع العامة

يتيح لك النوع العام كتابة الشيفرة مرة واحدة وإعادة استخدامها مع أنواع كثيرة دون التخلّي عن أمان الأنواع. فبدلًا من كتابة IntBox وStringBox وUserBox بشكل منفصل، تكتب صنفًا واحدًا Box<T> حيث يكون T موضعًا نائبًا يملؤه الطرف المُستدعي.

لقد استخدمت الأنواع العامة بالفعل في كل مرة كتبت فيها ArrayList<String> أو HashMap<String, Integer>. الجزء <...> هو وسيط نوعي. توضّح هذه الصفحة كيف تكتب أنواعك العامة الخاصة بك.

أمّا البديل - تخزين كل شيء على أنه Object - فيُلقي بالمعلومات النوعية بعيدًا ويفرض تحويلات قبيحة ومعرّضة للأخطاء:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Object> raw = new ArrayList<>();
        raw.add("hello");
        raw.add(42);                       // لا شيء يمنع هذا الخطأ

        String first = (String) raw.get(0); // كل عملية قراءة تحتاج إلى تحويل
        String oops = (String) raw.get(1);  // يُترجَم، ثم ينهار وقت التشغيل
        System.out.println(first + " " + oops);
    }
}

ذلك التحويل في السطر الأخير يطلق ClassCastException وقت التشغيل - وهو نوع الأخطاء الذي صُمّمت الأنواع العامة لجعله مستحيلًا.

صنف عام

أعلن عن معامل نوعي بين قوسين زاويين بعد اسم الصنف. وبحسب العُرف يكون حرفًا كبيرًا واحدًا: T لـ "type" (نوع)، وE لـ "element" (عنصر)، وK/V للمفتاح/القيمة.

class Box<T> {
    private T value;

    Box(T value) { this.value = value; }

    T get() { return value; }
    void set(T value) { this.value = value; }
}

public class Main {
    public static void main(String[] args) {
        Box<String> name = new Box<>("Coddy");
        Box<Integer> count = new Box<>(3);

        String s = name.get();     // بلا تحويل - المترجِم يعرف أنه String
        int n = count.get();
        System.out.println(s + " x" + n);

        // name.set(99); // لن يُترجَم - Box<String> يقبل String فقط
    }
}

داخل Box، يصبح كل T ما زوّده به الطرف المُستدعي. وBox<String> صندوق يحتوي ويُعيد String فقط. ويرفض المترجِم name.set(99) قبل أن يعمل البرنامج أصلًا.

أمّا <> الفارغة على الطرف المقابل (مُعامِل الماسة) فتدع المترجِم يستنتج الوسيط النوعي من الجهة المقابلة، فلا تكرّر <String> مرتين.

الطرق العامة

يمكن أن يكون لطريقة واحدة معاملها النوعي الخاص بها، مستقلًّا عن الصنف. ضع المعامل <T> قبل نوع القيمة المُعادة:

import java.util.List;

public class Main {

    // <T> تُعلِن المعامل النوعي؛ T هو نوع العنصر
    static <T> T firstOrNull(List<T> items) {
        return items.isEmpty() ? null : items.get(0);
    }

    public static void main(String[] args) {
        List<String> words = List.of("alpha", "beta");
        List<Integer> nums = List.of(10, 20, 30);

        String w = firstOrNull(words);   // يُستنتج T على أنه String
        Integer n = firstOrNull(nums);   // يُستنتج T على أنه Integer
        System.out.println(w + " " + n);
    }
}

أنت لا تمرّر T صراحةً أبدًا - بل يستنتجه المترجِم من الوسيط. والطرق العامة هي السبيل الذي يبقي به أدواتٌ مثل Collections.sort أو List.of آمنةً من حيث النوع مع أي نوع عنصر.

المعاملات النوعية المقيَّدة

أحيانًا لا يكون للنوع العام معنى إلا مع بعض الأنواع. تقيّد extends المعامل حتى تتمكّن من استدعاء طرق الحدّ. هنا يعني T extends Number أن T هو Number أو أي صنف فرعي منه (Integer، Double، ...)، فتُصبح doubleValue() متاحة:

import java.util.List;

public class Main {

    static <T extends Number> double sum(List<T> numbers) {
        double total = 0;
        for (T n : numbers) {
            total += n.doubleValue();   // مشروع لأن T هو Number على الأقل
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(List.of(1, 2, 3)));        // Integers
        System.out.println(sum(List.of(1.5, 2.5)));       // Doubles
    }
}

لاحظ أن extends هنا تعني "نوع فرعي من"، وهي تعمل مع الأصناف والواجهات على حدٍّ سواء - والصيغة <T extends Comparable<T>> شائعة جدًّا حين تحتاج إلى مقارنة العناصر.

الأحرف البدلية: ‎? extends‎ و‎? super‎

مزلق دقيق: List<Integer> ليست List<Number>، رغم أن Integer هو Number. فالأنواع العامة ثابتة (invariant). والأحرف البدلية تخفّف هذا القيد حين تحتاج إلى القراءة فقط أو الكتابة فقط.

استخدم ? extends T لمُنتِجٍ تقرأ منه، و? super T لمستهلِكٍ تكتب إليه (قاعدة "PECS" - Producer Extends, Consumer Super):

import java.util.ArrayList;
import java.util.List;

public class Main {

    // يقرأ Number - يقبل List<Integer>، List<Double>، إلخ.
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // يكتب Integer - يقبل List<Integer>، List<Number>، List<Object>
    static void addInts(List<? super Integer> dest) {
        dest.add(1);
        dest.add(2);
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        System.out.println(total(ints));      // يعمل بفضل ? extends

        List<Number> bucket = new ArrayList<>();
        addInts(bucket);                       // يعمل بفضل ? super
        System.out.println(bucket);
    }
}

تتيح لك قائمة ? extends Number قراءة العناصر بوصفها Number، لكنها لا تتيح الإضافة إليها (إذ لا يستطيع المترجِم معرفة نوع العنصر الدقيق). وتتيح لك قائمة ? super Integer إضافة Integer، لكن القراءات تعود بوصفها Object. اختر الحرف البدلي الذي يناسب طريقة تدفّق البيانات.

محو النوع وحدوده

الأنواع العامة ميزة خاصة بوقت الترجمة. فبعد الترجمة يُمحى المعامل النوعي - ووقت التشغيل تكون Box<String> وBox<Integer> كلتاهما مجرد Box. يُبقي هذا الأنواع العامة متوافقة رجعيًّا مع الشيفرة القديمة، لكنه يفرض حدودًا حقيقية.

// لا يُترجَم أيٌّ مما يلي - المعامل النوعي غير موجود وقت التشغيل:
T value = new T();          // لا يمكن إنشاء كائن من معامل نوعي
T[] array = new T[10];      // لا يمكن إنشاء مصفوفة عامة
if (list instanceof List<String>) { } // لا يمكن اختبار الوسيط النوعي

ولأن النوع يختفي وقت التشغيل، لا يمكنك السؤال "ماذا كان T؟" عبر الانعكاس، ولا يمكنك تحميل طرق زائد (overload) تختلف فقط في وسيطها العام (إذ تُمحى foo(List<String>) وfoo(List<Integer>) إلى البصمة نفسها). وحين تحتاج فعلًا إلى النوع وقت التشغيل، مرّر رمز Class<T> بوصفه معاملًا للباني أو للطريقة.

التالي: تعبيرات لامدا

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