Java Handout · ⁨ورقة عمل Java⁩

كل برنامج جافا يعيش داخل فئة. يبدأ في دالة تُسمى main. System.out.println(...) يطبع سطرًا؛ System.out.print(...) يطبع بدون سطر جديد.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
        System.out.println("I am learning Java.");
    }
}

• جافا يتم ترجمتها: المفكك يفحص البرنامج بأكمله، ثم يتم تشغيله.
• كل تعليمة تنتهي بنقطة فاصلة ;.

يجب على المتغير أن يعلن نوعه. الأنواع البدائية الشائعة: int (عدد صحيح)، double (عشري)، boolean (true/false)، char (حرف واحد).

public class Main {
    public static void main(String[] args) {
        int age = 17;
        double price = 9.99;
        boolean passed = true;
        System.out.println(age + " " + price + " " + passed);
    }
}

التعليق هو // (سطر واحد) أو /* ... */ (كتلة). قم بمحاذاة الكود داخل الأقواس { }. تبدأ أسماء الفئات بحرف كبير؛ تستخدم المتغيرات والدوال camelCase (حرف صغير أول).

public class Main {
    public static void main(String[] args) {
        // greet the user
        String firstName = "Mei";
        System.out.println("Hi, " + firstName);
    }
}

أخطاء شائعة

• كل تعليمة تنتهي بنقطة فاصلة ;.
• main يجب أن يكون بالضبط public static void main(String[] args).
• println يضيف سطرًا جديدًا؛ print لا يفعل ذلك.

تستخدم جافا العمليات الحسابية + - * / و% (باقي القسمة). مع رقمين int، / هي قسمة صحيحة — تتجاهل الجزء العشري. +=، -=، و++ هي اختصارات.

public class Main {
    public static void main(String[] args) {
        int a = 7, b = 2;
        System.out.println(a / b);    // 3 (integer division)
        System.out.println(a % b);    // 1
        double x = 7.0 / 2;           // 3.5 (one side is double)
        System.out.println(x);
    }
}

بعض القيم هي كائنات تحتوي على طرق. String يحتوي على .length() و.substring() و.toUpperCase(). Math يحتوي على Math.max وMath.sqrt وMath.pow. فئات التغليف (Integer، Double) تغلف نوعًا أوليًا — على سبيل المثال Integer.parseInt("42").

public class Main {
    public static void main(String[] args) {
        String s = "Hello";
        System.out.println(s.length());                  // 5
        System.out.println(s.toUpperCase());             // HELLO
        System.out.println(Math.max(3, 9));              // 9
        System.out.println(Integer.parseInt("42") + 1);  // 43
    }
}

Math.random() يعيد رقمًا عشوائيًا double من 0.0 حتى (ولكن لا يشمل) 1.0. ضربه وقم بتحويل النوع لتحصل على أعداد صحيحة — هذا هو الإياديون الخاص بالـ AP:

public class Main {
    public static void main(String[] args) {
        // a random whole number from 1 to 6 (a dice roll)
        int roll = (int) (Math.random() * 6) + 1;
        System.out.println(roll >= 1 && roll <= 6);   // true
    }
}

• Integer.MAX_VALUE (2147483647) وInteger.MIN_VALUE هما حدود int؛ تجاوزهما يؤدي إلى الدوران (فائض).
• متغير كائن يشير إلى أي كائن يحمل null؛ استدعاء طريقة عليه يرمز NullPointerException.

التحويل يغير نوع القيمة. (int) يتجاهل الجزء العشري؛ (double) يتجنب القسمة الصحيحة عندما تحتاج نتيجة دقيقة.

public class Main {
    public static void main(String[] args) {
        double pi = 3.99;
        System.out.println((int) pi);            // 3
        int total = 7, n = 2;
        System.out.println((double) total / n);  // 3.5
    }
}

أخطاء شائعة

• القسمة الصحيحة: 5 / 2 هي 2، وليست 2.5. حول النوع أولاً: (double) 5 / 2.
• قارن السلاسل (وغيرها من الكائنات) باستخدام .equals()، وليس ==.
• == على كائنين يختبر ما إذا كانا نفس الكائن، وليس ما إذا كانا متساويين شكليًا.

