Эта страница требует современного браузера (с поддержкой SharedArrayBuffer). Пожалуйста, обновите Chrome, Edge, Firefox или Safari до последней версии.
1Основы Java
1.1
Классы, main и output
Этот сайт компилирует Java, используя правила языка 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.");
}
}
Java компилируется: компилятор проверяет всю программу, затем она выполняется.
Объявления, присваивания, вызовы методов и операторы return заканваются точкой с запятой ;. Блок if, for или while использует фигурные скобки; не добавляйте точку с запятой только потому, что она стоит после закрывающей скобки.
Этот автономный пример Java 8 определяет main внутри класса
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
Арифметика и присваивание
Арифметика 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);
}
}
int/int усечено; используйте double для точного результата
2.2
Использование объектов: String, Math, обёртки
Некоторые значения являются объектами с методами. 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 — ложную ветку
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 выбирает из множества фиксированных значений. Используйте 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, break, return или throw могут остановить fall-through (продолжение выполнения). Достижение следующей ветки без одного из них продолжает выполнение там.
&& и || используют short-circuit (короткое замыкание). & и | выполняют побитовые операции над целыми числами; с логическими типами они вычисляют оба операнда.
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 проверяет условие перед каждым проходом тела
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 сортирует строки в лексикографическом порядке — на экзамене 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
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
}
}
Когда вы строите длинную строку в цикле, 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.
6Массивы
6.1
Массивы 1-мерные
Массив хранит фиксированное количество значений одного типа. Индексы начинаются с 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-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
}
}
Распространенные ошибки
Размер массива равен a.length (без скобок и без ()), и он фиксирован в момент создания.
Допустимые индексы находятся в диапазоне от 0 до a.length - 1; обращение к индексу a[a.length] вызывает исключение ArrayIndexOutOfBoundsException.
Новый int[5] заполняется нулями, а не остается пустым.
7ArrayList
7.1
Основы ArrayList
Объект 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]
}
}
ArrayList: add, get, size на динамическом списке
7.2
Алгоритмы ArrayList и ошибка remove
Метод .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.
8Написание классов
8.1
Поля, конструктор и методы
Класс — это чертеж для объектов. Его поля хранят данные, конструктор создает новый объект, а методы описывают действия. 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;
}
}
Поля хранят состояние; конструктор создает; методы выполняют действия
8.2
Инкапсуляция
Инкапсуляция управляет доступом к состоянию объекта. Объявите поля private, чтобы запретить прямой доступ из несвязанных классов; аксессор (getter) читает состояние, а мутатор изменяет его. Сеттер является одним из видов мутаторов. private не проверяет корректность значений: конструкторы и мутающие методы требуют собственных проверок или заявленных предусловий. Данный пример предполагает неотрицательное значение start и сложения, укладывающиеся в диапазон int; его метод deposit отклоняет неположительные суммы.
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;
}
}
Распространенные ошибки
Конструктор имеет имя класса и не имеет возвращаемого типа (даже не void).
Используйте this.field, чтобы отличить поле от параметра с тем же именем.
Сделайте поля private и обращайтесь к ним через методы getter/setter (инкапсуляция).
9Наследование и полиморфизм
9.1
Наследование
Наследование позволяет подклассу переиспользовать суперкласс. Запишите 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"); }
}
Cat и Dog наследуют Animal: они унаследовали его члены и добавили свои собственные
9.2
Полиморфизм и toString
Подкласс может переопределить метод, заменив версию родителя. Полиморфизм означает, что переменная типа 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 объекту родительского класса, но не наоборот.
10Рекурсия
10.1
Рекурсия
Рекурсия — это метод, вызывающий сам себя. Каждая рекурсия требует базового случая (когда остановиться) и рекурсивного вызова, который приближает решение к базовому случаю. Без базового случая она никогда не остановится и завершится ошибкой переполнения стека (stack overflow).
Стек вызовов для 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) выполняет основную работу; рекурсия лишь делит массив.
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;
}
}
Бинарный поиск уменьшает диапазон вдвое на каждом шаге, поэтому отсортированный массив searched за 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]
}
}
Как сравниваются скорости:
Алгоритм
Время
линейный поиск
O(n)
бинарный поиск
O(log n), только для отсортированных массивов
выборочная / сортировка вставками
O(n²)
сортировка слиянием (тема 10)
O(n log n)
Распространенные ошибки
Бинарный поиск работает только с отсортированным массивом.
Линейный поиск занимает O(n); бинарный поиск занимает O(log n), но требует предварительной сортировки.
Выборочная и сортировка вставками занимают O(n²) — легко изучаются, но медленны на больших объемах данных.
12Файлы и вопросы FRQ
12.1
Текстовые файлы и 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 читает строки, пока hasNextLine возвращает true
12.2
Типы вопросов FRQ экзамена AP
Экзамен 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 внимательно читайте заголовок метода: точно совпадайте с возвращаемым типом и параметрами.