الانتقال إلى المحتوى
المواد
  • 1 أساسيات Java
    1.1

    الفئات الرئيسية والمخرجات

    يجمع هذا الموقع باستخدام قواعد لغة Java 8. تضع هذه الأمثلة المستقلة طريقة الدخول الخاصة بها، وهي main، داخل فئة. الفئات المساعدة والإجابات التي تقتصر على الدوال لا تحتاج إلى 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.");
        }
    }
    
    • جافا يتم ترجمتها: المفكك يفحص البرنامج بأكمله، ثم يتم تشغيله.
    • التصريحات والتعيينات واستدعاءات الدوال وجمل return تنتهي بنقطة فاصلة ;. كتل if أو for أو while تستخدم الأقواس العنصرية { }؛ ولا تضيف نقطة فاصلة لمجرد ظهور القوس المغلق.
    هذا المثال المستقل للغة جافا 8 يعرف الدالة الرئيسية داخل صنف
    هذا المثال المستقل للغة جافا 8 يعرف الدالة الرئيسية داخل صنف
    1.2

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

    يجب على المتغير أن يعلن نوعه. الأنواع البدائية الشائعة: 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);
        }
    }
    
    1.3

    التعليقات والأسلوب

    التعليق هو // (سطر واحد) أو /* ... */ (كتلة). قم بمحاذاة الكود داخل الأقواس { }. تبدأ أسماء الفئات بحرف كبير؛ تستخدم المتغيرات والدوال 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 لا يفعل ذلك.
  • 2 العمليات والتعبيرات
    2.1

    العمليات الحسابية والتعيين

    تستخدم جافا العمليات الحسابية + - * / و% (باقي القسمة). مع رقمين 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);
        }
    }
    
    int/int يقطع; اشرك double للحصول على ناتج حقيقي
    int/int يقطع; اشرك double للحصول على ناتج حقيقي
    2.2

    استخدام الكائنات: String, Math, wrappers

    بعض القيم هي كائنات تحتوي على طرق. 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.
    2.3

    التحويل وتحويل الأنواع

    التحويل يغير نوع القيمة. (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()، وليس ==.
    • == على كائنين يختبر ما إذا كانا نفس الكائن، وليس ما إذا كانا متساويين شكليًا.
  • 3 القيم المنطقية والاختيار
    3.1

    if / else

    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");
            }
        }
    }
    
    if تختفر الفرع الصحيح؛ else الفرع الخطأ
    if تختفر الفرع الصحيح؛ else الفرع الخطأ
    3.2

    العمليات المنطقية والمقارنات

    قارن باستخدام ==، !=، <، >، <=، >= — المقارنة تعطي قيمة 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
        }
    }
    
    3.3

    مفتاح

    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;، وإلا سينزل التحكم إلى الحالة التالية.
    • && و|| هما العمليات المنطقية؛ & و| هي العمليات البتية.
  • 4 الحلقات
    4.1

    حلقات while

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

    public class Main {
        public static void main(String[] args) {
            int n = 1;
            while (n <= 3) {
                System.out.println(n);
                n++;
            }
        }
    }
    
    while يفحص الشرط قبل كل مرور لجسم الحلقة
    while يفحص الشرط قبل كل مرور لجسم الحلقة
    4.2

    حلقات for

    حلقة 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
        }
    }
    
    4.3

    التراكم

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

    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
        }
    }
    
    4.4

    الحلقات المتداخلة

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

    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 حتى ينتهي نطاقه مع الحلقة.
  • 5 النصوص
    5.1

    طرق String

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

    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
        }
    }
    

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

    الطريقة المعنى مثال → النتيجة
    .length() عدد الأحرف "Hi".length() → 2
    .charAt(i) حرف واحد "Hi".charAt(0) → H
    .substring(a, b) جزء، يتوقف قبل b "Python".substring(0, 3) → Pyt
    .substring(a) من a إلى النهاية "Python".substring(3) → hon
    .indexOf(x) أول موقع، -1 إذا غائب "banana".indexOf("na") → 2
    .equals(s) نفس النص؟ "hi".equals("hi") → true
    .compareTo(s) ترتيب: سالب / 0 / موجب "apple".compareTo("banana") → سالب

    يقارن compareTo وحدات الكود UTF-16 أبجدياً، مع مراعاة حالة الأحرف (على سبيل المثال، "Z" يأتي قبل "a") — يستخدم امتحان 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)
        }
    }
    
    طرق String الأساسية: length, charAt, substring, equals
    طرق String الأساسية: length, charAt, substring, equals
    5.2

    بناء واستعراض السلاسل

    اجمع السلاسل باستخدام + (الوصل). زور كل حرف باستخدام حلقة و.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() النتيجة بأحرف كبيرة دون تغيير s، لذا قم بتخزين النتيجة.
    • اقرأ حرفًا باستخدام s.charAt(i)؛ الطول هو s.length() (طريقة، مع ()).
    • بناء String باستخدام += في حلقة كبيرة بطيء؛ استخدم StringBuilder.
  • 6 المصفوفات
    6.1

    مصفوفات 1-A

    المصفوفة تحتفظ بعدد ثابت من القيم من نوع واحد. 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
        }
    }
    
    النوع البدائي يحتفظ بقيمته؛ متغير المصفوفة يحتفظ بإشارة إلى كائن المصفوفة
    النوع البدائي يحتفظ بقيمته؛ متغير المصفوفة يحتفظ بإشارة إلى كائن المصفوفة
    6.2

    خوارزميات المصفوفات

    مرر على المصفوفة باستخدام حلقة للعثور على القيمة العظمى، أو المجموع، أو العدد، أو للبحث. تحسب حلقة 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
        }
    }
    
    6.3

    مصفوفات 2-A

    المصفوفة متعددة الأبعاد 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]) بالصفر، ولا تترك فارغة.
  • 7 ArrayList
    7.1

    أساسيات ArrayList

    الـ 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]
        }
    }
    
    ArrayList: add, get, size on a resizable list
    ArrayList: add, get, size on a resizable list
    7.2

    خوارزميات ArrayList وخطأ الإزالة

    الإزالة (.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 تلقائياً.
  • 8 كتابة الفئات
    8.1

    الحقول والمُشكّل والطرق

    الفئة (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;
        }
    }
    
    الحقول تخزن الحالة؛ المُشكّل يبني؛ الطرق تتصرف
    الحقول تخزن الحالة؛ المُشكّل يبني؛ الطرق تتصرف
    8.2

    التغليف

    تحكم التغليف في الوصول إلى حالة الكائن. ضع علامات private على الحقول لمنع الوصول المباشر من الأصناف غير ذات الصلة؛ قارئ الحالة (المتحصل) يقرأ الحالة، والمُعدّل يُغيرها. المُعدِّل هو نوع واحد من المُعدِّلات. لا يقوم private بالتحقق من القيم: يجب أن تحتوي المُنشئات والدوال المُعدِّلة على فحوصاتها الخاصة أو شروطها الأولية المعلنة. يفترض هذا المثال وجود قيمة start غير سالبة وإضافات تتسع في int؛ ترفض دالة الإيداع المبالغ غير الموجبة.

    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;     // this guard checks the deposit amount
        }
    
        public int getBalance() {                  // accessor (getter)
            return balance;
        }
    }
    

    أخطاء شائعة

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

    الوراثة

    التوريث يسمح للفئة الفرعية بإعادة استخدام superclass. اكتب class Cat extends Animal وCat ترث الحقول والمؤهلات والدوال من Animal. الأعضاء الخاصة لا تُورث؛ ولا تُورث دوال البناء (constructors) أيضاً. استدعِ دالة بناء الأب باستخدام 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"); }
    }
    
    القطط والكلاب تمتد Animal: ورثوا أعضاؤها وأضافوا أعضاءهم الخاصة
    القطط والكلاب تمتد Animal: ورثوا أعضاؤها وأضافوا أعضاءهم الخاصة
    9.2

    تعدد الأشكال (Polymorphism) وtoString

    يمكن للفئة الفرعية 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 كائن الفئة الأب، والعكس غير صحيح.
  • 10 العودية
    10.1

    الاستدعاء المتكرر

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

    مكدس الاستدعاء لـ factorial(3): كل استدعاء ينتظر، ثم يعود بالترتيب العكسي
    مكدس الاستدعاء لـ factorial(3): كل استدعاء ينتظر، ثم يعود بالترتيب العكسي
    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) تقوم بالعمل الحقيقي؛ التراجع يقوم فقط بقسمة المصفوفة.
  • 11 البحث والفرز
    11.1

    البحث الخطي ثنائي التفرع

    البحث الخطي يفحص كل عنصر — يعمل على أي مصفوفة. البحث الثنائي أسرع بكثير لكنه يحتاج مصفوفة مرتبة: ينظر للوسط، ثم يتخلص من نصفها في كل خطوة. كلاهما يُرجع المؤشر، أو -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;
        }
    }
    
    البحث الثنائي يقلص النطاق إلى النصف في كل خطوة، لذا يتم البحث عن مصفوفة مرتبة في O(log n)
    البحث الثنائي يقلص النطاق إلى النصف في كل خطوة، لذا يتم البحث عن مصفوفة مرتبة في O(log n)
    11.2

    اختيار الترتيب وإدراج الترتيب

    اختيار الترتيب (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]
        }
    }
    

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

    الخوارزمية الوقت
    linear search O(n)
    binary search O(log n), للمصفوفات المرتبة فقط
    selection / insertion sort O(n²)
    merge sort (موضوع 10) O(n log n)

    أخطاء شائعة

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

    ملفات نصية مع Scanner

    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
        }
    }
    
    Scanner reads lines while hasNextLine is true
    Scanner reads lines while hasNextLine is true
    12.2

    أنواع أسئلة AP FRQ

    يحتوي امتحان 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() قبل القراءة، لتجنب الخروج عن نهاية الملف.
    • في السؤال المقالي، اقرأ ترويسة الدالة بعناية: طابق نوع الإرجاع والمعاملات تمامًا.

تسجيل الدخول أو إنشاء حساب

IGCSE, A-Level & AP