if يشغل كتلة عندما تكون الشرط صحيحًا؛ else if وelse يضيفان المزيد من الحالات. يوضع الشرط في ( )، والكتلة في { }.

public class Main {
    public static void main(String[] args) {
        int score = 72;
        if (score >= 80) {
            System.out.println("A");
        } else if (score >= 60) {
            System.out.println("B");
        } else {
            System.out.println("fail");
        }
    }
}

قارن باستخدام ==، !=، <، >، <=، >= — المقارنة تعطي قيمة boolean. ادمجها باستخدام && (و)، || (أو)، ! (لا) — العمليات المنطقية. بالنسبة لـ Strings، استخدم .equals(...)، ليس ==.

public class Main {
    public static void main(String[] args) {
        int age = 16;
        boolean member = true;
        System.out.println(age >= 18 && member);   // false
        String a = "hi";
        System.out.println(a.equals("hi"));        // true
    }
}

switch يختار بين قيم ثابتة متعددة. كل case ينتهي بـ break؛ default هو البديل الاحتياطي.

public class Main {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1: System.out.println("Mon"); break;
            case 3: System.out.println("Wed"); break;
            default: System.out.println("other");
        }
    }
}

أخطاء شائعة

• الشرط يجب أن يكون value boolean؛ if (x = 5) لا يترجم (استخدم ==).
• كل حالة switch تحتاج إلى break;، وإلا سينزل التحكم إلى الحالة التالية.
• && و|| هما العمليات المنطقية؛ & و| هي العمليات البتية.

حلقة while تكرر طالما الشرط صحيح. غيّر شيئًا بداخلها، أو ستكرر إلى ما لا نهاية.

public class Main {
    public static void main(String[] args) {
        int n = 1;
        while (n <= 3) {
            System.out.println(n);
            n++;
        }
    }
}

حلقة for تجمع البداية، الشرط، والخطوة في سطر واحد. الأفضل عندما تعرف العدد.

public class Main {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.print(i + " ");
        }
        System.out.println();   // 0 1 2 3 4
    }
}

نمط المجمع: ابدأ بمتغير قبل الحلقة، ثم حدّثه في كل دورة.

public class Main {
    public static void main(String[] args) {
        int total = 0;
        for (int i = 1; i <= 5; i++) {
            total += i;
        }
        System.out.println(total);   // 15
    }
}

حلقة داخل حلقة هي حلقة متداخلة. تعمل الحلقة الداخلية بالكامل في كل دورة من الحلقة الخارجية.

