Programación · Davante MEDAC · Temas 1–9
Java по-человечески
Все девять тем первого экзамена. Объясняю с нуля, на примерах из жизни и на коде, который можно запустить. Каждое важное слово — по-русски и по-испански, потому что экзамен будет на испанском.
Как читать этот учебник
Здесь нет ничего, чего не было в «Guía de estudio T1–T9» от Natalia. Порядок тот же, примеры в её стиле, код только из того, что проходили. Но объяснения другие: сначала «зачем это вообще нужно», потом «как это устроено», потом код и что он выведет.
Как темы связаны между собой
Темы идут не просто списком, каждая опирается на предыдущую. Если что-то непонятно в теме 8, почти всегда причина в теме 2 или 4.
- Что такое программа и алгоритм. Рецепт, который выполняет компьютер.
- Где программа хранит данные. Переменные, типы, операторы, ввод с клавиатуры.
- Как программа принимает решения и повторяет действия. if, switch, циклы.
- Как разбить большую программу на кусочки. Методы, параметры, return.
- Метод, который вызывает сам себя. Рекурсия и стек вызовов.
- Как хранить много данных сразу. Массивы, поиск, сортировка, строки.
- Новый способ думать: объекты. Класс как чертёж, объект как вещь.
- Как объекты живут в памяти. new, ссылки, null, this, toString.
- Как написать правильный класс. Конструкторы, private, get/set, static, enum.
«No memorices el código. Léelo, entiende qué hace cada línea y después intenta escribirlo tú sin mirar.»
Не зубри код. Прочитай, пойми, что делает каждая строка, а потом попробуй написать сам, не подглядывая. Весь этот учебник построен под этот совет.
Введение в программирование
Introducción a la programación
Программировать — значит дать компьютеру точный список шагов (алгоритм), который превращает входные данные в результат.
«Programar es darle al ordenador una lista de instrucciones precisas (un algoritmo) para que transforme unos datos de entrada en un resultado de salida.»
Компьютер очень быстрый, но совсем не умный. Он не догадывается, что ты имел в виду. Он делает ровно то, что написано, в том порядке, в каком написано. Поэтому вся первая тема о том, как думать «по-компьютерному»: разбивать задачу на маленькие однозначные шаги.
Данные и информация
Начнём со слов, которые кажутся одинаковыми, но на экзамене их различают.
- Данноеdato — отдельное значение без контекста. Число
20. Слово «Galaxy». Само по себе почти ничего не говорит: 20 чего? градусов? евро? - Информацияinformación — то, что получается, когда данные обработали, упорядочили и объяснили: «самый продаваемый товар — Galaxy S23, продано 20 штук». Вот теперь
20что-то значит. - Из информации люди строят знаниеconocimiento: «значит, нужно заказать ещё Galaxy». Это делает уже человек, а не компьютер.
Информатикаinformática — это как раз всё, что нужно знать, чтобы компьютер обрабатывал информацию автоматически.
Твой фитнес-браслет записывает данные: пульс 72, 75, 140, 138… Приложение превращает их в информацию: «вчера ты 40 минут был в зоне кардио». А решение «завтра отдохну» — это уже знание, его делаешь ты.
Как компьютер обрабатывает данные
Любая программа, от калькулятора до Instagram, работает по одной схеме из трёх шагов:
| Шаг | Что это | Пример: сложить два числа |
|---|---|---|
| Входentrada | Что мы даём машине | Набираем на клавиатуре 3 и 4 |
| Обработкаunidad de proceso | Где данные превращаются в результат | Процессор считает 3 + 4 |
| Выходsalida | Результат | На экране появляется 7 |
Ещё три пары слов, которые часто путают:
- Железоhardware — всё, что можно потрогать: экран, процессор, оперативная память (RAM). Программное обеспечениеsoftware — то, что потрогать нельзя: программы.
- Программаprograma — инструкции, которые лежат на диске «в покое», как рецепт в книге. Процессproceso — та же программа в момент, когда она выполняется в процессоре, как рецепт, по которому прямо сейчас готовят.
У тебя на ноутбуке установлен Chrome, но он закрыт. Это программа или процесс? А когда ты его открыл?
Закрытый — программа (лежит на диске). Открытый — процесс (выполняется). В Диспетчере задач Windows как раз видны процессы.
Языки программирования: от нулей и единиц до Java
Процессор понимает только 0 и 1. Человеку так писать почти невозможно. Поэтому придумали языки, которые всё ближе к человеческому:
| Язык | Как выглядит | Плюс / минус |
|---|---|---|
| Машинныйlenguaje máquina | 10110000 01100001 | Процессор понимает сразу. Но писать очень трудно, и код работает только на одном типе процессора. |
| Ассемблерensamblador | Короткие команды: SUB — вычесть, MOV — переместить | Чуть легче, но это всё ещё низкий уровеньbajo nivel: думаешь как процессор. |
| Высокого уровняalto nivel | Похоже на английский: Java, C, Python | Легко читать и писать. Но нужен переводчик в машинный код. |
По стилю языки бывают двух видов:
- Императивныеimperativos — ты говоришь как сделать, шаг за шагом. «Возьми первое число, прибавь второе, выведи». Java — императивный язык.
- Декларативныеdeclarativos — ты говоришь что хочешь получить, а не шаги. Сюда входят функциональныеfuncionales и логическиеlógicos языки.
Кто переводит код в нули и единицы
Есть два вида переводчиковtraductores:
- Компиляторcompilador переводит всю программу целиком, а потом её запускают. Как переводчик, который сначала переводит всю книгу, а потом ты её читаешь. Работает быстрее.
- Интерпретаторintérprete переводит и сразу выполняет по одной инструкции. Встретил ошибку — остановился на ней. Как синхронный переводчик на встрече. Медленнее, но удобнее для учёбы: сразу видно, где сломалось.
Синтаксис и семантика
- Синтаксисsintaxis — правила написания: где ставить
;, как закрывать{ }. Это «грамматика» языка. Нарушишь — программа даже не запустится. - Семантикаsemántica — смысл: что код делает на самом деле. Можно написать грамматически правильно, но не то. Например, вместо среднего посчитать сумму.
Программа скомпилировалась без ошибок — это значит, что синтаксис правильный. Это не значит, что она правильно работает. Семантические ошибки компилятор не ловит.
Эффективная и действенная программа
- Действеннаяeficaz — работает: делает то, что должна. Средняя оценка посчитана правильно.
- Эффективнаяeficiente — делает это хорошо: быстро и тратит мало ресурсов (времени и памяти).
Программа может быть eficaz, но не eficiente: считает правильно, но 10 минут. Хорошая программа и то, и другое.
Алгоритм — сердце темы
Алгоритмalgoritmo — конечный упорядоченный набор чётко определённых инструкций, которые решают задачу, если выполнять их шаг за шагом. У него есть вход, обработка и выход.
Лучшая аналогия — рецепт. «Вскипяти воду. Брось макароны. Вари 10 минут. Слей воду». Но рецепт для людей часто неточный: «посоли по вкусу». Компьютеру «по вкусу» не подходит, ему нужно «5 грамм соли».
Характеристики хорошего алгоритма:
| Свойство | Что значит | Плохой пример |
|---|---|---|
| Точныйpreciso | Указан порядок каждого шага | «Свари и посоли» — что сначала? |
| Определённыйdefinido | Нет двусмысленности | «Добавь немного соли» |
| Конечныйfinito | Когда-нибудь заканчивается | «Мешай, пока не надоест» |
| Детерминированныйdeterminista | С теми же входными данными всегда тот же результат | «Добавь случайное количество соли» |
| Независимый от языка | Один и тот же алгоритм можно написать на Java, Python, C | — |
Два самых важных свойства, их спрашивают отдельно: конечность и детерминизм (finitud y determinismo). Решение, которое может их не выполнять, называется полуалгоритмsemialgoritmo.
Сложность: насколько алгоритм быстрый
Сложностьcomplejidad показывает, как растёт работа, когда растёт количество данных n. Записывается как O(n). Например, найти имя в неотсортированном списке из n имён — в худшем случае придётся посмотреть все n, это O(n).
- Временная сложностьcomplejidad temporal — сколько времени.
- Пространственная сложностьcomplejidad espacial — сколько памяти.
Подробнее с примерами это будет в теме 6 (поиск и сортировка).
Как записать алгоритм до кода
Прежде чем писать на Java, алгоритм рисуют или пишут простыми словами. Так проще найти ошибку в логике.
Блок-схема
Блок-схемаdiagrama de flujo — рисунок из фигур и стрелок. Каждая фигура что-то значит:
| Фигура | Значение |
|---|---|
| Овалóvalo | Начало или конец |
| Прямоугольникrectángulo | Действие, вычисление |
| Ромбrombo | Решение: да / нет |
| Параллелограммparalelogramo | Ввод или вывод данных |
| Стрелкаflecha | Порядок выполнения |
Ромб — это всегда решение (sí/no), а параллелограмм — ввод/вывод. Их часто путают в тестах.
Псевдокод
Псевдокодpseudocódigo — алгоритм, записанный обычным языком по простым правилам. Занимает меньше места, чем схема, хорошо показывает повторения, и его очень легко перевести в настоящий код. Пример: сложить два числа с клавиатуры.
Inicio
Leer numero1
Leer numero2
suma ← numero1 + numero2
Escribir suma
FinСтрелка ← значит «положить значение в»: в suma кладём сумму. Leer — прочитать с клавиатуры, Escribir — вывести на экран.
Жизненный цикл программы
Программа не появляется сразу в виде кода. Она проходит жизненный цикл ПОciclo de vida del software из шести фаз. Представь, что тебе заказали приложение для записи в спортзал.
| Фаза | Вопрос | Что делают (спортзал) |
|---|---|---|
| Анализanálisis | ¿Qué? Что? | Список требований: клиент записывается на тренировку, видит расписание, отменяет запись. |
| Спецификацияespecificación | Подробное описание поведения: «отменить можно не позже, чем за 2 часа». | |
| Проектированиеdiseño | ¿Cómo? Как? | Придумывают алгоритмы: псевдокод, диаграммы классов. |
| Реализацияimplementación | Пишут исходный код на Java. | |
| Тестированиеpruebas | Ищут ошибки. Цель — найти, где программа ломается, а не убедиться, что работает. | |
| Сопровождениеmantenimiento | Исправления и изменения после запуска. Это 80 % всего цикла. |
Классический вопрос: «в какой фазе отвечают на ¿qué?, а в какой на ¿cómo?». ¿Qué? — análisis. ¿Cómo? — diseño. И запомни цифру 80 % для mantenimiento.
Инструменты
Чтобы программировать, в принципе хватит текстового редактора, компилятора и командной строки. Но обычно используют IDE (среду разработки)IDE, Entorno de Desarrollo Integrado — например, NetBeans. В ней всё вместе: редактор, компилятор, отладчикdepurador, автодополнение и подсветка ошибок.
Первая программа на Java
Вот самая маленькая программа. Каждую строку стоит понимать, потому что дальше она будет во всех примерах.
public class HolaMundo { // класс; файл должен называться HolaMundo.java
public static void main(String[] args) { // main: отсюда начинается выполнение
System.out.println("Hola mundo"); // инструкция: вывести текст
} // конец метода main
} // конец классаHola mundo
public class HolaMundo— в Java весь код живёт внутри классаclase. Имя класса и имя файла совпадают.public static void main(String[] args)— главный методmétodo main. Когда нажимаешь «Run», Java ищет именно его и начинает с первой строки внутри.System.out.println(...)— напечатать в консоль и перейти на новую строку.- Каждая инструкция заканчивается на
;. Каждая открытая{должна закрыться}.
Слова public, static, void пока просто запомни как «так надо». Что они значат, разберём в темах 4 и 9.
Проверь себя · Comprueba si lo sabes
¿Qué diferencia hay entre un dato y la información?Чем данное отличается от информации?
Un dato es un valor suelto sin contexto; la información es el resultado de procesar e interpretar los datos.
Данное — отдельное значение без контекста (20). Информация — результат обработки и объяснения данных («продано 20 телефонов»).
¿Cuáles son las dos características fundamentales de un algoritmo?Какие два главных свойства алгоритма?
Finitud (termina) y determinismo (mismos datos, mismo resultado).
Конечность — он заканчивается. Детерминизм — с теми же данными всегда тот же результат.
¿Qué diferencia hay entre un compilador y un intérprete?Чем компилятор отличается от интерпретатора?
El compilador traduce todo el programa antes de ejecutarlo; el intérprete traduce y ejecuta instrucción a instrucción y se para en el primer error.
Компилятор переводит всё сразу, потом запускают (быстрее). Интерпретатор переводит и выполняет по одной строке и останавливается на первой ошибке.
¿En qué fase del ciclo de vida se responde a «¿qué?» y en cuál a «¿cómo?»?В какой фазе отвечают на «что?», а в какой на «как?»?
«¿Qué?» en el análisis; «¿cómo?» en el diseño.
«Что?» — анализ. «Как?» — проектирование.
Explica la diferencia entre eficacia y eficiencia con un ejemplo.Объясни разницу между eficacia и eficiencia на примере.
Eficaz: el programa calcula bien la media. Eficiente: además lo hace rápido y gastando poca memoria.
Eficaz — правильно считает среднее. Eficiente — ещё и быстро, и тратит мало памяти.
Словарик темы
| По-русски | En español | Что это, коротко |
|---|---|---|
| данное | dato | отдельное значение без контекста |
| информация | información | обработанные и объяснённые данные |
| вход / выход | entrada / salida | что даём программе / что она возвращает |
| программа | programa | инструкции «в покое», на диске |
| процесс | proceso | программа в момент выполнения |
| компилятор | compilador | переводит всю программу сразу |
| интерпретатор | intérprete | переводит и выполняет по одной инструкции |
| синтаксис | sintaxis | правила написания кода, «грамматика» |
| семантика | semántica | смысл кода: что он делает на самом деле |
| действенный | eficaz | делает то, что должен |
| эффективный | eficiente | делает быстро и тратит мало ресурсов |
| алгоритм | algoritmo | конечный упорядоченный набор шагов, решающий задачу |
| конечность | finitud | алгоритм обязательно заканчивается |
| детерминизм | determinismo | одинаковые данные → одинаковый результат |
| сложность | complejidad | как растёт работа с ростом данных, O(n) |
| блок-схема | diagrama de flujo | алгоритм в виде фигур и стрелок |
| псевдокод | pseudocódigo | алгоритм обычными словами по правилам |
| жизненный цикл ПО | ciclo de vida del software | анализ, спецификация, проектирование, реализация, тесты, сопровождение |
| сопровождение | mantenimiento | исправления после запуска, 80 % цикла |
| среда разработки | IDE (Entorno de Desarrollo Integrado) | редактор + компилятор + отладчик вместе, например NetBeans |
| отладчик | depurador | инструмент, чтобы искать ошибки по шагам |
Элементы программы
Elementos de un programa
Программа хранит данные в переменных и константах определённого типа и работает с ними с помощью операторов.
«Un programa guarda los datos en variables y constantes de un tipo concreto, y opera con ellos usando operadores.»
Если тема 1 была про «что такое программа», то тема 2 — про её кирпичики. Без них не напишешь ни одной строки: каждый пример дальше состоит из переменных, типов и операторов.
Блоки и имена
Блокbloque — кусок кода между фигурными скобками { }. В программе есть два больших блока: блок объявленийbloque de declaración, где создаются переменные и константы, и блок инструкцийbloque de instrucciones, где с ними что-то делают.
Идентификаторidentificador — имя, которое ты даёшь чему-то: переменной, константе, методу. Правила:
- Начинается с буквы:
edadможно,1edadнельзя. - Без пробелов:
nota mediaнельзя,notaMediaможно. - Не повторяется и не совпадает со служебным словомpalabra reservada:
int,class,if,while… Их Java уже занял. - Говорящее:
notaMediaлучше, чемx. Через месяц ты сам не вспомнишь, что такоеx.
В Java имена переменных и методов пишут в стиле camelCasecamelCase: первое слово с маленькой, каждое следующее с большой — precioFinal, numeroDeAlumnos.
Переменная — коробка с подписью
Переменнаяvariable — место в памяти с именем, где лежит значение, которое может меняться. Представь коробку с наклейкой «edad». Внутри лежит 17. На день рождения ты достаёшь 17 и кладёшь 18. Коробка та же, содержимое новое.
У переменной три шага жизни:
- Объявлениеdeclaración: тип + имя. Java резервирует коробку нужного размера.
int edad; - Инициализацияinicialización: кладём первое значение.
edad = 17; - Использованиеutilización: читаем и меняем сколько угодно раз.
edad = edad + 1;
Первые два шага можно сделать одной строкой: int edad = 17;
Константаconstante — значение, которое не меняется никогда. В Java её объявляют словом final. Имена констант принято писать БОЛЬШИМИ буквами.
int edad = 17; // переменная: может меняться
final double PI = 3.1416; // константа: не может меняться
final String SALUDO = "¡Hola!";
String nombre = "Lucía";
boolean mayorDeEdad = edad >= 18; // false, потому что 17 >= 18 — неправдаВ интернет-магазине количество товара в корзине — переменная (добавляешь, удаляешь). Ставка IVA 21 % — константа: она одинаковая для всех расчётов, и если она случайно изменится посреди программы, все цены станут неправильными. final защищает от такой ошибки: компилятор просто не даст её изменить.
Типы данных: какого размера коробка
Java должен заранее знать, что лежит в коробке: целое число, дробное, буква или текст. От этого зависит, сколько памяти выделить и что с этим можно делать.
- Простые (примитивные) типыtipos simples o primitivos — нельзя разделить на части: целые, дробные, символ, логический.
- Составные типыtipos estructurados — состоят из других: массивы,
String…
| Группа | Тип | Хранит | Пример |
|---|---|---|---|
| Целыеenteros | byte, short, int, long | Числа без дробной части | int edad = 17; |
| Дробныеreales | float, double | Числа с дробной частью | double nota = 7.5; |
| Символcarácter | char | Один символ, в одинарных кавычках | char letra = 'A'; |
| Строкаcadena | String | Текст, в двойных кавычках | String nombre = "Ana"; |
| Логическийlógico | boolean | Только true или false | boolean aprobado = true; |
Чем точнее тип, тем больше памяти он занимает. На практике почти всегда хватает int для целых и double для дробных.
'A'(одинарные кавычки) — этоchar, один символ."A"(двойные) — этоString, текст, пусть и из одной буквы.- В Java дробная часть пишется через точку:
7.5, а не7,5. Stringпишется с большой буквы, потому что это класс, а не примитивный тип.
Операторы: что можно делать с данными
Выражениеexpresión — комбинация переменных, констант, операторов и скобок, которая даёт одно значение. precio * 2 + 5 — выражение.
Арифметические
+ сложение, - вычитание, * умножение, / деление, % остаток от деления, ++ прибавить 1, -- отнять 1.
Самые коварные — / и %. Если оба числа целые (int), деление тоже целое: дробная часть просто отбрасывается.
System.out.println(17 / 5); // 3 — сколько раз 5 целиком помещается в 17
System.out.println(17 % 5); // 2 — что осталось: 17 - 5*3 = 2
System.out.println(17.0 / 5); // 3.4 — одно из чисел дробное, значит и результат дробный3 2 3.4
- Чётное или нечётное: если
numero % 2 == 0— чётное. - Минуты в часы: 135 минут →
135 / 60= 2 часа и135 % 60= 15 минут. - Последняя цифра числа:
1234 % 10= 4.
Операторы сравнения
Операторы сравненияoperadores relacionales сравнивают два значения и всегда отвечают true или false: == равно, != не равно, > больше, < меньше, >= больше или равно, <= меньше или равно.
= — это «положить значение» (присвоить). == — это «сравнить». if (edad = 18) — ошибка, нужно if (edad == 18).
Логические операторы
Логические операторыoperadores lógicos соединяют условия. Работают только с boolean.
&&— И (AND). Истина, только если оба условия истинны. «Пускаем в клуб, если тебе 18+ и у тебя есть билет».||— ИЛИ (OR). Истина, если хотя бы одно истинно. «Скидка, если ты студент или пенсионер».!— НЕ (NOT). Переворачивает значение.!true— этоfalse.
| a | b | a && b | a || b | !a |
|---|---|---|---|---|
| true | true | true | true | false |
| true | false | false | true | false |
| false | true | false | true | true |
| false | false | false | false | true |
Сокращённое присваивание и тернарный оператор
a += b — то же самое, что a = a + b. Так же работают -=, *=, /=, %=. Пишут так, потому что короче: total += precio; — «добавь цену к сумме».
Тернарный операторoperador ternario — это if-else в одну строку: condición ? valorSiVerdadero : valorSiFalso.
String resultado = (nota >= 5) ? "Aprobado" : "Suspenso";Читается так: «nota больше или равна 5? Если да — "Aprobado", иначе — "Suspenso"».
++x и x++: в чём разница
Оба прибавляют 1. Разница только в том, когда, если это стоит внутри другой инструкции.
- Преинкрементpreincremento
++x: сначала прибавь, потом используй. - Постинкрементpostincremento
x++: сначала используй старое значение, потом прибавь.
int x = 10;
System.out.println(x); // 10
x++; // x = 11 (одна инструкция — разницы нет)
System.out.println(++x); // сначала +1 → 12, печатает 12
System.out.println(x++); // сначала печатает 12, потом x становится 13
System.out.println(x); // 1310 12 12 13
Что напечатает int a = 5; System.out.println(a++ + 1);? А чему будет равно a после этого?
Напечатает 6 (взяли старое 5, прибавили 1), а a станет 6.
Приведение типов (casting)
Приведение типовcasting — превращение значения одного типа в другой. Представь, что переливаешь воду из стакана в ведро и обратно.
- Неявное (upcasting)implícito (upcasting) — из маленького типа в большой:
int → double. Как из стакана в ведро: всё помещается, ничего не теряется. Java делает это сам. - Явное (downcasting)explícito (downcasting) — из большого в маленький:
double → int. Как из ведра в стакан: что-то может пролиться. Поэтому Java требует, чтобы ты написал это явно в скобках, мол, «я знаю, что делаю». Дробная часть теряется.
int entero = 7;
double real = entero; // неявное: real = 7.0
double nota = 7.9;
int notaEntera = (int) nota; // явное: notaEntera = 7 (дробь отрезана, НЕ округлена)(int) 7.9 — это 7, а не 8. Приведение отрезает дробную часть, а не округляет. Для округления есть Math.round (тема 4).
Где это нужно: посчитать среднее. suma / cantidad с двумя int даст целое число. Поэтому пишут (double) suma / cantidad — тогда деление будет дробным.
Комментарии и API
Комментарииcomentarios объясняют код людям. Java их не выполняет. // одна строка и /* несколько строк */.
API JavaAPI de Java — огромная библиотека готовых классов, разложенных по пакетамpaquetes. Не нужно самому писать квадратный корень: он уже есть в java.lang.Math. А чтение с клавиатуры — в java.util.Scanner.
Ввод с клавиатуры и вывод на экран
Программа, которая ничего не спрашивает у пользователя, скучная. Для ввода используют класс Scanner.
import java.util.Scanner; // 1. подключаем класс Scanner
public class Ejemplo {
public static void main(String[] args) {
Scanner lectura = new Scanner(System.in); // 2. создаём «читателя» клавиатуры
System.out.print("Introduce un número: "); // print: без перехода на новую строку
int numero = lectura.nextInt(); // 3. ждём, пока пользователь введёт число
System.out.println("Has escrito " + numero); // println: с переходом на новую строку
}
}Introduce un número: 42 Has escrito 42
Почему print, а не println в вопросе? Чтобы курсор остался на той же строке и число вводилось рядом с вопросом. А + между текстом и числом склеивает их в одну строку.
| Метод Scanner | Читает |
|---|---|
nextInt() | Целое число |
nextDouble() | Дробное число |
nextLine() | Всю строку текста целиком |
next() | Одно слово (до пробела) |
После nextInt() следующий nextLine() «проскакивает» и возвращает пустую строку. Причина: в буфере остался Enter, который ты нажал после числа. Решение: поставить лишний lectura.nextLine(); сразу после nextInt().
Пример целиком: чётное или нечётное
import java.util.Scanner;
public class ParImpar {
public static void main(String[] args) {
Scanner lectura = new Scanner(System.in);
System.out.print("Introduce un número: ");
int numero = lectura.nextInt();
if (numero % 2 == 0) { // остаток от деления на 2 равен 0?
System.out.println("Es par");
} else {
System.out.println("Es impar");
}
}
}Introduce un número: 7 Es impar
if подробно будет в теме 3, но идея уже понятна: если условие в скобках истинно, выполняется первый блок, иначе второй.
Проверь себя · Comprueba si lo sabes
¿Qué diferencia hay entre una variable y una constante? ¿Cómo se declara una constante en Java?Чем переменная отличается от константы? Как объявить константу?
La variable puede cambiar de valor; la constante no. Se declara con final: final double PI = 3.1416;
Переменная может менять значение, константа — нет. Объявляется словом final.
¿Qué diferencia hay entre char y String?Чем char отличается от String?
char guarda un solo carácter entre comillas simples; String guarda texto entre comillas dobles.
char — один символ в одинарных кавычках 'A'. String — текст в двойных "Ana".
¿Cuánto vale 17 % 5? ¿Y 17 / 5 si los dos son int?Сколько будет 17 % 5? А 17 / 5, если оба int?
17 % 5 = 2. 17 / 5 = 3 (división entera).
Остаток 2. Целочисленное деление даёт 3, дробь отбрасывается.
¿Cuál es el resultado de true && false? ¿Y de true || false?Что даст true && false? А true || false?
true && false = false. true || false = true.
И требует, чтобы оба были true → false. ИЛИ достаточно одного true → true.
¿Qué tipo de casting es int n = (int) 4.8; y cuánto vale n?Какой это casting и чему равно n?
Casting explícito (downcasting). n vale 4.
Явное приведение (из большого в маленький). n = 4: дробь отрезается, не округляется.
Словарик темы
| По-русски | En español | Что это, коротко |
|---|---|---|
| блок | bloque | код между фигурными скобками { } |
| идентификатор | identificador | имя переменной, константы или метода |
| служебное слово | palabra reservada | слово, занятое Java: int, class, if… |
| переменная | variable | место в памяти с именем, значение меняется |
| константа | constante | значение не меняется, объявляется с final |
| объявление | declaración | тип + имя, резервирует память |
| инициализация | inicialización | первое значение переменной |
| тип данных | tipo de dato | что хранится: int, double, char, String, boolean |
| примитивный тип | tipo primitivo (simple) | неделимый тип: int, double, char, boolean |
| строка | cadena (String) | текст в двойных кавычках |
| выражение | expresión | комбинация значений и операторов, дающая одно значение |
| остаток от деления | resto (%) | что остаётся после целочисленного деления |
| операторы сравнения | operadores relacionales | ==, !=, >, <, >=, <=; дают true/false |
| логические операторы | operadores lógicos | && (И), || (ИЛИ), ! (НЕ) |
| тернарный оператор | operador ternario | if-else в одну строку: cond ? a : b |
| преинкремент / постинкремент | preincremento / postincremento | ++x сначала прибавляет; x++ сначала использует |
| приведение типов | casting | превращение значения в другой тип |
| неявное приведение | implícito (upcasting) | из маленького типа в большой, делает Java сам |
| явное приведение | explícito (downcasting) | из большого в маленький, пишешь (int); теряются данные |
| комментарий | comentario | пояснение для людей, Java его не выполняет |
| пакет | paquete | папка с родственными классами, например java.util |
| чтение с клавиатуры | Scanner (lectura) | класс для ввода: nextInt, nextDouble, nextLine, next |
Структурное программирование
Programación estructurada
Любую программу можно собрать всего из трёх конструкций: последовательность, выбор (решить) и повторение (цикл).
«Cualquier programa se puede construir combinando solo tres estructuras: secuencia, selección (decidir) e iteración (repetir).»
Подумай о своём утре. Ты делаешь шаги по порядку: проснулся, умылся, оделся (последовательность). Смотришь в окно: если дождь — берёшь зонт, иначе нет (выбор). Чистишь зубы: двигаешь щёткой, пока не пройдут 2 минуты (повторение). Вот и всё. Вся логика любой программы — это эти три вещи, вложенные друг в друга.
Теорема о структуре
Теорема о структуреteorema de la estructura: любую программу можно написать, используя только последовательностьsecuencia, выборselección и повторениеiteración, без хаотичных прыжков по коду. Эту идею продвигал Дейкстра (Dijkstra) в конце 60-х.
- Плюсы: код легче читать, отлаживать и менять; меньше усилий на тесты и дешевле сопровождение.
- Минус: всё лежит в одном большом блоке, и когда программа растёт, его тяжело поддерживать. Эту проблему решает модульное программирование (тема 4).
Поток выполненияflujo de ejecución — порядок, в котором выполняются инструкции. По умолчанию сверху вниз. Управляющие конструкцииestructuras de control позволяют этот порядок менять: пропустить кусок или повторить.
Выбор: программа принимает решения
Простой if
Простой выборselección simple: если условие выполняется — делаем блок. Если нет — пропускаем его.
if (temperatura > 30) {
System.out.println("Bebe agua");
}
System.out.println("Fin"); // выполнится в любом случаеif-else: два пути
Двойной выборselección doble: один путь, если условие истинно, другой — если ложно. Ровно один из двух блоков выполнится всегда.
if (nota >= 5) {
System.out.println("Aprobado");
} else {
System.out.println("Suspenso");
}if-else if: лестница условий
Вложенный выборselección anidada: проверяем условия по очереди. Как только одно оказалось истинным, остальные даже не проверяются.
if (nota >= 9) {
System.out.println("Sobresaliente");
} else if (nota >= 7) {
System.out.println("Notable");
} else if (nota >= 5) {
System.out.println("Aprobado");
} else {
System.out.println("Suspenso");
}Пройдём руками для nota = 8: 8 >= 9? Нет. 8 >= 7? Да → печатаем «Notable» и выходим из всей лестницы. Условие >= 5 тоже истинно, но до него очередь не дойдёт.
Что будет, если поменять порядок и первым написать if (nota >= 5)?
Тогда и 8, и 10 получат «Aprobado»: первое же истинное условие заберёт их. Порядок важен: от самого строгого к самому мягкому.
Тернарный оператор
Тот же if-else, но в одну строку, когда нужно просто выбрать одно из двух значений:
String resultado = (nota >= 5) ? "Aprobado" : "Suspenso";Два способа проверить логин
Оба правильные. Это хороший пример того, как вложенные if и && делают одно и то же.
// Вариант 1: вложенные if
if (usuario.equals("admin")) {
if (clave.equals("1234")) {
System.out.println("Acceso correcto");
}
}
// Вариант 2: одно условие с &&
if (usuario.equals("admin") && clave.equals("1234")) {
System.out.println("Acceso correcto");
}Обрати внимание: строки сравнивают через .equals(), а не через ==. Почему — разберём в темах 6 и 8.
switch: выбор из многих вариантов
Множественный выборselección múltiple (switch) — когда переменная может иметь много конкретных значений, и для каждого нужно своё действие. Обычно это целое число или символ. Каждый случайcase заканчивается словом break.
switch (dia) {
case 1:
System.out.println("Lunes");
break;
case 2:
System.out.println("Martes");
break;
default: // если не подошёл ни один case
System.out.println("Día no válido");
}Если убрать break после case 1, то при dia = 1 напечатается «Lunes», а потом выполнение «провалится» дальше и напечатает ещё и «Martes». Java выполняет все case подряд, пока не встретит break или конец switch.
Меню в банкомате: 1 — снять деньги, 2 — баланс, 3 — сменить PIN. Каждая кнопка — свой case. Нажал что-то не то — default: «Opción no válida».
Циклы: повторяем, пока нужно
У любого циклаbucle есть три части: телоcuerpo (что повторяется), количество повторений и условие завершенияcondición de finalización. Если условие никогда не станет ложным, получится бесконечный циклbucle infinito — программа зависнет.
| Цикл | Когда проверяет условие | Минимум раз | Используй, когда… |
|---|---|---|---|
while | В начале | 0 | Не знаешь заранее, сколько раз повторять |
do-while | В конце | 1 | Нужно выполнить хотя бы один раз (меню, ввод данных) |
for | В начале, со счётчиком | 0 | Знаешь, сколько раз повторять |
while — «пока»
Сначала проверяет условие, потом выполняет тело. Если условие ложно с самого начала, тело не выполнится ни разу. Пример: складываем числа, пока не введут отрицательное.
int suma = 0;
int numero = lectura.nextInt();
while (numero >= 0) {
suma += numero;
numero = lectura.nextInt(); // переменная из условия меняется → цикл когда-нибудь закончится
}
System.out.println("Suma: " + suma);5 10 3 -1 Suma: 18
Если забыть строку numero = lectura.nextInt(); внутри цикла, numero никогда не изменится, и цикл станет бесконечным. Правило: внутри цикла должна меняться переменная из условия.
do-while — «сделай, а потом проверь»
Тело выполняется хотя бы один раз, а условие проверяется в конце. Идеально, когда нужно что-то спросить у пользователя и переспрашивать, пока ответ неправильный.
int n;
do {
System.out.print("Introduce un número positivo: ");
n = lectura.nextInt();
} while (n <= 0); // ← здесь ; обязательна!Introduce un número positivo: -3 Introduce un número positivo: 0 Introduce un número positivo: 8
С while пришлось бы спросить число один раз до цикла и ещё раз внутри. do-while убирает это повторение.
for — «столько-то раз»
Когда количество повторений известно. В скобках три части через ;: инициализацияinicialización; условиеcondición; шагpaso (incremento).
int suma = 0;
for (int i = 1; i <= 100; i++) { // начать с 1; пока i <= 100; после каждого круга i++
suma += i;
}
System.out.println(suma); // 5050Как это работает по шагам: i = 1 → проверка 1 <= 100 → тело → i++ (i = 2) → проверка → тело → … → i = 101 → проверка ложна → выход.
Таблица умножения на 7: точно 10 строк → for. Игра «угадай число», где не знаешь, с какой попытки угадают → while. Меню, которое показывается, пока не выберешь «Salir» → do-while.
Все три цикла взаимозаменяемы
Любую задачу можно решить любым циклом. Вот тот же for на 100 чисел, но через while:
int suma = 0;
int i = 1; // инициализация — до цикла
while (i <= 100) { // условие
suma += i;
i++; // шаг — в конце тела
}Видно, что for просто собирает три части в одной строке, чтобы не забыть ни одну.
Досрочный выход: break, continue, return
Операторы переходаsentencias de salto меняют обычный ход цикла:
break— выйти из цикла или из switch. В Java рекомендуется только в switch.continue— пропустить остаток этого круга и сразу перейти к следующему.return— выйти из метода и вернуть управление (и, если есть, значение) тому, кто его вызвал.goto— прыгнуть в любое место. Делает код хаотичным. В Java не используется.
Их использование не рекомендуется: код становится труднее читать и отлаживать. Хороший цикл заканчивается сам, по своему условию.
Проверь себя · Comprueba si lo sabes
¿Cuáles son las tres estructuras básicas de la programación estructurada?Какие три базовые конструкции?
Secuencia, selección e iteración.
Последовательность, выбор и повторение.
¿Qué diferencia hay entre while y do-while?Чем while отличается от do-while?
while comprueba la condición al principio (puede no ejecutarse nunca); do-while la comprueba al final (se ejecuta al menos una vez).
while проверяет в начале — может не выполниться ни разу. do-while проверяет в конце — выполнится минимум один раз.
¿Qué bucle usarías para mostrar la tabla de multiplicar del 7? ¿Por qué?Какой цикл для таблицы умножения на 7 и почему?
Un for, porque sabemos que hay que repetir 10 veces.
for, потому что точно знаем: 10 повторений.
¿Qué pasa si olvidas el break en un case del switch?Что будет, если забыть break в case?
Se siguen ejecutando los casos de debajo hasta encontrar un break o el final del switch.
Выполнение «провалится» в следующие case, пока не встретится break или конец switch.
¿Qué es un bucle infinito y cómo se evita?Что такое бесконечный цикл и как его избежать?
Un bucle cuya condición nunca deja de cumplirse. Se evita cambiando dentro del bucle la variable de la condición.
Цикл, условие которого всегда истинно. Избегаем, меняя внутри цикла переменную из условия.
Словарик темы
| По-русски | En español | Что это, коротко |
|---|---|---|
| теорема о структуре | teorema de la estructura | любая программа = последовательность + выбор + повторение |
| последовательность | secuencia | инструкции выполняются по порядку |
| выбор | selección | программа решает, какой блок выполнить (if, switch) |
| повторение | iteración | цикл: блок выполняется много раз |
| поток выполнения | flujo de ejecución | порядок, в котором выполняются инструкции |
| управляющая конструкция | estructura de control | то, что меняет порядок: if, switch, циклы |
| вложенный if | if anidado | if внутри другого if |
| множественный выбор | selección múltiple (switch) | выбор по конкретным значениям переменной |
| цикл | bucle | повторяющийся блок кода |
| тело цикла | cuerpo | то, что повторяется |
| условие завершения | condición de finalización | когда цикл должен остановиться |
| бесконечный цикл | bucle infinito | цикл, который никогда не заканчивается |
| операторы перехода | sentencias de salto | break, continue, return, goto |
Модульное программирование
Programación modular
«Разделяй и властвуй»: большая программа делится на маленькие модули (методы), у каждого одна понятная задача, и их можно использовать много раз.
«“Divide y vencerás”: partir un programa grande en módulos pequeños (métodos), cada uno con una tarea concreta, que se pueden reutilizar.»
Представь, что ты написал программу для кафе в 2000 строк, и всё внутри main. Где-то считается цена со скидкой, и ты нашёл там ошибку. Её нужно исправить в пяти местах, потому что этот кусок ты копировал пять раз. Одно место забыл — и в чеке неправильная сумма. Модульное программирование решает именно это: кусок пишется один раз, у него есть имя, и его вызывают по имени.
Что такое модуль
Модульное программированиеprogramación modular — делить программу на независимые подпрограммыsubprogramas (модули). Есть главная программаprograma principal (main), которая всем управляет и вызывает подпрограммы по очереди.
Каждый модуль работает как чёрный ящикcaja negra: получает данные, возвращает результат, а как он внутри устроен — тому, кто его вызывает, неважно. Ты пользуешься кофемашиной: засыпаешь зёрна, нажимаешь кнопку, получаешь кофе. Тебе не нужно знать, как там устроен насос.
Как делить задачу
- Нисходящее проектированиеdiseño descendente (top-down) — от общего к частному. «Организовать день рождения» → «пригласить гостей», «купить еду», «украсить комнату» → «купить еду» делим на «составить список», «сходить в магазин»… Пока каждый кусок не станет простым.
- Восходящее проектированиеdiseño ascendente (bottom-up) — наоборот: сначала делаем маленькие детали, потом собираем из них целое.
Зачем это всё
- Удобно работать в команде: каждый пишет свой модуль.
- Модули можно переиспользовать и экономить время.
- Тестировать проще: проверяешь каждый кусок отдельно.
- Меньше затрат на сопровождение и меньше ошибок (используешь уже проверенные модули).
- Дизайн программы понятнее.
Слишком много модулей — тоже плохо: растёт усилие, чтобы связать их между собой. Нужен баланс. Это любят спрашивать: «¿dividir en muchos módulos siempre es bueno?» — нет.
Процедура и функция
В языках без объектов подпрограммы называют процедурами и функциями. В объектно-ориентированных (Java) — методамиmétodos.
- Процедураprocedimiento — делает задачу и ничего не возвращает. В Java у неё тип
void(«пустота»). Например, напечатать приветствие. - Функцияfunción — делает задачу и возвращает значение через
return. Как функция в математике: даёшьx, получаешьy. Например, посчитать сумму. - Внутреннийinterno модуль лежит в том же файле, что и главная программа; внешнийexterno — в другом файле.
Из чего состоит метод
// модификаторы что возвращает имя формальные параметры
public static int sumar (int a, int b) {
int resultado = a + b; // локальная переменная
return resultado; // возвращаем int
}public static— модификаторыmodificadores. Пока просто пиши их у методов рядом сmain. Что они значат — в теме 9.int— тип возвращаемого значенияtipo de retorno. Если ничего не возвращаем —void.sumar— имя. Глагол в camelCase:calcularMedia,mostrarMenu.(int a, int b)— параметры: что метод получает на вход.return— отдаёт результат тому, кто вызвал, и сразу завершает метод.
Функция и процедура в одной программе
public class Calculadora {
public static int sumar(int a, int b) { // функция: возвращает int
return a + b;
}
public static void mostrarSaludo(String nombre) { // процедура: ничего не возвращает
System.out.println("Hola, " + nombre);
}
public static void main(String[] args) {
int total = sumar(3, 4); // 3 и 4 — фактические параметры
System.out.println(total);
mostrarSaludo("Marta");
}
}7 Hola, Marta
Обрати внимание: результат функции мы сохраняем (int total = sumar(3, 4);), а процедуру просто вызываем (mostrarSaludo("Marta");) — ей нечего вернуть.
Пишем один раз — вызываем много
public static void despegue() {
for (int i = 3; i >= 1; i--) {
System.out.println(i);
}
System.out.println("¡Despegue!");
}
public static void main(String[] args) {
despegue();
despegue();
despegue();
}Обратный отсчёт написан один раз, а работает три раза. Захочешь считать с 5 — поменяешь одну цифру в одном месте.
Где «живут» переменные
Область видимостиámbito (visibilidad) — где переменная существует и где её можно использовать.
- Локальная переменнаяvariable local — объявлена внутри подпрограммы и существует только в ней. Метод закончился — переменная исчезла. Два разных метода могут иметь локальные переменные с одинаковым именем, и они не мешают друг другу. Как два человека по имени Лена в разных квартирах.
- Глобальная переменнаяvariable global — объявлена в главной программе и видна везде. Опасна: её может изменить кто угодно, и если значение вдруг неправильное, очень трудно найти, кто его испортил. Их рекомендуют избегать.
Параметры: как передать данные в метод
- Формальные параметрыparámetros formales — те, что в определении метода, с типами:
sumar(int a, int b). Это «пустые места», которые заполнятся при вызове. - Фактические параметры (аргументы)parámetros reales (argumentos) — значения, которые реально передаёшь при вызове:
sumar(3, 4). Должны совпадать с формальными по количеству, типу и порядку.
Для метода saludar(String nombre, int edad) вызов saludar(17, "Ana") — ошибка: порядок перепутан. Java не догадается переставить.
Передача по значению и по ссылке
Это одна из самых важных идей всего курса, она вернётся в темах 6, 8 и 9.
| Способ | Что получает метод | Меняется оригинал? | В Java |
|---|---|---|---|
| По значениюpor valor | Копию значения | Нет | Примитивы: int, double, char, boolean… |
| По ссылкеpor referencia | Адрес в памяти (копию ссылки) | Да | Объекты и массивы |
Аналогия. По значению — ты даёшь другу ксерокопию своего конспекта. Он может на ней рисовать что угодно, твой оригинал чистый. По ссылке — ты даёшь другу адрес Google Docs. Он что-то поменял — поменялось и у тебя, потому что документ один.
// По значению: оригинал НЕ меняется
public static int test(int miValor) {
miValor = 799;
return miValor;
}
int num = 200;
int resultado = test(num);
System.out.println(num); // 200 — оригинал не тронут
System.out.println(resultado); // 799// По ссылке: оригинал МЕНЯЕТСЯ
public static void test(int[] miValor) {
miValor[0] = 799;
}
int[] num = {200, 100};
test(num);
System.out.println(num[0]); // 799 — массив изменился200 799 799
Перегрузка
- Перегрузка операторовsobrecarga de operadores — один и тот же оператор работает с разными типами.
+складывает числа (2 + 3→ 5) и склеивает тексты ("Ho" + "la"→ "Hola"). - Перегрузка методовsobrecarga de métodos — несколько методов с одним именем, но разными параметрами (по количеству или типу). Компилятор сам выбирает, какой вызвать, по тому, что ты передал.
public static int sumar(int a, int b) { return a + b; }
public static int sumar(int a, int b, int c) { return a + b + c; }
public static double sumar(double a, double b) { return a + b; }
sumar(2, 3); // первый: два int
sumar(2, 3, 4); // второй: три int
sumar(2.5, 1.5); // третий: два doubleSystem.out.println сам перегружен: ты передаёшь ему то int, то String, то double, и он всё печатает. Это не один метод, а несколько с одним именем.
Библиотеки: готовые функции
Библиотекиlibrerías — функции, которые язык уже дал тебе. Самые частые — в классе Math:
System.out.println(Math.sqrt(16)); // 4.0 — квадратный корень
System.out.println(Math.pow(2, 3)); // 8.0 — 2 в степени 3
System.out.println(Math.round(7.6)); // 8 — округление
double azar = Math.random(); // случайное число от 0.0 до 1.0 (1.0 не включается)Бывают ещё символьные функции (про char, тема 6) и числовые. Главное — не изобретать велосипед: если что-то частое, оно скорее всего уже есть в API.
Проверь себя · Comprueba si lo sabes
¿Qué es el diseño descendente?Что такое нисходящее проектирование?
Partir del problema general y dividirlo en subproblemas cada vez más pequeños y sencillos.
Начать с общей задачи и делить её на всё более мелкие и простые подзадачи.
¿Qué diferencia hay entre un procedimiento y una función?Чем процедура отличается от функции?
El procedimiento no devuelve nada (void); la función devuelve un valor con return.
Процедура ничего не возвращает (void), функция возвращает значение через return.
¿Por qué se recomienda evitar las variables globales?Почему стоит избегать глобальных переменных?
Porque cualquier parte del programa puede cambiarlas y los errores son difíciles de localizar.
Их может изменить любая часть программы, и ошибку трудно найти.
Si paso un int a un método y lo modifica dentro, ¿cambia la variable original? ¿Y si paso un array?Если передать int и изменить его внутри — изменится оригинал? А массив?
El int no cambia (paso por valor). El array sí cambia (paso por referencia).
int — нет (копия). Массив — да (метод получил адрес того же массива).
¿Qué es la sobrecarga de métodos? Pon un ejemplo.Что такое перегрузка методов? Пример.
Varios métodos con el mismo nombre y distintos parámetros, como sumar(int, int) y sumar(double, double).
Несколько методов с одним именем, но разными параметрами.
Словарик темы
| По-русски | En español | Что это, коротко |
|---|---|---|
| модульное программирование | programación modular | делить программу на независимые модули |
| подпрограмма | subprograma (módulo) | кусок программы со своей задачей |
| метод | método | подпрограмма в Java |
| чёрный ящик | caja negra | важно, что модуль получает и отдаёт, а не как он устроен |
| нисходящее проектирование | diseño descendente (top-down) | от общей задачи к мелким подзадачам |
| восходящее проектирование | diseño ascendente (bottom-up) | от мелких деталей к целому |
| процедура | procedimiento | метод, который ничего не возвращает (void) |
| функция | función | метод, который возвращает значение (return) |
| возвращать | devolver (return) | отдать результат тому, кто вызвал |
| локальная переменная | variable local | существует только внутри своего метода |
| глобальная переменная | variable global | видна везде, опасна |
| формальные параметры | parámetros formales | параметры в определении метода, с типами |
| фактические параметры | parámetros reales (argumentos) | значения, передаваемые при вызове |
| передача по значению | paso por valor | метод получает копию, оригинал не меняется |
| передача по ссылке | paso por referencia | метод получает адрес, оригинал меняется |
| перегрузка методов | sobrecarga de métodos | одно имя, разные параметры |
| библиотека | librería | готовые функции языка, например Math |
Рекурсия
Recursividad
Рекурсивный метод вызывает сам себя с задачей поменьше, пока не дойдёт до настолько простого случая, что ответ известен сразу (базовый случай).
«Un método recursivo se llama a sí mismo con un problema cada vez más pequeño, hasta llegar a un caso tan sencillo que se resuelve directamente (el caso base).»
Ты стоишь в длинной очереди и хочешь узнать, какой ты по счёту. Видно плохо. Ты спрашиваешь человека впереди: «Ты какой?». Он не знает и спрашивает того, кто перед ним. И так до самого первого. Первый отвечает: «Я первый» — ему считать не надо, это базовый случай. Второй слышит «1» и говорит своему заднему «2». Ответы идут обратно по цепочке, и до тебя доходит число. Это и есть рекурсия: задача «какой я?» сводится к той же задаче для соседа, только на одного человека короче.
Что такое рекурсия
Рекурсияrecursividad — решать задачу через более простую версию той же задачи. В программе это метод, который вызывает сам себя. Это альтернатива итерацииiteración (циклам): то, что делается циклом, обычно можно сделать рекурсией, и наоборот.
Три части рекурсивного решения
- Базовый случайcaso base — условие, которое останавливает рекурсию и сразу возвращает ответ. Обязателен. Без него метод будет вызывать себя бесконечно.
- Рекурсивный случайcaso recursivo (inductivo o general) — вызов самого себя с меньшим значением, которое приближается к базовому.
- Окончательное решениеresolución final — когда дошли до базового случая, все отложенные вызовы досчитываются «назад».
Факториал: разбор по шагам
Факториал 5! = 5 · 4 · 3 · 2 · 1 = 120. Заметь хитрость: 5! = 5 · 4!. А 4! = 4 · 3!. То есть факториал числа — это число, умноженное на факториал числа на единицу меньше. Задача сводится к самой себе. А где остановиться? 0! = 1 по определению — это базовый случай.
public static int factorial(int n) {
if (n == 0) { // базовый случай
return 1;
} else {
return n * factorial(n - 1); // рекурсивный случай: та же задача, но n меньше
}
}Что происходит при factorial(3):
factorial(3) = 3 * factorial(2)
= 3 * (2 * factorial(1))
= 3 * (2 * (1 * factorial(0)))
= 3 * (2 * (1 * 1)) ← базовый случай: factorial(0) = 1
= 6Сначала вызовы «спускаются» вниз: 3 → 2 → 1 → 0. Каждый ждёт ответа от следующего и пока не может досчитать. На нуле ответ известен сразу, и дальше всё «поднимается» обратно: 1 · 1 = 1, 2 · 1 = 2, 3 · 2 = 6.
Стек вызовов: где ждут незаконченные вызовы
Пока factorial(3) ждёт ответа от factorial(2), Java где-то должен помнить, что «тут осталось умножить на 3». Это место называется стек вызововpila de llamadas (stack). Каждый вызов метода кладётся в стек, как тарелка в стопку. Последняя положенная снимается первой.
┌──────────────────┐
вершина → │ factorial(0) │ ← вернёт 1 и уйдёт первым
├──────────────────┤
│ factorial(1) │ ждёт: 1 * ?
├──────────────────┤
│ factorial(2) │ ждёт: 2 * ?
├──────────────────┤
│ factorial(3) │ ждёт: 3 * ?
├──────────────────┤
│ main │
└──────────────────┘Если вызовов слишком много (например, базовый случай написан неправильно или его нет), стек переполняется: переполнение стекаdesbordamiento de pila (stack overflow). Программа падает с ошибкой StackOverflowError. Это рекурсивный аналог бесконечного цикла.
Что будет, если вызвать factorial(-1)? -1 == 0? Нет. Вызываем factorial(-2), потом -3… До нуля мы никогда не дойдём — StackOverflowError. Каждый вызов должен приближаться к базовому случаю.
Плюсы и минусы
| Плюсы | Минусы |
|---|---|
| Решение короткое и красивое | Может быть медленным: много вызовов |
| Очень удобно для структур-деревьев (папки в папках) | Тратит больше памяти: каждый вызов кладёт свои переменные в стек |
| Некоторые задачи очень трудно решить циклами | Риск переполнения стека |
Стоимость рекурсивного решенияcoste de una solución recursiva считают в трёх вещах: усилие разработкиesfuerzo de desarrollo (сколько времени придумать и написать), временная сложность и пространственная сложность. Если рекурсия получилась слишком медленной, лучше переписать циклом: пользователю важнее, что программа работает хорошо, а не что код красивый.
Поиск файла в папке: открыть папку, посмотреть файлы, и для каждой вложенной папки сделать то же самое. Базовый случай — папка без подпапок. Так работает поиск в Windows. Ещё пример — комментарии с ответами на комментарии в YouTube.
Виды рекурсии
| Вид | Что происходит | Пример |
|---|---|---|
| Прямаяdirecta | Метод вызывает сам себя один раз | Факториал |
| Косвеннаяindirecta | A вызывает B, B вызывает C… и кто-то снова вызывает A | m1 → m2 → m3 → m1 |
| Нарастающаяen aumento | После каждого вызова остаются незаконченные операции | return a + metodo(a - 2); |
| Множественнаяmúltiple | В одном случае метод вызывает себя несколько раз | Фибоначчи (стек переполняется быстрее) |
Фибоначчи: два вызова сразу
Последовательность: 0, 1, 1, 2, 3, 5, 8, 13… Каждое число — сумма двух предыдущих. Значит, у нас два базовых случая (0 и 1), а рекурсивный вызывает себя дважды.
public static int fibonacci(int n) {
if (n == 0) {
return 0; // базовый случай 1
} else if (n == 1) {
return 1; // базовый случай 2
} else {
return fibonacci(n - 1) + fibonacci(n - 2); // множественная рекурсия
}
}Почему это медленно: fibonacci(5) вызывает fibonacci(4) и fibonacci(3). Но fibonacci(4) сам снова вызывает fibonacci(3). Одно и то же считается много раз, и число вызовов растёт лавиной.
Driver: проверяем данные один раз
Driver (посредник)driver — метод-посредник. Он один раз проверяет, что данные правильные, и только потом вызывает рекурсивный метод. Иначе проверка повторялась бы в каждом из сотни вызовов.
public static void driverSuma(int n) { // driver: проверка один раз
if (n > 0) {
System.out.println("Suma: " + suma(n));
} else {
System.out.println("El número no puede ser menor que 1");
}
}
public static int suma(int n) { // сама рекурсия
if (n == 1) {
return 1; // базовый случай
} else {
return suma(n - 1) + n; // рекурсивный случай
}
}Вызов driverSuma(5) напечатает сумму 1 + 2 + 3 + 4 + 5, а driverSuma(0) до рекурсии даже не дойдёт:
Suma: 15 El número no puede ser menor que 1
Ханойские башни (идея)
Есть три стержня и пирамидка из дисков. Нужно перенести её на другой стержень, двигая по одному диску и никогда не кладя большой на маленький. Рекурсивная идея: чтобы перенести n дисков, перенеси n − 1 на вспомогательный стержень, переложи самый большой на цель, затем перенеси n − 1 со вспомогательного на цель. Базовый случай: один диск переносится сразу.
Как придумать рекурсию самому (рецепт)
- Какой самый простой случай я могу решить сразу? → базовый случай.
- Как выразить задачу через ту же задачу, но меньше? → рекурсивный случай.
- Проверь, что каждый вызов приближается к базовому случаю.
Пример по рецепту: степень baseexp. 1) base0 = 1. 2) baseexp = base · baseexp−1. 3) exp каждый раз уменьшается на 1 и дойдёт до 0.
public static int potencia(int base, int exp) {
if (exp == 0) {
return 1; // базовый случай
}
return base * potencia(base, exp - 1); // рекурсивный случай
}Проверь себя · Comprueba si lo sabes
¿Qué es el caso base y qué pasa si no existe?Что такое базовый случай и что будет без него?
Es la condición que detiene la recursividad. Sin él, el método se llama infinitamente y se produce un desbordamiento de pila.
Условие, которое останавливает рекурсию. Без него метод вызывает себя бесконечно → переполнение стека.
¿Qué es un desbordamiento de pila?Что такое переполнение стека?
Cuando hay tantas llamadas pendientes que se llena la pila de memoria y el programa falla (StackOverflowError).
Когда незаконченных вызовов так много, что стек заполняется, и программа падает.
¿Por qué Fibonacci recursivo es un ejemplo de recursividad múltiple?Почему Фибоначчи — множественная рекурсия?
Porque en el caso general se llama a sí mismo dos veces: fibonacci(n-1) + fibonacci(n-2).
В общем случае метод вызывает себя два раза.
¿Para qué sirve un driver?Зачем нужен driver?
Para comprobar los datos una sola vez antes de llamar al método recursivo.
Чтобы проверить данные один раз до запуска рекурсии.
Escribe un método recursivo que calcule la potencia base^exp.Напиши рекурсивный метод степени.
Метод potencia выше, в разделе «рецепт»: базовый случай exp == 0 → 1, рекурсивный base * potencia(base, exp - 1).
Словарик темы
| По-русски | En español | Что это, коротко |
|---|---|---|
| рекурсия | recursividad | метод вызывает сам себя с задачей поменьше |
| итерация | iteración | решение через цикл |
| базовый случай | caso base | останавливает рекурсию, ответ известен сразу |
| рекурсивный случай | caso recursivo (general, inductivo) | вызов самого себя с меньшим значением |
| стек вызовов | pila de llamadas (stack) | память, где ждут незаконченные вызовы; LIFO |
| переполнение стека | desbordamiento de pila (StackOverflowError) | слишком много вызовов, программа падает |
| прямая рекурсия | recursividad directa | метод вызывает сам себя |
| косвенная рекурсия | recursividad indirecta | A → B → … → A |
| множественная рекурсия | recursividad múltiple | несколько вызовов себя в одном случае |
| driver | driver | метод-посредник: проверяет данные один раз |
| усилие разработки | esfuerzo de desarrollo | сколько времени придумать и написать решение |
Массивы и строки
Estructuras de almacenamiento y cadenas de caracteres
Массив хранит много данных одного типа под одним именем, в пронумерованных ячейках начиная с 0, а String — это строка символов со своими методами.
«Un array guarda muchos datos del mismo tipo bajo un solo nombre, en posiciones numeradas desde el 0, y un String es una cadena de caracteres con sus propios métodos.»
Нужно сохранить оценки 30 учеников. Создавать nota1, nota2… nota30? А потом считать среднее, складывая 30 переменных вручную? Массив решает это: одно имя notas, 30 ячеек, и цикл, который проходит по всем.
Массив: ряд ящиков с номерами
Составные типыtipos compuestos — типы, которые состоят из нескольких данных: массивы, матрицы, строки.
Массивarray (vector, lista) — набор элементов одного типа, которые лежат в памяти подряд. Представь шкафчики в спортзале: у всех одна надпись «notas», а различаются они номером.
- У каждого элемента есть индексíndice. Первый — 0, последний — длина − 1. В массиве из 5 элементов индексы 0, 1, 2, 3, 4.
- Размер задаётся при создании и больше не меняется.
- После создания через
newвсе элементы равны 0 (числа) илиfalse(boolean). - Типичные операции: создать и заполнить, добавить, удалить, найти, отсортировать.
Как создать и заполнить
int[] edades; // 1. объявить: «будет массив int»
edades = new int[5]; // 2. создать: 5 ячеек (0..4), все равны 0
edades[0] = 18; // заполнить по номеру ячейки
edades[1] = 20;
for (int i = 0; i < edades.length; i++) { // заполнить в цикле с клавиатуры
edades[i] = lectura.nextInt();
}
int[] notas = {7, 5, 9, 4, 8}; // всё сразу: объявить, создать, заполнитьedades.length — длина массива (без скобок, это не метод, а свойство). Условие i < edades.length гарантирует, что мы не выйдем за последний индекс.
i <= edades.length — частая ошибка. При длине 5 цикл дойдёт до edades[5], а такой ячейки нет. Результат — ArrayIndexOutOfBoundsException. Всегда <, а не <=.
Пройти по массиву и посчитать среднее
int[] notas = {7, 5, 9, 4, 8};
int suma = 0;
for (int i = 0; i < notas.length; i++) {
suma += notas[i];
}
double media = (double) suma / notas.length; // (double), иначе деление будет целым
System.out.println("Media: " + media);Media: 6.6
Найти максимум
Идея как в жизни: берёшь первую оценку как «пока самую большую», потом смотришь остальные по одной. Нашёл больше — запоминаешь её.
int max = notas[0];
for (int i = 1; i < notas.length; i++) {
if (notas[i] > max) {
max = notas[i];
}
}
System.out.println("Máximo: " + max); // 9Ссылка: переменная массива хранит адрес
Важная вещь, которая вернётся в теме 8. Переменная массива хранит не сами числа, а ссылкуreferencia — адрес в памяти, где массив начинается. Как бумажка с адресом склада, а не сам склад.
int[] datos = {10, 20, 30};
int[] precios = datos; // НЕ копия! Обе переменные смотрят на ОДИН массив
precios[0] = 99;
System.out.println(datos[0]); // 99 — потому что массив один
datos = null; // datos больше никуда не указываетСборщик мусораrecolector de basura (garbage collector) — Java сам освобождает память массивов и объектов, на которые больше не указывает ни одна переменная. Тебе не нужно удалять их вручную.
Поиск
| Поиск | Как работает | Требование | Сложность |
|---|---|---|---|
| Линейныйlineal | Проверяет по одному с начала | Никакого | O(n) |
| Бинарныйbinaria | Смотрит в середину и отбрасывает половину на каждом шаге | Массив отсортирован | O(log n) |
// Линейный поиск: возвращает позицию или -1, если не нашли
public static int buscar(int[] array, int valor) {
for (int i = 0; i < array.length; i++) {
if (array[i] == valor) {
return i;
}
}
return -1;
}Бинарный поиск — это как искать слово в бумажном словаре. Ты не листаешь с первой страницы, а открываешь посередине: нужное слово дальше по алфавиту? Значит, левая половина не нужна. Снова середина оставшегося… Из 1000 элементов хватит примерно 10 шагов.
public static int busquedaBinaria(int[] array, int valor) {
int inicio = 0;
int fin = array.length - 1;
while (inicio <= fin) {
int centro = (inicio + fin) / 2;
if (array[centro] == valor) {
return centro;
} else if (valor < array[centro]) {
fin = centro - 1; // ищем в левой половине
} else {
inicio = centro + 1; // ищем в правой половине
}
}
return -1;
}Пример: ищем 23 в {2, 5, 8, 12, 16, 23, 38, 56, 72, 91}. Центр — индекс 4 (16). 23 больше → идём вправо, inicio = 5. Центр — индекс 7 (56). 23 меньше → влево, fin = 6. Центр — индекс 5 (23). Нашли за 3 шага.
Сортировка
| Метод | Как работает | Сложность |
|---|---|---|
| Пузырькомburbuja | Сравнивает соседей и меняет местами, если стоят неправильно | O(n²) |
| Выборомselección | Ищет самый маленький и ставит его в начало, снова и снова | O(n²) |
| Вставкамиinserción | Берёт каждый элемент и вставляет на своё место среди уже отсортированных (как карты в руке) | O(n²) |
| Quicksort, Mergesort | «Разделяй и властвуй». Намного быстрее | O(n log n) |
// Пузырёк: после каждого прохода самый большой «всплывает» в конец
for (int i = 0; i < array.length - 1; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j] > array[j + 1]) { // стоят неправильно?
int aux = array[j]; // меняем через вспомогательную переменную
array[j] = array[j + 1];
array[j + 1] = aux;
}
}
}Зачем aux? Чтобы поменять содержимое двух стаканов, нужен третий, пустой. Если сразу написать array[j] = array[j + 1], старое значение array[j] потеряется.
Матрицы: таблица из массивов
Двумерный массив (матрица)array bidimensional (matriz) — массив, внутри которого массивы. Выглядит как таблица со строкамиfilas и столбцамиcolumnas. Как места в кинотеатре: ряд и место.
int[][] matriz = new int[3][4]; // 3 строки и 4 столбца
matriz[0][0] = 1; // строка 0, столбец 0
int[][] m = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };
for (int i = 0; i < m.length; i++) { // проходим строки
for (int j = 0; j < m[i].length; j++) { // проходим столбцы
System.out.print(m[i][j] + " ");
}
System.out.println(); // новая строка после каждого ряда
}1 2 3 4 5 6 7 8 9
m.length — сколько строк, m[i].length — сколько столбцов в строке i. Бывают и массивы с большим числом измерений: int[][][].
Строки и символы
Строка символовcadena de caracteres — последовательность символов. Java использует стандарт ЮникодUnicode: у каждого символа любого языка есть свой уникальный номер. Поэтому в Java можно хранить и «ñ», и «ж».
Управляющие последовательности
Управляющие последовательностиsecuencias de escape — как вставить в текст то, что иначе сломало бы строку:
| Пишешь | Получаешь |
|---|---|
\n | Перевод строки |
\t | Табуляция |
\' | Одинарная кавычка |
\" | Двойная кавычка (иначе строка бы закончилась) |
\\ | Обратный слеш |
Класс Character: вопросы про один char
| Метод | Что делает |
|---|---|
Character.isDigit(c) | Это цифра? |
Character.isLetter(c) | Это буква? |
Character.isLetterOrDigit(c) | Буква или цифра? |
Character.isUpperCase(c) / isLowerCase(c) | Заглавная / строчная? |
Character.isSpaceChar(c) | Пробел? |
Character.toUpperCase(c) / toLowerCase(c) | Сделать заглавной / строчной |
Проверка пароля при регистрации: «должна быть хотя бы одна цифра и одна заглавная буква». Проходишь по символам пароля и спрашиваешь isDigit и isUpperCase.
Класс String
Неизменяемостьinmutable: однажды созданная строка не меняется. Методы не трогают исходную строку, а возвращают новую. Поэтому s.toUpperCase(); само по себе ничего не изменит — нужно s = s.toUpperCase();.
| Метод | Что делает | Для s = "Hola mundo" |
|---|---|---|
length() | Длина | 10 |
charAt(n) | Символ в позиции n | charAt(0) → 'H' |
indexOf('o') | Первая позиция символа | 1 |
lastIndexOf('o') | Последняя позиция | 9 |
substring(n1, n2) | Кусок с n1 до n2 − 1 | substring(0, 4) → "Hola" |
toUpperCase() / toLowerCase() | Заглавные / строчные | "HOLA MUNDO" |
equals(otra) | Равны ли строки? | true / false |
equalsIgnoreCase(otra) | Равны, не глядя на регистр | "hola" и "HOLA" → true |
compareTo(otra) | 0 если равны, отрицательное если раньше по алфавиту, положительное если позже | — |
String.valueOf(n) | Превращает n в String | String.valueOf(5) → "5" |
replace('o', 'a') | Меняет все такие символы | "Hala munda" |
replaceAll("mundo", "Java") | Меняет кусок текста | "Hola Java" |
- Строки сравнивают через
equals(), никогда через==.==сравнивает адреса в памяти (тема 8), и две одинаковые строки могут датьfalse. substring(0, 4)— символ с индексом 4 не входит. Длина куска = 4 − 0 = 4.- У массива
lengthбез скобок, у String —length()со скобками.
Посчитать гласные в тексте
String texto = "Programacion en Java";
int vocales = 0;
for (int i = 0; i < texto.length(); i++) {
char c = Character.toLowerCase(texto.charAt(i)); // берём символ и делаем строчным
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
vocales++;
}
}
System.out.println("Vocales: " + vocales);Vocales: 8
Почему toLowerCase? Чтобы не проверять отдельно 'A' и 'a'. Мы приводим всё к одному виду и сравниваем только с пятью строчными.
Проверь себя · Comprueba si lo sabes
Si un array tiene 10 elementos, ¿cuál es el índice del primero y del último?Массив из 10 элементов: индекс первого и последнего?
El primero es el 0 y el último el 9.
0 и 9 (длина − 1).
¿Qué valor tienen los elementos de un int[] recién creado con new?Чему равны элементы только что созданного int[]?
Todos valen 0.
Все равны 0.
¿Qué requisito necesita la búsqueda binaria? ¿Por qué es más rápida que la lineal?Что нужно для бинарного поиска? Почему он быстрее?
Que el array esté ordenado. Es más rápida porque descarta la mitad de los elementos en cada paso: O(log n) frente a O(n).
Массив должен быть отсортирован. Каждый шаг отбрасывает половину.
¿Qué hace el recolector de basura?Что делает сборщик мусора?
Libera automáticamente la memoria de los arrays y objetos que ya no tienen ninguna referencia.
Сам освобождает память того, на что больше не указывает ни одна переменная.
¿Qué devuelve "Programacion".substring(0, 3)? ¿Y "Java".charAt(2)?Что вернут эти вызовы?
"Pro" y 'v'.
"Pro" (индексы 0, 1, 2) и 'v' (J=0, a=1, v=2).
Словарик темы
| По-русски | En español | Что это, коротко |
|---|---|---|
| массив | array (vector) | набор элементов одного типа под одним именем |
| индекс | índice | номер ячейки, начиная с 0 |
| длина | longitud (length) | количество элементов |
| ссылка | referencia | адрес в памяти, где лежит массив или объект |
| сборщик мусора | recolector de basura (garbage collector) | сам освобождает ненужную память |
| линейный поиск | búsqueda lineal | проверяет по одному, O(n) |
| бинарный поиск | búsqueda binaria | делит пополам, только для отсортированного, O(log n) |
| сортировка | ordenación | расставить элементы по порядку |
| пузырёк | método de la burbuja | меняет соседей местами, O(n²) |
| вспомогательная переменная | variable auxiliar (aux) | временное место для обмена значений |
| матрица | matriz (array bidimensional) | массив массивов: строки и столбцы |
| строка / столбец | fila / columna | горизонтальный ряд / вертикальный ряд |
| строка символов | cadena de caracteres | текст, последовательность символов |
| управляющая последовательность | secuencia de escape | \n, \t, \" … |
| неизменяемый | inmutable | String не меняется, методы возвращают новую строку |
Введение в объектно-ориентированное программирование
Introducción a la orientación a objetos
В ООП программа состоит из объектов, у которых есть данные (атрибуты) и умения (методы); класс — это форма, а объект — то, что по ней сделано.
«En la Programación Orientada a Objetos (POO) el programa se organiza en objetos que tienen datos (atributos) y saben hacer cosas (métodos); la clase es el molde y el objeto es lo que se fabrica con él.»
До сих пор у нас были отдельно данные (переменные, массивы) и отдельно действия (методы). Представь, что ты пишешь игру с 50 собаками. У каждой имя, порода, возраст. Ты заводишь три массива nombres[], razas[], edades[] и следишь, чтобы индекс 17 во всех трёх был одной и той же собакой. Одна ошибка в индексе — и у таксы возраст овчарки. ООП говорит: давай всё, что относится к одной собаке, хранить в ней самой.
От структурного к ООП
В структурном программированииprogramación estructurada данные и функции разделены. В ООПPOO, Programación Orientada a Objetos они собраны внутри объектовobjetos, а программа работает за счёт того, что объекты общаются между собой.
Класс и объект: форма и печенье
Классclase — модель, шаблон: описывает, какие атрибуты и поведение будут у объектов. Сам по себе класс не используется, по нему создают объекты (экземплярыinstancias). Имя класса начинается с большой буквы: Perro, Alumno, Coche.
Аналогия: формочка для печенья — это класс. Печенье — объекты. По одной формочке можно сделать сто печений. Форма у всех одинаковая, но одно с шоколадом, другое с корицей. Так и два объекта одного класса: одинаковые атрибуты и методы, но разные значения.
Класс Perro | Объект «Rex» | Объект «Luna» |
|---|---|---|
| nombre | "Rex" | "Luna" |
| raza | "Pastor alemán" | "Caniche" |
| edad | 5 | 2 |
| ladrar(), correr() | умеет | умеет |
Это должно быть классом? Три вопроса
- Существует ли это в реальном мире (или в мире задачи)?
- Есть ли у него свойства?
- Может ли оно что-то делать?
Три «да» — хороший кандидат в классы. «Coche»: существует, есть марка и цвет, может ехать — класс. «Rojo»: свойство, а не вещь — скорее атрибут color какого-то класса.
Из чего состоит класс
- Атрибутыatributos — данные, характеристики. У Perro: nombre, color, raza, altura. С
finalатрибут становится константой. - Методыmétodos — что объект умеет. Бывают:
- наблюдателиobservadores — узнают информацию об объекте («какой у тебя возраст?»);
- модификаторыmodificadores — меняют данные объекта («теперь тебе 6»);
- конструкторыconstructores — задают значения атрибутов при создании объекта;
- деструкторыdestructores — выполняются при удалении объекта. В Java их нет: этим занимается сборщик мусора.
Пример как на паре: класс Perro
public class Perro {
// Атрибуты (propiedades)
private String raza;
private String nombre;
private int edad;
// Конструктор: вызывается, когда создаём собаку через new
public Perro(String raza, String nombre, int edad) {
this.raza = raza;
this.nombre = nombre;
this.edad = edad;
}
// Наблюдатель (observador)
public String getNombre() {
return nombre;
}
// Модификатор (modificador)
public void setEdad(int edad) {
this.edad = edad;
}
// Что умеет собака
public void ladrar() {
System.out.println(nombre + ": ¡Guau!");
}
}public class Main {
public static void main(String[] args) {
Perro rex = new Perro("Pastor alemán", "Rex", 5); // объект 1
Perro luna = new Perro("Caniche", "Luna", 2); // объект 2
rex.ladrar();
luna.ladrar();
luna.setEdad(3); // меняем только Луну
System.out.println(rex.getNombre());
}
}Rex: ¡Guau! Luna: ¡Guau! Rex
Слова private, this и как работает new подробно разберём в темах 8 и 9. Сейчас главное — увидеть: одна форма Perro, два разных объекта.
Четыре принципа ООП
Это спрашивают почти на каждом экзамене. Учи не определения, а примеры — по ним определения вспоминаются сами.
| Принцип | Что значит | Пример |
|---|---|---|
| Абстракцияabstracción | Оставить только характеристики, важные для задачи | Для школьной программы у ученика важны имя и оценка, а не любимый цвет |
| Инкапсуляцияencapsulamiento | Данные защищены внутри объекта, доступ к ним только через методы | Банкомат: ты не трогаешь деньги руками, ты нажимаешь кнопки |
| Наследованиеherencia | Класс-потомок получает атрибуты и методы класса-родителя | Perro наследует от Animal: тоже умеет есть |
| Полиморфизмpolimorfismo | Один и тот же метод ведёт себя по-разному в зависимости от объекта | hacerSonido(): собака лает, кошка мяукает |
Пульт от телевизора: какой это принцип — абстракция или инкапсуляция?
Скорее инкапсуляция: внутренности спрятаны, ты пользуешься только кнопками. А то, что на пульте только нужные кнопки, а не все возможные функции, — это абстракция. Один предмет может показывать оба принципа.
Защита данныхprotección de datos достигается инкапсуляцией и сокрытием информацииocultación de la información: с помощью модификаторов доступаmodificadores de acceso (private, public) решаешь, что видно снаружи.
Плюсы и минусы ООП
- Плюсы: повторное использование кода, больше абстракции, быстрее разработка, легче сопровождение, можно строить сложные системы, информация защищена.
- Минусы: полиморфизм работает чуть медленнее, анализ сложнее, учиться дольше (нужно знать библиотеки классов).
Наследование в коде
public class Animal {
String nombre;
public void comer() {
System.out.println(nombre + " está comiendo");
}
}
public class Perro extends Animal { // Perro «является» Animal
public void ladrar() {
System.out.println("¡Guau!");
}
}extends значит «наследует от». У объекта Perro теперь есть и nombre, и comer(), хотя в классе Perro мы их не писали, — они пришли от родителя. Плюс своё: ladrar().
- Суперкласс (родитель)superclase (clase padre) — более общий класс:
Animal. - Подкласс (потомок)subclase (clase hija) — более конкретный, наследует от родителя:
Perro.
Связи между классами
Классы в программе не живут поодиночке. Как они связаны — описывают в диаграммах UMLdiagrama de clases UML.
| Связь | Читается как | Пример | В UML |
|---|---|---|---|
| Ассоциацияasociación | «имеет» / «является частью» | У машины есть колёса | Сплошная линия |
| ↳ Агрегацияagregación | Части могут существовать сами | Точка в многоугольнике; игрок в команде | |
| ↳ Композицияcomposición | Части существуют только вместе с целым | Комнаты в доме: снесли дом — нет комнат | |
| Зависимостьdependencia | «использует» (временно) | Учитель использует мел | Пунктирная стрелка |
| Обобщение (наследование)generalización (herencia) | «является» | Медведь является млекопитающим | Стрелка к родителю |
Спроси себя: «если уничтожить целое, части останутся?» Команду распустили — игроки живы → агрегация. Дом снесли — комнат больше нет → композиция.
- Кратностьmultiplicidad — сколько объектов участвует:
1(ровно один),0..1(ноль или один),0..*(ноль или много),1..*(один или много),N..M. - Рефлексивная связьrelación involutiva (reflexiva) — один и тот же класс на обоих концах: сотрудник руководит другим сотрудником.
Как читать диаграмму класса
+----------------------+
| Libro | ← имя класса
+----------------------+
| - titulo: String | ← атрибуты (- значит private)
| - autor: String |
| - paginas: int |
+----------------------+
| + mostrar(): void | ← методы (+ значит public)
+----------------------+Из задачи — в класс
Самое практичное умение темы. Задача: «Queremos gestionar los libros de una biblioteca. De cada libro guardamos título, autor y número de páginas, y queremos poder mostrar sus datos.»
Ищем в тексте: существительное-предмет → класс; то, что «guardamos de cada…» → атрибуты; глаголы «queremos poder…» → методы.
- Класс:
Libro - Атрибуты:
titulo,autor,paginas - Метод:
mostrar()
/**
* Representa un libro de la biblioteca.
* @author Nombre del alumno
* @version 1.0
*/
public class Libro {
// Атрибуты
private String titulo;
private String autor;
private int paginas;
// Метод
public void mostrar() {
System.out.println(titulo + " de " + autor + " (" + paginas + " páginas)");
}
}Инструменты: NetBeans и Doxygen
- Создать класс в NetBeans: File → New File → Java Class. Файл называется так же, как класс, с расширением
.java. - Doxygen генерирует документациюdocumentación из комментариев между
/**и*/. Для классов используют@author(автор) и@version(версия). Умеет рисовать и UML-диаграммы.
Проверь себя · Comprueba si lo sabes
¿Qué diferencia hay entre una clase y un objeto?Чем класс отличается от объекта?
La clase es el molde o plantilla; el objeto es un ejemplar concreto creado a partir de ella.
Класс — форма, шаблон. Объект — конкретный экземпляр, сделанный по нему.
Explica los cuatro principios de la POO con un ejemplo cada uno.Четыре принципа ООП с примерами.
Abstracción (quedarse con lo importante), encapsulamiento (proteger los datos), herencia (la hija recibe lo del padre) y polimorfismo (un mismo método se comporta distinto según el objeto).
Абстракция — у ученика важны имя и оценка. Инкапсуляция — банкомат. Наследование — Perro от Animal. Полиморфизм — hacerSonido() лает или мяукает.
¿Qué diferencia hay entre agregación y composición?Чем агрегация отличается от композиции?
En la agregación las partes pueden existir solas; en la composición solo existen junto al todo.
В агрегации части живут сами по себе, в композиции — только вместе с целым.
«Un empleado es una persona»: ¿qué tipo de relación es?«Сотрудник является человеком» — какая это связь?
Generalización (herencia): «es un».
Обобщение, то есть наследование. Ключевые слова «es un».
¿Qué etiquetas de Doxygen se usan para documentar una clase?Какие теги Doxygen для класса?
@author y @version.
@author и @version.
Словарик темы
| По-русски | En español | Что это, коротко |
|---|---|---|
| ООП | POO (Programación Orientada a Objetos) | программа из объектов с данными и методами |
| класс | clase | шаблон, форма для объектов |
| объект / экземпляр | objeto / instancia | конкретная вещь, созданная по классу |
| атрибут | atributo | данные, характеристика объекта |
| наблюдатель | método observador (get) | узнаёт данные объекта |
| модификатор (метод) | método modificador (set) | меняет данные объекта |
| конструктор | constructor | задаёт значения при создании объекта |
| деструктор | destructor | в Java нет, работает сборщик мусора |
| абстракция | abstracción | оставить только важное для задачи |
| инкапсуляция | encapsulamiento | данные защищены, доступ через методы |
| наследование | herencia | потомок получает всё от родителя (extends) |
| полиморфизм | polimorfismo | один метод — разное поведение у разных объектов |
| сокрытие информации | ocultación de la información | решать, что видно снаружи |
| суперкласс | superclase (clase padre) | более общий класс-родитель |
| подкласс | subclase (clase hija) | класс-потомок |
| ассоциация | asociación | связь «имеет» |
| агрегация | agregación | части живут и без целого |
| композиция | composición | части существуют только с целым |
| зависимость | dependencia | связь «использует», временная |
| обобщение | generalización | связь «является», наследование |
| кратность | multiplicidad | сколько объектов в связи: 1, 0..1, 0..*, 1..* |
Классы и объекты в памяти
Gestión de clases y objetos
Через new объект создаётся в памяти, а переменная хранит только ссылку (адрес) на него — как пульт, который направлен на телевизор.
«Con new se crea un objeto en memoria, y la variable solo guarda una referencia (la dirección) a ese objeto, como un mando a distancia que apunta a la tele.»
Эта тема объясняет самые «странные» вещи в Java: почему изменил одну переменную, а поменялась другая; почему программа падает с NullPointerException; зачем писать this. Всё это следует из одной картинки: переменная — пульт, объект — телевизор. Держи её в голове всю тему.
Чем определяется объект
- Идентичностьidentidad — то, что делает объект уникальным. Даже если у двух объектов одинаковые значения, это два разных объекта (в Java — разные адреса в памяти). Два одинаковых iPhone из одной коробки — всё равно два телефона.
- Состояниеestado — значения атрибутов в данный момент. Телефон: заряд 80 %, громкость 5.
- Поведениеcomportamiento — что объект умеет (его методы). Позвонить, сделать фото.
Жизненный цикл объекта (5 фаз)
- Созданиеcreación —
newрезервирует память. - Инициализацияinicialización — конструктор задаёт значения атрибутам.
- Использованиеuso — вызываем его методы.
- Завершениеfinalización — освобождаются ресурсы (метод
finalize()). - Уничтожениеdestrucción — сборщик мусора удаляет объект из памяти.
Запомнить порядок помогает жизнь вещи: купили (создание), распаковали и настроили (инициализация), пользуемся (использование), вынули батарейки (завершение), выбросили (уничтожение).
Зоны памяти
| Зона | Что там лежит |
|---|---|
| Стек вызововpila de llamadas (call stack) | Вызовы методов и их локальные переменные. Работает по принципу LIFO: последним пришёл — первым ушёл (тарелки в стопке) |
| Кучаmontículo (heap) | Объекты, созданные через new |
| Статические данныеdatos estáticos | Глобальные и статические переменные |
| Кодcódigo | Инструкции программы |
Когда пишешь Persona p1 = new Persona(...), происходят две вещи: сам объект появляется в куче, а маленькая переменная p1 с его адресом лежит в стеке (если это локальная переменная метода).
СТЕК (pila) КУЧА (montículo / heap)
┌──────────────┐ ┌──────────────────────────┐
│ p1 ──────────┼────────────▶ │ Persona │
│ (адрес) │ │ nombre = "Sara" │
├──────────────┤ │ edad = 17 │
│ n = 5 │ └──────────────────────────┘
└──────────────┘ объект живёт здесь
int n хранит само значение,
p1 хранит только адресСсылка и null
Ссылка на объектreferencia — адрес в памяти, где лежит объект. Если напечатать объект без toString, увидишь что-то вроде Coche@15db9742 — это и есть «адрес». Главное правило:
- Переменная примитивного типа хранит значение:
int edad = 17— внутри 17. - Переменная типа-класса хранит ссылку:
Persona p1— внутри адрес объекта.
Пустая ссылкаreferencia nula (null) — переменная никуда не указывает. Пульт есть, а телевизора нет. Объявил объект, но не создал — он равен null. Попробуешь нажать кнопку (вызвать метод) — программа упадёт с NullPointerException.
Persona p1; // объявлена, но не создана: p1 = null
p1.saludo(); // ОШИБКА: NullPointerException — объекта нетСоздать экземплярinstanciar — создать объект через new NombreClase(parámetros).
Присваивание объектов: два пульта, один телевизор
Самое важное место темы. Если написать Persona p2 = p1;, новый объект не создаётся. Ты просто взял второй пульт и направил его на тот же телевизор.
Persona p1 = new Persona("Sara", "López", 17);
Persona p2 = p1; // p2 указывает НА ТОТ ЖЕ объект
p2.cumplirAnios(); // меняем через p2…
System.out.println(p1); // …и видим изменение через p1: edad=18Persona [nombre=Sara, apellido=López, edad=18]
«Сколько объектов Persona создано в этом коде?» Считай new, а не переменные. Здесь один new — значит, один объект, хотя переменных две. Как сделать настоящую копию — конструктор копирования в теме 9.
Сборщик мусора
Сборщик мусораrecolector de basura (garbage collector) сам удаляет объекты, на которые больше не направлен ни один «пульт». Это большое преимущество Java по сравнению с языками вроде C++, где память нужно освобождать вручную и легко ошибиться.
Persona p = new Persona("Ana", "Gil", 20);
p = new Persona("Leo", "Paz", 22); // пульт перенаправили на нового человека.
// На «Ana» больше никто не указывает → сборщик её удалит.Виды методов класса
- Конструкторыconstructores — инициализируют объект (по умолчанию или с параметрами).
- Наблюдатели (get)observadores (get) — узнают значение атрибута.
- Модификаторы (set)modificadores (set) — меняют значение атрибута.
- Пользовательскиеpersonalizados — всё, что нужно программе:
saludo(),cumplirAnios()…
Имена в camelCase. Вызываются через оператор точкаoperador punto: p1.saludo(). Возвращают одно значение через return или ничего (void).
Полный класс Persona
public class Persona {
private String nombre;
private String apellido;
private int edad;
public Persona(String nombre, String apellido, int edad) {
this.nombre = nombre; // this.nombre — атрибут; nombre — параметр
this.apellido = apellido;
this.edad = edad;
}
public void saludo() {
System.out.println("Hola, soy " + nombre);
}
public String nombreCompleto() {
return nombre + " " + apellido;
}
public void cumplirAnios() {
edad++;
}
@Override
public String toString() {
return "Persona [nombre=" + nombre + ", apellido=" + apellido + ", edad=" + edad + "]";
}
}Persona p1; // объявлена: null
p1 = new Persona("Sara", "López", 17); // создана: теперь существует в памяти
p1.saludo();
p1.cumplirAnios();
System.out.println(p1.nombreCompleto());
System.out.println(p1); // автоматически вызывает toString()Hola, soy Sara Sara López Persona [nombre=Sara, apellido=López, edad=18]
this и сокрытие атрибутов
Посмотри на конструктор: параметр называется nombre, и атрибут тоже nombre. Внутри метода локальная переменная или параметр с тем же именем закрывает собой атрибут. Это называется сокрытие атрибутовocultación de atributos (shadowing).
Чтобы обратиться именно к атрибуту, пишут this. впереди. Слово this значит «текущий объект»el objeto actual, «я сам». this.nombre = nombre; читается как «моё имя = имя, которое мне передали».
Если написать nombre = nombre; без this, параметр присвоится сам себе, а атрибут останется null. Компилятор не ругается, но объект получится пустым.
Где живут переменные (область видимости)
| Вид | Где объявлена | Где существует |
|---|---|---|
| Переменная класса (атрибут)de clase (atributo) | В классе, вне методов | Во всём классе |
| Локальнаяlocal | Внутри метода | Только в этом методе |
| Блочнаяde bloque | Внутри if, for, while… | Только в этом блоке |
public class Ambito {
int varClase; // видна во всём классе
void metodo() {
int varLocal = 0; // видна только внутри metodo()
while (varLocal < 3) {
int varBloque = 5; // видна только внутри while
varLocal++;
}
// здесь varBloque уже не существует
}
}Передача объектов в методы
То же правило, что в теме 4: примитивы передаются по значениюpor valor (копия), объекты — по ссылкеpor referencia, и изменения видны снаружи. Метод получает второй пульт от того же телевизора.
Метод toString()
Есть у всех классов. Возвращает String с кратким описанием данных объекта. Вызывается автоматически, когда пишешь System.out.println(objeto). Если его не переопределить, напечатается что-то вроде Persona@1b6d3586. @Override над методом значит «я заменяю стандартную версию своей».
Отладка: вместо того чтобы печатать каждый атрибут по отдельности, пишешь System.out.println(cliente) и сразу видишь всё состояние объекта.
Документирование методов (Doxygen)
| Тег | Зачем |
|---|---|
@param | Описывает параметр (по одному на каждый) |
@return | Что возвращает (только если что-то возвращает) |
@see | Ссылка на другой метод, который вызывается |
@deprecated | Метод устарел |
@throws | Какое исключение может выбросить |
/**
* Calcula el precio final aplicando un descuento.
* @param precio precio original en euros
* @param descuento porcentaje de descuento (0 a 100)
* @return el precio con el descuento aplicado
*/
public double precioFinal(double precio, double descuento) {
return precio - precio * descuento / 100;
}Проверь себя · Comprueba si lo sabes
¿Cuáles son las tres características que definen un objeto?Три характеристики объекта?
Identidad, estado y comportamiento.
Идентичность, состояние и поведение.
Nombra las fases del ciclo de vida de un objeto.Фазы жизненного цикла объекта.
Creación, inicialización, uso, finalización y destrucción.
Создание, инициализация, использование, завершение, уничтожение.
¿Qué significa que una variable valga null? ¿Qué error da si la usas?Что значит null? Какая ошибка при использовании?
Que no apunta a ningún objeto. Da NullPointerException.
Никуда не указывает. NullPointerException.
¿Para qué sirve this?Зачем нужен this?
Para referirse al objeto actual y diferenciar un atributo de un parámetro o variable local con el mismo nombre.
Обратиться к текущему объекту и отличить атрибут от параметра с тем же именем.
¿Qué hace el método toString() y cuándo se llama automáticamente?Что делает toString() и когда вызывается сам?
Devuelve un String con los datos del objeto. Se llama automáticamente al hacer System.out.println(objeto).
Возвращает строку с данными объекта. Вызывается сам в System.out.println(objeto).
Словарик темы
| По-русски | En español | Что это, коротко |
|---|---|---|
| идентичность | identidad | делает объект уникальным, даже при одинаковых значениях |
| состояние | estado | значения атрибутов в данный момент |
| поведение | comportamiento | что объект умеет: его методы |
| жизненный цикл объекта | ciclo de vida de un objeto | создание, инициализация, использование, завершение, уничтожение |
| куча | montículo (heap) | память, где живут объекты из new |
| LIFO | LIFO | последним пришёл — первым ушёл (стек) |
| ссылка на объект | referencia | адрес объекта; например Coche@15db9742 |
| пустая ссылка | null | переменная никуда не указывает |
| создать экземпляр | instanciar | создать объект через new |
| оператор точка | operador punto | вызов метода: objeto.metodo() |
| сокрытие атрибутов | ocultación (shadowing) | параметр с тем же именем закрывает атрибут |
| this | this | «текущий объект», я сам |
| блочная переменная | variable de bloque | живёт только внутри if/for/while |
| toString | toString() | строка с данными объекта, вызывается в println |
Конструкторы, private, get/set, static
Manipulación de clases y objetos
У хорошо написанного класса атрибуты private, есть конструкторы, чтобы создавать объекты, get и set, чтобы получать доступ к данным, и static для того, что общее у всех объектов.
«Una clase bien hecha tiene los atributos privados, constructores para crear los objetos, getters y setters para acceder a sus datos, y usa static para lo que es común a todos los objetos.»
Это «итоговая» тема: она собирает всё из 7 и 8 в правильно написанный класс. Именно такие классы ты пишешь в практиках (Gimnasio, Hotel). Если поймёшь эту тему, поймёшь, как устроены почти все программы на Java.
Объекты общаются сообщениями
Объекты работают вместе, вызывая методы друг друга. Это называется передача сообщенийpaso de mensajes: тот, кто вызывает, отправляет сообщение, другой его получает. recepcion.reservar(cliente, habitacion) — ресепшен «просит» забронировать.
Жизнь программы: создаём объекты → они общаются сообщениями → сборщик мусора убирает ненужные.
Конструкторы
Конструкторconstructor — особый метод, который инициализирует объект. Три признака, их спрашивают:
- Называется точно как класс.
- Ничего не возвращает, даже
voidне пишется. - Выполняется вместе с
new.
| Вид | Что делает |
|---|---|
| По умолчаниюpor defecto | Без параметров. Если ты не написал ни одного конструктора, Java создаст его сам и поставит: 0 в числа, null в String и объекты, false в boolean |
| С параметрамиcon parámetros | Получает значения для атрибутов |
| Копированияde copia | Получает другой объект того же класса и создаёт новый, независимый, с теми же значениями. В классе может быть только один |
- Перегрузка конструкторовsobrecarga de constructores — в классе может быть несколько конструкторов с разными параметрами. Один может вызвать другой через
this(...). - Деструкторыdestructores — в Java их нет. Память освобождает сборщик мусора.
Если ты написал конструктор с параметрами, Java больше не создаёт конструктор по умолчанию сам. Тогда new Perro() не скомпилируется, пока не напишешь public Perro() { ... } вручную.
Зачем нужен конструктор копирования
Вспомни тему 8: Alumno b = a; — это не копия, это второй пульт к тому же телевизору. Поменял через b — «поменялись оба». Конструктор копирования делает новый телевизор с теми же настройками. Как ксерокопия документа против ссылки на Google Docs.
Модификаторы доступа: кто что видит
Соседние классыclases vecinas — в одном пакете. Внешние классыclases externas — в разных пакетах.
Видимость класса:
| Модификатор | Соседний класс | Внешний класс |
|---|---|---|
| Без модификатора | Виден | Не виден |
public | Виден | Виден |
Видимость членов (атрибутов и методов):
| Модификатор | Свой класс | Соседний | Внешний |
|---|---|---|---|
private | Виден | Не виден | Не виден |
| Без модификатора | Виден | Виден | Не виден |
public | Виден | Виден | Виден |
Аналогия: private — твой дневник, читаешь только ты. Без модификатора — холодильник в квартире: доступен всем, кто живёт в этой квартире (пакете). public — объявление на подъезде: читает кто угодно.
Атрибуты private, методы public.
«Regla de oro del encapsulamiento: atributos private y métodos public.»
Getters и setters
- Get (наблюдатель)get (observador) — возвращает значение private-атрибута. Без параметров. Обычно по одному на атрибут:
getNombre(). - Set (модификатор)set (modificador) — меняет значение private-атрибута. Получает новое значение, ничего не возвращает (
void). Главное — может проверить данные перед сохранением.
Если edad публичный, любой может написать alumno.edad = -50;, и программа будет хранить чепуху. Через setEdad ты сам решаешь: «отрицательный возраст не принимаю». Это как охранник у входа: внутрь только по правилам.
Полный класс Alumno
public class Alumno {
private String nombre;
private String apellido;
private int edad;
// Конструктор по умолчанию
public Alumno() {
this("Sin nombre", "Sin apellido", 0); // вызывает конструктор с 3 параметрами
}
// Конструктор с параметрами
public Alumno(String nombre, String apellido, int edad) {
this.nombre = nombre;
this.apellido = apellido;
this.edad = edad;
}
// Конструктор копирования
public Alumno(Alumno otro) {
this.nombre = otro.nombre;
this.apellido = otro.apellido;
this.edad = otro.edad;
}
// Getters
public String getNombre() { return nombre; }
public int getEdad() { return edad; }
// Setters
public void setNombre(String nombre) { this.nombre = nombre; }
public void setEdad(int edad) {
if (edad >= 0) { // проверяем, прежде чем сохранить
this.edad = edad;
}
}
}Alumno a1 = new Alumno(); // по умолчанию
Alumno a2 = new Alumno("Sara", "Ruiz", 17); // с параметрами
Alumno a3 = new Alumno(a2); // копия: НОВЫЙ независимый объект
a3.setNombre("Marta");
System.out.println(a2.getNombre()); // Sara — a2 не изменился
System.out.println(a3.getNombre()); // Marta
System.out.println(a1.getNombre()); // Sin nombre
a2.setEdad(-5); // set не примет отрицательное
System.out.println(a2.getEdad()); // 17Sara Marta Sin nombre 17
static: общее для всех объектов
- Статический атрибут (атрибут класса)atributo estático (de clase) — принадлежит классу, а не каждому объекту. Он один на всех: если один объект его изменил, это видят все. Например, общая скидка для всех машин или общий рубильник для всех лампочек.
- Статический метод (метод класса)método estático (de clase) — вызывается через имя класса, без создания объекта:
Math.sqrt(9). Самый известный —main. Может использовать только статические атрибуты и вызывать только другие статические методы. - Статический блокbloque estático —
static { ... }. Выполняется один раз, когда класс загружается в память.
Аналогия: у каждого ученика в классе своя тетрадь (обычный атрибут), но доска одна на всех (статический). Учитель стёр доску — это увидели все.
public class Bombilla {
private boolean encendida; // у каждой лампочки своя
private static boolean interruptorGeneral = true; // один рубильник на все
public void encender() { encendida = true; }
public boolean daLuz() {
return encendida && interruptorGeneral;
}
public static void cortarLuz() { // метод класса
interruptorGeneral = false;
}
}Bombilla b1 = new Bombilla();
Bombilla b2 = new Bombilla();
b1.encender();
b2.encender();
Bombilla.cortarLuz(); // вызываем через имя класса
System.out.println(b1.daLuz()); // false
System.out.println(b2.daLuz()); // false — касается всехfalse false
Ошибка non-static ... cannot be referenced from a static context значит: из main (он static) ты пытаешься использовать что-то не static. Решение: создать объект и вызывать через него, или объявить этот элемент static.
Перечисления (enum)
Перечислениеenumerado (enum) — тип с фиксированным набором именованных констант: дни недели, времена года, размеры одежды. Вместо того чтобы хранить день как число 1–7 (и случайно записать 8), ты используешь DiaSemana.MARTES — другого значения просто не бывает. Могут иметь атрибуты, конструкторы и методы, отлично работают со switch. Появились в Java 5.0.
public enum DiaSemana { LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO }
DiaSemana dia = DiaSemana.MARTES;
switch (dia) {
case LUNES: System.out.println("Es lunes"); break;
case MARTES: System.out.println("Es martes"); break;
default: System.out.println("Otro día");
}Es martes
Внутри case пишется просто LUNES, без DiaSemana. — Java уже знает тип.
Библиотеки и пакеты
- Пакетpaquete — папка, которая объединяет родственные классы.
- Библиотекаbiblioteca (library) — набор классов с общей функцией, упакованный в файл
.jar, чтобы переиспользовать и делиться. - Собственные — идут с JDK (как
System). Внешние — сделаны другими (например, для подключения к базе данных). - Подключаются через
import:import paquete.Clase;илиimport paquete.*;(все классы пакета; лучше импортировать только нужные). - В NetBeans: создать библиотеку — Java Class Library + Clean and Build (появится
.jarв папкеbuild). Подключить — правый клик по Libraries → Add JAR/Folder. - Библиотеки соблюдают инкапсуляцию (классы с общей функцией вместе) и сокрытие информации (пользуешься, не видя их код).
import java.util.Scanner; // один конкретный класс
import java.util.*; // все классы пакета java.utilПроверь себя · Comprueba si lo sabes
¿Qué diferencia hay entre un atributo normal y uno static?Чем обычный атрибут отличается от static?
Un atributo normal es propio de cada objeto; uno static es de la clase y lo comparten todos los objetos.
Обычный — свой у каждого объекта. Static — один на класс, общий для всех.
¿Qué tres características tiene un constructor en Java?Три признака конструктора?
Se llama igual que la clase, no devuelve nada (ni void) y se ejecuta con new.
Имя как у класса, ничего не возвращает (даже void), выполняется с new.
¿Para qué sirve el constructor de copia? ¿Qué pasa si en su lugar haces b = a;?Зачем конструктор копирования? Что будет при b = a;?
Para crear un objeto nuevo e independiente con los mismos valores que otro. Con b = a; las dos variables apuntan al mismo objeto, así que si cambias uno «cambian los dos».
Создать новый независимый объект с теми же значениями. При b = a; обе переменные указывают на один объект.
Un atributo private, ¿se puede usar desde una clase vecina? ¿Cómo se accede a él desde fuera?Можно ли использовать private-атрибут из соседнего класса? Как получить к нему доступ?
No. Desde fuera se accede con sus métodos get y set.
Нет. Снаружи — только через get и set.
¿Qué es un enum? Pon un ejemplo.Что такое enum? Пример.
Un tipo de dato con un conjunto fijo de constantes con nombre. Ejemplo: enum Estacion { PRIMAVERA, VERANO, OTONO, INVIERNO }.
Тип с фиксированным набором именованных констант.
Словарик темы
| По-русски | En español | Что это, коротко |
|---|---|---|
| передача сообщений | paso de mensajes | объекты вызывают методы друг друга |
| конструктор по умолчанию | constructor por defecto | без параметров; Java создаёт сам, если нет других |
| конструктор с параметрами | constructor con parámetros | получает значения атрибутов |
| конструктор копирования | constructor de copia | новый независимый объект с теми же значениями |
| перегрузка конструкторов | sobrecarga de constructores | несколько конструкторов; this(...) вызывает другой |
| модификатор доступа | modificador de acceso | private, без модификатора, public |
| соседний класс | clase vecina | в том же пакете |
| внешний класс | clase externa | в другом пакете |
| get | getter (observador) | возвращает значение private-атрибута |
| set | setter (modificador) | меняет private-атрибут, может проверять данные |
| статический атрибут | atributo estático (de clase) | один на класс, общий для всех объектов |
| статический метод | método estático (de clase) | вызывается через имя класса, например Math.sqrt |
| статический блок | bloque estático | static { }, выполняется один раз при загрузке класса |
| перечисление | enumerado (enum) | фиксированный набор именованных констант |
| библиотека (.jar) | biblioteca (library) | упакованные классы для повторного использования |
| импорт | import | подключить класс из пакета |
Ошибки и как их чинить
Ошибки — это не катастрофа, а подсказки. Java пишет, что не так, просто на своём языке. Вот перевод самых частых сообщений.
| Сообщение | Что обычно случилось | Как починить |
|---|---|---|
';' expected | Забыл точку с запятой | Проверь конец этой строки или предыдущей |
cannot find symbol | Имя написано с ошибкой, переменная не объявлена или вне своей области видимости, или нет import | Проверь большие и маленькие буквы и где ты её объявил |
incompatible types | Кладёшь значение в неподходящий тип: int x = 2.5; | Поменяй тип или сделай casting |
missing return statement | Метод не void, но есть путь без return | Поставь return во все ветки |
ArrayIndexOutOfBoundsException | Вышел за границы массива | В цикле i < array.length, а не <= |
NullPointerException | Используешь объект, который равен null | Создай объект через new до использования |
StackOverflowError | Рекурсия без базового случая или никогда до него не доходит | Проверь базовый случай |
InputMismatchException | Ввели текст там, где ждали число | Проверь, что вводится |
non-static … cannot be referenced from a static context | Используешь не-static из main | Создай объект или объяви элемент static |
| Программа не заканчивается | Бесконечный цикл | Проверь, что переменная условия меняется |
Две одинаковые String дают false | Сравниваешь через == | Используй equals() |
nextLine() «проскакивает» после nextInt() | В буфере остался Enter | Добавь лишний lectura.nextLine(); |
Словарь RU · ES
Все 150 терминов из учебника в одном месте. Ищи по-русски или по-испански. Номер справа — тема, где термин объясняется.
Ничего не нашлось. Попробуй часть слова: «recurs», «масс».
| По-русски | En español | Что это, коротко | Тема |
|---|---|---|---|
| driver | driver | метод-посредник: проверяет данные один раз | 5 |
| get | getter (observador) | возвращает значение private-атрибута | 9 |
| LIFO | LIFO | последним пришёл — первым ушёл (стек) | 8 |
| set | setter (modificador) | меняет private-атрибут, может проверять данные | 9 |
| this | this | «текущий объект», я сам | 8 |
| toString | toString() | строка с данными объекта, вызывается в println | 8 |
| абстракция | abstracción | оставить только важное для задачи | 7 |
| агрегация | agregación | части живут и без целого | 7 |
| алгоритм | algoritmo | конечный упорядоченный набор шагов, решающий задачу | 1 |
| ассоциация | asociación | связь «имеет» | 7 |
| атрибут | atributo | данные, характеристика объекта | 7 |
| базовый случай | caso base | останавливает рекурсию, ответ известен сразу | 5 |
| бесконечный цикл | bucle infinito | цикл, который никогда не заканчивается | 3 |
| библиотека | librería | готовые функции языка, например Math | 4 |
| библиотека (.jar) | biblioteca (library) | упакованные классы для повторного использования | 9 |
| бинарный поиск | búsqueda binaria | делит пополам, только для отсортированного, O(log n) | 6 |
| блок | bloque | код между фигурными скобками { } | 2 |
| блок-схема | diagrama de flujo | алгоритм в виде фигур и стрелок | 1 |
| блочная переменная | variable de bloque | живёт только внутри if/for/while | 8 |
| вложенный if | if anidado | if внутри другого if | 3 |
| внешний класс | clase externa | в другом пакете | 9 |
| возвращать | devolver (return) | отдать результат тому, кто вызвал | 4 |
| восходящее проектирование | diseño ascendente (bottom-up) | от мелких деталей к целому | 4 |
| вспомогательная переменная | variable auxiliar (aux) | временное место для обмена значений | 6 |
| вход / выход | entrada / salida | что даём программе / что она возвращает | 1 |
| выбор | selección | программа решает, какой блок выполнить (if, switch) | 3 |
| выражение | expresión | комбинация значений и операторов, дающая одно значение | 2 |
| глобальная переменная | variable global | видна везде, опасна | 4 |
| данное | dato | отдельное значение без контекста | 1 |
| действенный | eficaz | делает то, что должен | 1 |
| деструктор | destructor | в Java нет, работает сборщик мусора | 7 |
| детерминизм | determinismo | одинаковые данные → одинаковый результат | 1 |
| длина | longitud (length) | количество элементов | 6 |
| жизненный цикл объекта | ciclo de vida de un objeto | создание, инициализация, использование, завершение, уничтожение | 8 |
| жизненный цикл ПО | ciclo de vida del software | анализ, спецификация, проектирование, реализация, тесты, сопровождение | 1 |
| зависимость | dependencia | связь «использует», временная | 7 |
| идентификатор | identificador | имя переменной, константы или метода | 2 |
| идентичность | identidad | делает объект уникальным, даже при одинаковых значениях | 8 |
| импорт | import | подключить класс из пакета | 9 |
| индекс | índice | номер ячейки, начиная с 0 | 6 |
| инициализация | inicialización | первое значение переменной | 2 |
| инкапсуляция | encapsulamiento | данные защищены, доступ через методы | 7 |
| интерпретатор | intérprete | переводит и выполняет по одной инструкции | 1 |
| информация | información | обработанные и объяснённые данные | 1 |
| итерация | iteración | решение через цикл | 5 |
| класс | clase | шаблон, форма для объектов | 7 |
| комментарий | comentario | пояснение для людей, Java его не выполняет | 2 |
| компилятор | compilador | переводит всю программу сразу | 1 |
| композиция | composición | части существуют только с целым | 7 |
| конечность | finitud | алгоритм обязательно заканчивается | 1 |
| константа | constante | значение не меняется, объявляется с final | 2 |
| конструктор | constructor | задаёт значения при создании объекта | 7 |
| конструктор копирования | constructor de copia | новый независимый объект с теми же значениями | 9 |
| конструктор по умолчанию | constructor por defecto | без параметров; Java создаёт сам, если нет других | 9 |
| конструктор с параметрами | constructor con parámetros | получает значения атрибутов | 9 |
| косвенная рекурсия | recursividad indirecta | A → B → … → A | 5 |
| кратность | multiplicidad | сколько объектов в связи: 1, 0..1, 0..*, 1..* | 7 |
| куча | montículo (heap) | память, где живут объекты из new | 8 |
| линейный поиск | búsqueda lineal | проверяет по одному, O(n) | 6 |
| логические операторы | operadores lógicos | && (И), || (ИЛИ), ! (НЕ) | 2 |
| локальная переменная | variable local | существует только внутри своего метода | 4 |
| массив | array (vector) | набор элементов одного типа под одним именем | 6 |
| матрица | matriz (array bidimensional) | массив массивов: строки и столбцы | 6 |
| метод | método | подпрограмма в Java | 4 |
| множественная рекурсия | recursividad múltiple | несколько вызовов себя в одном случае | 5 |
| множественный выбор | selección múltiple (switch) | выбор по конкретным значениям переменной | 3 |
| модификатор (метод) | método modificador (set) | меняет данные объекта | 7 |
| модификатор доступа | modificador de acceso | private, без модификатора, public | 9 |
| модульное программирование | programación modular | делить программу на независимые модули | 4 |
| наблюдатель | método observador (get) | узнаёт данные объекта | 7 |
| наследование | herencia | потомок получает всё от родителя (extends) | 7 |
| неизменяемый | inmutable | String не меняется, методы возвращают новую строку | 6 |
| неявное приведение | implícito (upcasting) | из маленького типа в большой, делает Java сам | 2 |
| нисходящее проектирование | diseño descendente (top-down) | от общей задачи к мелким подзадачам | 4 |
| обобщение | generalización | связь «является», наследование | 7 |
| объект / экземпляр | objeto / instancia | конкретная вещь, созданная по классу | 7 |
| объявление | declaración | тип + имя, резервирует память | 2 |
| ООП | POO (Programación Orientada a Objetos) | программа из объектов с данными и методами | 7 |
| оператор точка | operador punto | вызов метода: objeto.metodo() | 8 |
| операторы перехода | sentencias de salto | break, continue, return, goto | 3 |
| операторы сравнения | operadores relacionales | ==, !=, >, <, >=, <=; дают true/false | 2 |
| остаток от деления | resto (%) | что остаётся после целочисленного деления | 2 |
| отладчик | depurador | инструмент, чтобы искать ошибки по шагам | 1 |
| пакет | paquete | папка с родственными классами, например java.util | 2 |
| перегрузка конструкторов | sobrecarga de constructores | несколько конструкторов; this(...) вызывает другой | 9 |
| перегрузка методов | sobrecarga de métodos | одно имя, разные параметры | 4 |
| передача по значению | paso por valor | метод получает копию, оригинал не меняется | 4 |
| передача по ссылке | paso por referencia | метод получает адрес, оригинал меняется | 4 |
| передача сообщений | paso de mensajes | объекты вызывают методы друг друга | 9 |
| переменная | variable | место в памяти с именем, значение меняется | 2 |
| переполнение стека | desbordamiento de pila (StackOverflowError) | слишком много вызовов, программа падает | 5 |
| перечисление | enumerado (enum) | фиксированный набор именованных констант | 9 |
| поведение | comportamiento | что объект умеет: его методы | 8 |
| повторение | iteración | цикл: блок выполняется много раз | 3 |
| подкласс | subclase (clase hija) | класс-потомок | 7 |
| подпрограмма | subprograma (módulo) | кусок программы со своей задачей | 4 |
| полиморфизм | polimorfismo | один метод — разное поведение у разных объектов | 7 |
| последовательность | secuencia | инструкции выполняются по порядку | 3 |
| поток выполнения | flujo de ejecución | порядок, в котором выполняются инструкции | 3 |
| преинкремент / постинкремент | preincremento / postincremento | ++x сначала прибавляет; x++ сначала использует | 2 |
| приведение типов | casting | превращение значения в другой тип | 2 |
| примитивный тип | tipo primitivo (simple) | неделимый тип: int, double, char, boolean | 2 |
| программа | programa | инструкции «в покое», на диске | 1 |
| процедура | procedimiento | метод, который ничего не возвращает (void) | 4 |
| процесс | proceso | программа в момент выполнения | 1 |
| прямая рекурсия | recursividad directa | метод вызывает сам себя | 5 |
| псевдокод | pseudocódigo | алгоритм обычными словами по правилам | 1 |
| пузырёк | método de la burbuja | меняет соседей местами, O(n²) | 6 |
| пустая ссылка | null | переменная никуда не указывает | 8 |
| рекурсивный случай | caso recursivo (general, inductivo) | вызов самого себя с меньшим значением | 5 |
| рекурсия | recursividad | метод вызывает сам себя с задачей поменьше | 5 |
| сборщик мусора | recolector de basura (garbage collector) | сам освобождает ненужную память | 6 |
| семантика | semántica | смысл кода: что он делает на самом деле | 1 |
| синтаксис | sintaxis | правила написания кода, «грамматика» | 1 |
| сложность | complejidad | как растёт работа с ростом данных, O(n) | 1 |
| служебное слово | palabra reservada | слово, занятое Java: int, class, if… | 2 |
| создать экземпляр | instanciar | создать объект через new | 8 |
| сокрытие атрибутов | ocultación (shadowing) | параметр с тем же именем закрывает атрибут | 8 |
| сокрытие информации | ocultación de la información | решать, что видно снаружи | 7 |
| сопровождение | mantenimiento | исправления после запуска, 80 % цикла | 1 |
| сортировка | ordenación | расставить элементы по порядку | 6 |
| соседний класс | clase vecina | в том же пакете | 9 |
| состояние | estado | значения атрибутов в данный момент | 8 |
| среда разработки | IDE (Entorno de Desarrollo Integrado) | редактор + компилятор + отладчик вместе, например NetBeans | 1 |
| ссылка | referencia | адрес в памяти, где лежит массив или объект | 6 |
| ссылка на объект | referencia | адрес объекта; например Coche@15db9742 | 8 |
| статический атрибут | atributo estático (de clase) | один на класс, общий для всех объектов | 9 |
| статический блок | bloque estático | static { }, выполняется один раз при загрузке класса | 9 |
| статический метод | método estático (de clase) | вызывается через имя класса, например Math.sqrt | 9 |
| стек вызовов | pila de llamadas (stack) | память, где ждут незаконченные вызовы; LIFO | 5 |
| строка | cadena (String) | текст в двойных кавычках | 2 |
| строка / столбец | fila / columna | горизонтальный ряд / вертикальный ряд | 6 |
| строка символов | cadena de caracteres | текст, последовательность символов | 6 |
| суперкласс | superclase (clase padre) | более общий класс-родитель | 7 |
| тело цикла | cuerpo | то, что повторяется | 3 |
| теорема о структуре | teorema de la estructura | любая программа = последовательность + выбор + повторение | 3 |
| тернарный оператор | operador ternario | if-else в одну строку: cond ? a : b | 2 |
| тип данных | tipo de dato | что хранится: int, double, char, String, boolean | 2 |
| управляющая конструкция | estructura de control | то, что меняет порядок: if, switch, циклы | 3 |
| управляющая последовательность | secuencia de escape | \n, \t, \" … | 6 |
| усилие разработки | esfuerzo de desarrollo | сколько времени придумать и написать решение | 5 |
| условие завершения | condición de finalización | когда цикл должен остановиться | 3 |
| фактические параметры | parámetros reales (argumentos) | значения, передаваемые при вызове | 4 |
| формальные параметры | parámetros formales | параметры в определении метода, с типами | 4 |
| функция | función | метод, который возвращает значение (return) | 4 |
| цикл | bucle | повторяющийся блок кода | 3 |
| чтение с клавиатуры | Scanner (lectura) | класс для ввода: nextInt, nextDouble, nextLine, next | 2 |
| чёрный ящик | caja negra | важно, что модуль получает и отдаёт, а не как он устроен | 4 |
| эффективный | eficiente | делает быстро и тратит мало ресурсов | 1 |
| явное приведение | explícito (downcasting) | из большого в маленький, пишешь (int); теряются данные | 2 |
Составлено по «Guía de estudio de Programación (Java), Temas 1–9» Natalia Mártir · Davante MEDAC. Примеры Perro и Hotel — как в практиках курса.