Java Handout · ⁨חומר עזר Java⁩

כל תוכנת 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.");
    }
}

• 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 אינו עושה זאת.

Java arithmetic 算术 uses + - * / and % (remainder). With two ints, / is integer division 整数除法 — it drops the decimal. +=, -=, and ++ are shortcuts.

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

Some values are objects 对象 with methods. String has .length(), .substring(), .toUpperCase(). Math has Math.max, Math.sqrt, Math.pow. Wrapper classes 包装类 (Integer, Double) wrap a primitive — e.g. 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() returns a random 随机 double from 0.0 up to (but not including) 1.0. Scale it and cast to get whole numbers — this is the AP idiom:

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) and Integer.MIN_VALUE are the limits of int; going past them wraps around (an overflow).
• An object variable that points at no object holds null; calling a method on it throws a NullPointerException.

A cast 强制转换 changes a value's type. (int) drops the decimal; (double) avoids integer division when you need an exact result.

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

Common mistakes

• Integer division: 5 / 2 is 2, not 2.5. Cast first: (double) 5 / 2.
• Compare Strings (and other objects) with .equals(), not ==.
• == on two objects tests whether they are the SAME object, not whether they look equal.

if runs a block when a condition 条件 is true; else if and else add more cases. The condition goes in ( ), the block in { }.

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");
        }
    }
}

Compare with ==, !=, <, >, <=, >= — a comparison 比较 gives a boolean. Combine with && (and), || (or), ! (not) — the logical operators 逻辑运算符. For Strings, use .equals(...), not ==.

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

לולאת 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 (...) — זה יוצר לולאה ריקה.
• הכרז את הסופר בח头 header של 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
    }
}

כשאתם בונים מחרוזת ארוכה בתוך לולאה, StringBuilder מהיר משמעותית: הוסיפו את החלקים באמצעות append, ולאחר מכן קראו ל-.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
    }
}

שגיאות נפוצות

• מחרוזות הן בלתי ניתנות לשינוי (immutable): s.toUpperCase() מחזירה מחרוזת חדשה, ולכן יש לאחסן את התוצאה.
• קראו תווית באמצעות s.charAt(i); האורך הוא s.length() (זו שיטה, עם ()).
• בניית מחרוזת באמצעות += בתוך לולאה גדולה היא איטית; השתמשו ב-StringBuilder.

מערך מחזיק מספר קבוע של ערכים מאותו סוג. מדדו מתוך 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⟩-D הוא רשת של שורות ועמודות: ⟨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] ממולא באפסים, ולא נשאר ריק.

An ArrayList is a resizable 可变大小 list — it grows and shrinks as you add or remove items. It stores objects, so use a wrapper 包装类 type like Integer (not int). The <Integer> part is a generic 泛型 type. Key methods: .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) shifts 移动 every later element one place left. If you remove while counting i up, you skip the next element. Fix: loop backwards, or don't increment i after a remove.

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

Common mistakes

• ArrayList uses .size(), .get(i) and .add(...) — not the [] you use on arrays.
• Removing items while looping forward by index skips the next item (the remove bug). Loop backwards, or use an iterator.
• Store objects, not primitives: use ArrayList<Integer>, and Java auto-boxes int values.

כיתה היא תבנית לאובייקטים. השדות שלה מאחסנים נתונים, הבונה מייצר אובייקט חדש, והמתודות הן הפעולות. 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 שייך לכיתה עצמה, ולא לכל אובייקט בנפרד. קרא לשיטה סטטית על שם הכיתה — כמו Math.max — ושדה סטטי משותף לכל האובייקטים:

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 כדי שהקוד מחוץ לא יוכל לגעת בהם ישירות; חשוף גוף נגיש (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;
    }
}

שגיאות נפוצות

• לבונה יש שם הכיתה ואין לו סוג החזרה (לא גם void).
• השתמש בthis.field כדי להבדיל בין שדה לבין פרמטר בעל אותו שם.
• הגדר שדות כprivate והגיע אליהם דרך מתודות getter/setter (הסתגרות).

ירישה מאפשרת לתת-כיתה להשתמש במונה-כיתה. כתוב class Cat extends Animal ו-Cat יקבלו את השדות והשיטות של Animal בחינם. קרא לבונה ההורה עם 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: הם מורשים את חבריה ומוסיפים את משלהם

כיתה בת יכולה להחליף מתודה ולהחליף את גרסת ההורה. פולימורפיזם פירושה שמשתנה 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 כך שהקומפיילר יזהה טעויות.
• super(...) חייב להיות השורה הראשונה בבונה של סוג נגזר.
• אובייקט של מחלקה נגזרת IS-A אובייקט של מחלקת אם, אך לא להפך.

רקורסיה היא שיטה הקוראת לעצמה. לכל רקורסיה נדרש מקרה בסיס (כאן לעצור) וקריאה רקורסיבית המנחה את הביצועים אליו. ללא מקרה בסיס, התוכנית מעולם אינה נעצרת וגורמת לקריסה עם שפיכת סטאק (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.

רקורסיה פועלת גם על Strings — הורידו אותף אחד בכל קריאה:

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.
• כל קריאה רקורסיבית חייבת לקרב CLOSER למקרה הבסיס.
• בצעו מעקב ידני לדוגמה קטנה כדי לוודא שהרקורסיה מחזירה את הערך הנכון.
• בשלב המיזוג ב-Merge sort מתבצע העבודה העיקרית; הרקורסיה משמשת רק לחלוקת המערכת.

חיפוש ליניארי בודק כל אלמנט — עובד על כל מערך. חיפוש בינארי מהיר משמעותית יותר אך דורש מערך מומיין: הוא בוחן את האלמנט באמצע, ולאחר מכן פולט חצי מהטווח בכל צעד. שניהם מחזירים את המקדם, או -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;
    }
}

במיון בחירה נמצא באופן חוזר הערך הקטן ביותר שנותר והוא מתחליפו עם האלמנט הראשון. במיון הכנסה לוקחים כל ערך ומחליקים אותו אחורה למקומו בין הערכים שכבר ממוינים.

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 קורא טקסט שורה בשורה. עבור קובץ אמיתי כותבים 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 — מערך /ArrayList: עבד על מערך בעל ממד 1 או על ArrayList (חיפוש, ספירה, בניית רשימה חדשה).
• שאלה4 — מערך בעל ממד 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() לפני הקריאה, כדי להימנע מהליכה מחוץ לגבולות הקובץ.
• במבחן FRQ, קרא את חתימת המתודה בקפידה: התאים את סוג ההחזרה והפרמטרים בדיוק.