public class Main {
    public static void main(String[] args) {
        for (int r = 0; r < 3; r++) {
            for (int c = 0; c < 3; c++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

أخطاء شائعة

• for (int i = 0; i < n; i++) تعمل n مرة (من 0 إلى n - 1)؛ استخدام <= يعمل مرة إضافية.
• لا تضع نقطة فاصلة مباشرة بعد for (...) أو while (...) — لأنها تصنع حلقة فارغة.
• أعلن العداد في رأس for حتى ينتهي نطاقه مع الحلقة.

الـ String هو نص. الطرق المفيدة: .length()، .charAt(i)، .substring(a, b)، .indexOf(x)، .toUpperCase()، .equals(...). السلاسل غير قابلة للتغيير — كل طريقة تُعيد String جديد.

public class Main {
    public static void main(String[] args) {
        String s = "Python";
        System.out.println(s.length());          // 6
        System.out.println(s.charAt(0));         // P
        System.out.println(s.substring(0, 3));   // Pyt
        System.out.println(s.toUpperCase());     // PYTHON
    }
}

الطرق التي ستستخدمها كل يوم:

compareTo يضع السلاسل في الترتيب القامسي — يستخدم امتحان الـ AP ذلك في أسئلة الترتيب:

public class Main {
    public static void main(String[] args) {
        String a = "apple", b = "banana";
        System.out.println(a.compareTo(b) < 0);    // true (apple comes first)
        System.out.println(a.compareTo("apple"));  // 0 (equal)
    }
}

اجمع السلاسل باستخدام + (الوصل). زور كل حرف باستخدام حلقة و.charAt(i).

public class Main {
    public static void main(String[] args) {
        String word = "banana";
        int count = 0;
        for (int i = 0; i < word.length(); i++) {
            if (word.charAt(i) == 'a') count++;
        }
        System.out.println(count);   // 3
    }
}

عند بناء String طويل في حلقة، StringBuilder أسرع بكثير: أضف القطع، ثم استدعِ .toString() مرة واحدة.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 5; i++) {
            sb.append(i).append(" ");
        }
        System.out.println(sb.toString().trim());   // 1 2 3 4 5
    }
}

أخطاء شائعة

• السلاسل غير قابلة للتغيير: s.toUpperCase() تُعيد String جديد، لذا احفظ النتيجة.
• اقرأ حرفًا باستخدام s.charAt(i)؛ الطول هو s.length() (طريقة، مع ()).
• بناء String باستخدام += في حلقة كبيرة بطيء؛ استخدم StringBuilder.

المصفوفة تحتفظ بعدد ثابت من القيم من نوع واحد. indeks من 0، واحصل على الحجم باستخدام .length.

public class Main {
    public static void main(String[] args) {
        int[] scores = {88, 71, 95};
        System.out.println(scores[0]);       // 88
        System.out.println(scores.length);   // 3
        scores[1] = 100;
        System.out.println(scores[1]);       // 100
    }
}

مرر على المصفوفة باستخدام حلقة للعثور على القيمة العظمى، أو المجموع، أو العدد، أو للبحث. تحسب حلقة for-each (for (int x : a)) كل قيمة على التوالي.

public class Main {
    public static void main(String[] args) {
        int[] a = {3, 9, 2, 7};
        int max = a[0], total = 0;
        for (int x : a) {
            if (x > max) max = x;
            total += x;
        }
        System.out.println(max + " " + total);   // 9 21
    }
}

المصفوفة متعددة الأبعاد 2 هي شبكة من الصفوف والأعمدة: grid[row][col].

public class Main {
    public static void main(String[] args) {
        int[][] grid = {{1, 2, 3}, {4, 5, 6}};
        System.out.println(grid[1][2]);   // 6
        for (int[] row : grid) {
            for (int v : row) System.out.print(v + " ");
        }
        System.out.println();             // 1 2 3 4 5 6
    }
}

أخطاء شائعة

• حجم المصفوفة هو a.length (بدون أقواس، بدون ())، وهو ثابت عند الإنشاء.
• الفهارس الصالحة تتراوح بين 0 وa.length - 1؛ بينما a[a.length] يتسبب في استثناء ArrayIndexOutOfBoundsException.
• تُعبأ المصفوفة الجديدة (int[5]) بالصفر، ولا تترك فارغة.

الـ ArrayList هو قائمة قابلة للتغيير الحجم — حيث تتوسع وتضيق عند إضافة أو إزالة العناصر. تخزن الكائنات، لذا استخدم نوع تغليف مثل Integer (وليس int). الجزء <Integer> هو نوع عام. الطرق الرئيسية: .add(x)، .get(i)، .set(i, x)، .size()، .remove(i).

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> nums = new ArrayList<Integer>();
        nums.add(10);
        nums.add(20);
        nums.add(30);
        System.out.println(nums.size());   // 3
        System.out.println(nums.get(1));   // 20
        nums.set(0, 99);
        System.out.println(nums);          // [99, 20, 30]
    }
}

الإزالة (.remove(i)) تحرك كل عنصر لاحق خطوة واحدة لليسار. إذا قمت بالإزالة أثناء العد التصاعدي (i لأعلى)، ستنتقل إلى العنصر التالي دون فحصه. الحل: عود الحلقة للخلف، أو لا زِد العداد (i) بعد عملية الإزالة.

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> nums = new ArrayList<Integer>();
        for (int n : new int[]{4, 7, 4, 9, 4}) nums.add(n);
        // Remove every 4 — loop backwards so removals don't skip items.
        for (int i = nums.size() - 1; i >= 0; i--) {
            if (nums.get(i) == 4) nums.remove(i);
        }
        System.out.println(nums);   // [7, 9]
    }
}

أخطاء شائعة

• ArrayList يستخدم .size()، .get(i) و.add(...) — وليس [] الذي تستخدمه على المصفوفات.
• إزالة العناصر أثناء المرور للأمام بالمؤشرات يتجاوز العنصر التالي (خطأ الإزالة). عد الحلقة للخلف، أو استخدم Iteration.
• احفظ كائنات، وليست القيم البدائية: استخدم ArrayList<Integer>، وتقوم Java بـ auto-boxing لقيم int تلقائياً.

