Java Handout · ⁨Раздаточный материал Java⁩

Любая программа Java resides inside a class. Она начинается с метода под именем 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 использует + - * / и % (остаток от деления). При двух ints, / — целочисленное деление — оно отбрасывает десятичную часть. +=, -= и ++ — это сокращения.

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

Распространенные ошибки

• Условие должно быть boolean; if (x = 5) не компилируется (используйте ==).
• Каждый switch case требует break;, иначе управление перейдет к следующему case.
• && и || — это логические операторы; & и | — побитовые.

Цикл 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(...). Строки неизменяемы — каждый метод возвращает новую строку.

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 работает намного быстрее: добавляйте части, затем вызывайте .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.charAt(i); длина равна s.length() (метод, с ()).
• Построение строки с помощью += в большом цикле медленнее; используйте StringBuilder.

An array 数组 holds a fixed number of values of one type. Index from 0, and get the size with .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
    }
}

Walk the array with a loop to find a max, a total, a count, or to search 查找. A for-each loop (for (int x : a)) reads each value in turn.

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

A 2-D array 二维数组 is a grid 网格 of rows and columns: 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
    }
}

Common mistakes

• An array's size is a.length (no brackets, no ()), and it is fixed when created.
• Valid indexes are 0 to a.length - 1; a[a.length] throws ArrayIndexOutOfBoundsException.
• A new int[5] is filled with zeros, not left empty.

Объект ArrayList представляет собой динамический список, который увеличивается и уменьшается при добавлении или удалении элементов. Он хранит объекты, поэтому необходимо использовать тип-обертку, такой как Integer (а не int). Часть <Integer> является параметром типа (generic type). Ключевые методы: .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(...), а не те, которые применяются к обычным массивам ([]).
• Удаление элементов при обходе вперед по индексу пропускает следующий элемент (ошибка remove). Двигайтесь назад или используйте итератор.
• Храните объекты, а не примитивы: используйте ArrayList<Integer>, и Java автоматически выполняет автоупаковку (auto-boxing) значений int.

Класс — это чертеж для объектов. Его поля хранят данные, конструктор создает новый объект, а методы описывают действия. 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;
    }
}

Инкапсуляция означает сокрытие данных за методами. Объявите поля 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 (инкапсуляция).

Inheritance 继承 lets a subclass 子类 reuse a superclass 父类. Write class Cat extends Animal and Cat gets Animal's fields and methods for free. Call the parent constructor with 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"); }
}

A subclass can override 重写 a method to replace the parent's version. Polymorphism 多态 means a Shape variable can hold any subtype, and Java picks the right toString at run time. System.out.println(obj) automatically calls 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
}

Common mistakes

• An overriding method must match the signature exactly; add @Override so the compiler catches slips.
• super(...) must be the first line of a subclass constructor.
• A subclass object IS-A superclass object, but not the other way round.

Рекурсия — это метод, вызывающий сам себя. Каждая рекурсия требует базового случая (когда остановиться) и рекурсивного вызова, который приближает решение к базовому случаю. Без базового случая она никогда не остановится и завершится ошибкой переполнения стека (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) выполняет основную работу; рекурсия лишь делит массив.

Линейный поиск проверяет каждый элемент — работает с любым массивом. Бинарный поиск намного быстрее, но требует отсортированного массива: он смотрит на середину, а затем отбрасывает половину на каждом шаге. Оба возвращают индекс или -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 читает текст построчно. Для работы с реальным файлом вы пишете 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 — Проектирование классов: напишите полный класс (поля, конструктор, методы) на основе описания.
• Q3 — Массив / ArrayList: обработать 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() перед чтением, чтобы не выйти за пределы файла.
• В FRQ внимательно читайте заголовок метода: точно совпадайте с возвращаемым типом и параметрами.