الفئة (class) هي مخطط لمبنى الكائنات. حقولها تخزن البيانات، ومُشكّلاها (constructor) يُعدّ كائناً جديداً، وطرقها تمثل الإجراءات. this.name يعني "name هذا الكائن". أنشئ كائناً باستخدام new.

public class Main {
    public static void main(String[] args) {
        Dog d = new Dog("Rex", 3);
        System.out.println(d.describe());   // Rex is 3 years old
        d.haveBirthday();
        System.out.println(d.describe());   // Rex is 4 years old
    }
}

class Dog {
    private String name;
    private int age;

    public Dog(String name, int age) {   // constructor
        this.name = name;
        this.age = age;
    }

    public String describe() {
        return name + " is " + age + " years old";
    }

    public void haveBirthday() {
        age++;
    }
}

عضو static (static) ينتمي للفئة نفسها، وليس لكائن بعينه. استدعِ طريقة static باسم الفئة — مثلاً Math.max — وحقل static مشترك بين جميع الكائنات:

public class Main {
    public static void main(String[] args) {
        System.out.println(Counter.made());   // 0
        new Counter();
        new Counter();
        System.out.println(Counter.made());   // 2
    }
}

class Counter {
    private static int count = 0;      // shared by ALL Counter objects

    public Counter() { count++; }

    public static int made() {         // called on the class: Counter.made()
        return count;
    }
}

التغليف (Encapsulation) يعني إخفاء البيانات خلف الطرق. حدد الحقول بـ private حتى لا يستطيع الكود الخارجي الوصول إليها مباشرة؛ قدّم method getter لقراءتها، وطريقة لتغييرها بأمان. يمكن للطريقة أن تحمي البيانات — هنا يجب أن يكون الإيداع موجباً.

public class Main {
    public static void main(String[] args) {
        Account a = new Account(100);
        a.deposit(50);
        a.deposit(-999);                       // rejected by the guard
        System.out.println(a.getBalance());    // 150
    }
}

class Account {
    private int balance;                       // hidden from outside

    public Account(int start) {
        balance = start;
    }

    public void deposit(int amount) {
        if (amount > 0) balance += amount;     // guard keeps balance valid
    }

    public int getBalance() {                  // accessor (getter)
        return balance;
    }
}

أخطاء شائعة

• المُشكّل (constructor) يحمل اسم الفئة ولا يحتوي على نوع إرجاع (ولا حتى void).
• استخدم this.field لتمييز الحقل عن المعامل (parameter) الذي يحمل نفس الاسم.
• اجعل الحقول private وأصل إليها عبر طرق getter/setter (التغليف).

الوراثة تسمح للفئة الفرعية بإعادة استخدام superclass. اكتب class Cat extends Animal وسيحصل Cat مجاناً على حقول Animal وطرقها. استدعِ constructor الأب باستخدام super(...).

public class Main {
    public static void main(String[] args) {
        Cat c = new Cat("Milo");
        c.eat();      // Milo is eating  (inherited from Animal)
        c.speak();    // Meow            (Cat's own method)
    }
}

class Animal {
    protected String name;
    public Animal(String name) { this.name = name; }
    public void eat() { System.out.println(name + " is eating"); }
}

class Cat extends Animal {
    public Cat(String name) { super(name); }     // call Animal's constructor
    public void speak() { System.out.println("Meow"); }
}

يمكن للفئة الفرعية override لطريقة ما لاستبدال نسخة الأب. تعدد الأشكال يعني أن متغير من نوع Shape يمكنه حمل أي فرعي، وتختار Java الـ toString الصحيح وقت التشغيل. System.out.println(obj) تستدعي obj.toString() تلقائياً.

public class Main {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(2), new Square(3) };
        for (Shape s : shapes) {
            System.out.println(s);          // each calls its own toString
        }
    }
}

class Shape {
    public String toString() { return "a shape"; }
}

class Circle extends Shape {
    private int r;
    public Circle(int r) { this.r = r; }
    public String toString() { return "Circle r=" + r; }     // override
}

class Square extends Shape {
    private int side;
    public Square(int side) { this.side = side; }
    public String toString() { return "Square side=" + side; }   // override
}

أخطاء شائعة

• يجب أن تطابق الطريقة_override التوقيع (signature) تماماً؛ أضف @Override ليكتشف المترجم الأخطاء.
• super(...) يجب أن يكون السطر الأول من مُنشئ الفئة الابنة.
• كائن الفئة الفرعية IS-A كائن الفئة الأب، والعكس غير صحيح.

التراجع (Recursion) هو طريقة تستدعي نفسها. كل استدعاء راجع يحتاج حالة أساسية (متى تتوقف) واستدعاء راجع يقرّب منها. بدون حالة أساسية لن تتوقف أبداً وتسبب stack overflow.

public class Main {
    public static void main(String[] args) {
        System.out.println(factorial(5));   // 120
    }

    public static int factorial(int n) {
        if (n <= 1) return 1;            // base case
        return n * factorial(n - 1);     // recursive call: n * (n-1)!
    }
}

تتبع المسار: factorial(5) ينتظر factorial(4)، الذي ينتظر factorial(3)… وصولاً إلى factorial(1) الذي يُرجع 1. ثم تُضرب النتائج صعوداً: 1 → 2 → 6 → 24 → 120.

التراجع يعمل أيضاً مع النصوص — أزل حرفاً واحداً في كل استدعاء:

public class Main {
    public static void main(String[] args) {
        System.out.println(reverse("PYTHON"));   // NOHTYP
    }

    static String reverse(String s) {
        if (s.length() <= 1) return s;               // base case
        return reverse(s.substring(1)) + s.charAt(0);
    }
}

Merge sort هو ترتيب راجع في امتحان AP: قسّم المصفوفة لنصفين، رتّب كل نصف راجعاً، ثم ادمج النصفين المرتبين. يعمل بـ O(n log n) — أسرع بكثير من ترتيبات O(n²) على المصفوفات الكبيرة.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1, 7, 3};
        mergeSort(a, 0, a.length - 1);
        System.out.println(Arrays.toString(a));   // [1, 2, 3, 5, 7, 9]
    }

    static void mergeSort(int[] a, int lo, int hi) {
        if (lo >= hi) return;                 // base case: one element
        int mid = (lo + hi) / 2;
        mergeSort(a, lo, mid);                // sort the left half
        mergeSort(a, mid + 1, hi);            // sort the right half
        merge(a, lo, mid, hi);                // merge the two halves
    }

    static void merge(int[] a, int lo, int mid, int hi) {
        int[] tmp = new int[hi - lo + 1];
        int i = lo, j = mid + 1, k = 0;
        while (i <= mid && j <= hi) {
            if (a[i] <= a[j]) tmp[k++] = a[i++];
            else              tmp[k++] = a[j++];
        }
        while (i <= mid) tmp[k++] = a[i++];
        while (j <= hi)  tmp[k++] = a[j++];
        for (k = 0; k < tmp.length; k++) a[lo + k] = tmp[k];
    }
}

أخطاء شائعة

• يحتاج التكرار إلى حالة أساسية، وإلا سيُطلق StackOverflowError.
• يجب أن تقرب كل استدعاء راجع من الحالة الأساسية.
• تتبع مثال صغير يدوياً للتحقق من أن التراجع يُرجع القيمة الصحيحة.
• في merge sort، خطوة الدمج (merge step) تقوم بالعمل الحقيقي؛ التراجع يقوم فقط بقسمة المصفوفة.

البحث الخطي يفحص كل عنصر — يعمل على أي مصفوفة. البحث الثنائي أسرع بكثير لكنه يحتاج مصفوفة مرتبة: ينظر للوسط، ثم يتخلص من نصفها في كل خطوة. كلاهما يُرجع المؤشر، أو -1 إذا لم يُوجد.

public class Main {
    public static void main(String[] args) {
        int[] a = {2, 5, 8, 12, 16, 23};      // sorted, so binary search works
        System.out.println(linear(a, 12));    // 3
        System.out.println(binary(a, 12));    // 3
        System.out.println(binary(a, 9));     // -1 (not found)
    }

    static int linear(int[] a, int target) {
        for (int i = 0; i < a.length; i++)
            if (a[i] == target) return i;
        return -1;
    }

    static int binary(int[] a, int target) {
        int lo = 0, hi = a.length - 1;
        while (lo <= hi) {
            int mid = (lo + hi) / 2;
            if (a[mid] == target) return mid;
            else if (a[mid] < target) lo = mid + 1;
            else hi = mid - 1;
        }
        return -1;
    }
}

اختيار الترتيب (Selection sort) يجد مراراً أصغر قيمة متبقية ويبدلها في البداية. إدراج الترتيب (Insertion sort) يأخذ كل قيمة وينزلق بها للخلف في مكانها ضمن القيم المرتبة مسبقاً.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1, 7};
        for (int i = 0; i < a.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < a.length; j++)
                if (a[j] < a[min]) min = j;
            int t = a[min]; a[min] = a[i]; a[i] = t;   // swap into place
        }
        System.out.println(Arrays.toString(a));   // [1, 2, 5, 7, 9]
    }
}

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {5, 2, 9, 1, 7};
        for (int i = 1; i < a.length; i++) {
            int key = a[i], j = i - 1;
            while (j >= 0 && a[j] > key) {    // shift bigger values right
                a[j + 1] = a[j];
                j--;
            }
            a[j + 1] = key;                  // drop key into the gap
        }
        System.out.println(Arrays.toString(a));   // [1, 2, 5, 7, 9]
    }
}

مقارنة السرعات:

أخطاء شائعة

• البحث الثنائي يعمل فقط على مصفوفة مرتبة.
• البحث الخطي هو O(n)؛ البحث الثنائي هو O(log n) لكنه يحتاج الترتيب أولاً.
• اختيار الترتيب وإدراج الترتيب هما O(n²) — واضح للتعلم، لكن بطيء على البيانات الكبيرة.

Scanner (Scanner) يقرأ النص سطراً بسطر. بالنسبة لملف حقيقي تكتب new Scanner(new File("scores.txt"))؛ هنا نعطف String لكي يعمل المثال في أي مكان. استخدم .split(" ") لتقسيم السطر لأجزاء وInteger.parseInt(...) لتحليل رقم من النص.

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // Real file:  Scanner in = new Scanner(new File("scores.txt"));
        String data = "Alice 80\nBob 95\nCara 72";
        Scanner in = new Scanner(data);
        int total = 0, count = 0;
        while (in.hasNextLine()) {
            String line = in.nextLine();
            String[] parts = line.split(" ");      // break the line on the space
            total += Integer.parseInt(parts[1]);
            count++;
        }
        System.out.println("average = " + (total / count));   // average = 82
    }
}

يحتوي امتحان AP CS A على أربع أسئلة مقالية، كل منها له شكل ثابت:

• Q1 — الطرق والتحكم: اكتب طرقاً وفقاً لمواصفات محددة؛ حلقات تكرار، if، String/Math.
• Q2 — تصميم الفئات: اكتب فئة كاملة (حقول، مُنشئ، دوال) بناءً على وصف.
• س3 — مصفوفة / مصفوفة متغيرة: معالجة مصفوفة أحادية الأبعاد 1 أو ArrayList (بحث، عد، بناء قائمة جديدة).
• Q4 — مصفوفة متعددة الأبعاد 2: تجوال عبر الشبكة صفوياً وعمودياً.

المهارة دائمًا هي نفسها: اقرأ المواصفات، واكتب الدالة تمامًا كما هو موصوف، وأرجع النوع الصحيح.

public class Main {
    public static void main(String[] args) {
        // Q1 style: implement a method to a spec, then it is tested.
        System.out.println(countEven(new int[]{4, 7, 10, 3, 6}));   // 3
    }

    /** Returns how many values in arr are even. */
    public static int countEven(int[] arr) {
        int count = 0;
        for (int x : arr)
            if (x % 2 == 0) count++;
        return count;
    }
}

أخطاء شائعة

• nextInt() يترك سطر الجديد خلفه، لذا يقرأ nextLine() التالية سطرًا فارغًا — اقرأه أولاً.
• تحقق من hasNext() قبل القراءة، لتجنب الخروج عن نهاية الملف.
• في السؤال المقالي، اقرأ ترويسة الدالة بعناية: طابق نوع الإرجاع والمعاملات تمامًا.