Прикладное программирование и веб-технологии

Тема 5.1

Объектно-ориентированное программирование

Понятие класса, поля и методы, ссылочные переменные, инкапсуляция, наследование, полиморфизм и динамическое связывание — вопросы билетов №6, №18.

Понятие класса и объекта

Синтаксис и структура класса (на Java-подобном языке):

class Point {
    // поля (данные объекта)
    private double x;
    private double y;

    // конструктор — вызывается при создании экземпляра
    Point(double x, double y) { this.x = x; this.y = y; }

    // методы (операции над данными)
    double dist() { return Math.sqrt(x*x + y*y); }
    void moveTo(double nx, double ny) { x = nx; y = ny; }
}

• Описание полей — как объявление переменных, но внутри класса; каждое поле имеет тип и модификатор доступа.
• Описание методов — функции внутри класса; им доступны все поля «своего» объекта (через this / self).
• Модификаторы доступа: public — виден всем; private — только внутри класса; protected — внутри класса и наследников.
• Создание экземпляра: Point p = new Point(3, 4); — выделяется память в куче, вызывается конструктор.
• Доступ к полям и вызов методов — через точку: p.dist(), p.moveTo(0, 0).

Конструкторы, деструкторы и статические члены

• Перегрузка конструкторов: Point(), Point(x, y), Point(other) (копирующий) — нужный выбирается по числу и типам аргументов.
• Статические (классовые) члены объявляются словом static и принадлежат классу, а не объекту: одно поле на все экземпляры (счётчик созданных объектов, общая настройка) и методы, вызываемые без объекта — Math.sqrt(). Статическому методу недоступен this.
• Перегрузка методов (overloading) — несколько методов с одним именем и разными параметрами в одном классе; выбор — на этапе компиляции. Не путать с переопределением (overriding) — заменой унаследованного метода в наследнике с той же сигнатурой; выбор — во время выполнения.

Ссылочные переменные

В большинстве ООП-языков (Java, C#, Python, JavaScript) переменная типа «класс» хранит не сам объект, а ссылку на него: объект живёт в куче (heap), а переменная — лишь «адрес» этого объекта.

Point p1 = new Point(3, 4);
Point p2 = p1;      // копируется ССЫЛКА, а не объект!
p2.moveTo(0, 0);
// p1.dist() == 0 — p1 и p2 указывают на ОДИН объект

Три принципа ООП

• Инкапсуляция — объединение данных и методов в классе и сокрытие внутреннего устройства: поля закрыты (private), доступ — через методы (геттеры/сеттеры), которые могут проверять корректность. Внешний код зависит только от интерфейса класса — внутренности можно менять свободно.
• Наследование — создание нового класса (производного, наследника) на основе существующего (базового): наследник получает все поля и методы родителя, добавляет свои и может переопределять унаследованные методы. Выражает отношение «является» (круг — это фигура).
• Полиморфизм — возможность работать с объектами разных классов через общий интерфейс базового класса: один и тот же вызов fig.draw() выполняет разный код в зависимости от фактического класса объекта.

Часто к трём принципам добавляют четвёртый — абстракцию: в классе отражают только существенные для задачи свойства объекта, отбрасывая второстепенные. Класс Student в деканатской системе хранит ФИО и оценки, но не рост и цвет глаз; тот же студент в медицинской системе абстрагирован иначе. Инкапсуляция — техническое средство абстракции: несущественное прячется за интерфейсом.

class Figure {
    protected double x, y;               // положение — общее для всех
    Figure(double x, double y) { this.x = x; this.y = y; }
    void move(double dx, double dy) { x += dx; y += dy; }
    double area() { return 0; }
}

class Circle extends Figure {            // Circle «является» Figure
    private double r;                    // добавили своё поле
    Circle(double x, double y, double r) {
        super(x, y);                     // вызов конструктора предка
        this.r = r;
    }
    @Override
    double area() { return Math.PI * r * r; }   // переопределили
}

Абстрактные классы и интерфейсы

abstract class Figure {
    abstract double area();            // без тела — контракт
    void report() {                    // общий код для всех фигур
        System.out.println("S = " + area());   // вызов полиморфный!
    }
}
class Circle extends Figure {
    double r;
    double area() { return Math.PI * r * r; }
}

Полиморфизм и динамическое связывание

Механизм: для класса с виртуальными методами компилятор строит таблицу виртуальных методов (vtable) — массив адресов реализаций. Каждый объект хранит указатель на таблицу своего класса. Вызов fig.draw() превращается в «взять из таблицы объекта адрес метода draw и перейти по нему» — поэтому один и тот же код обходит массив фигур, а рисуется каждая по-своему.

Figure[] figs = { new Circle(...), new Square(...), new Triangle(...) };
for (Figure f : figs)
    f.draw();   // тип переменной — Figure, но вызывается
                // Circle.draw / Square.draw / Triangle.draw

В Java методы виртуальны по умолчанию, в C++ нужно слово virtual, в Python всякий вызов метода — позднее связывание (поиск по имени в словаре класса). Полиморфное поведение методов — основа расширяемости: добавив класс Star с собственным draw(), мы не меняем ни строчки в цикле рисования.

Тема 5.2

Python: классы и графический интерфейс

ООП в Python и библиотеки для настольных GUI-приложений — вопросы билетов №3, №12, №13.

ООП в Python

В Python всё — объект: числа, строки, функции, модули и сами классы. Класс объявляется словом class; первый параметр каждого метода — self, ссылка на текущий экземпляр (аналог this, но передаётся явно).

class Vector:
    dim = 2                          # атрибут КЛАССА (общий для всех)

    def __init__(self, x, y):        # конструктор
        self.x = x                   # атрибуты ЭКЗЕМПЛЯРА
        self.y = y

    def length(self):                # обычный метод
        return (self.x**2 + self.y**2) ** 0.5

    def __add__(self, other):        # перегрузка оператора +
        return Vector(self.x + other.x, self.y + other.y)

    def __str__(self):               # строковое представление
        return f"({self.x}; {self.y})"

v = Vector(3, 4) + Vector(1, 0)
print(v, v.length())                 # (4; 4) 5.656...

• Атрибуты класса и экземпляра: dim один на всех, self.x — у каждого объекта свой. Атрибуты можно добавлять динамически.
• Магические методы (__init__, __str__, __add__, __eq__, __len__…) встраивают класс в синтаксис языка: операторы, печать, сравнение, len().
• Наследование: class Circle(Figure):; вызов родительской реализации — super().__init__(...). Поддерживается множественное наследование (порядок поиска — MRO).
• Инкапсуляция — соглашением: «приватные» имена начинают с подчёркивания _x (или __x — имя искажается), настоящих модификаторов доступа нет. Контролируемый доступ — декоратор @property: снаружи это поле, внутри — метод с проверками.
• Утиная типизация: полиморфизм без общего базового класса — подойдёт любой объект, у которого есть нужный метод («если крякает как утка — это утка»). Проверка типов происходит в момент вызова.

class Circle:
    def draw(self): print("круг")

class Star:                # НЕ наследует Circle и вообще ничего
    def draw(self): print("звезда")

for f in [Circle(), Star()]:
    f.draw()               # работает: у обоих есть draw()

Инкапсуляция, property и виды методов

Настоящих модификаторов доступа в Python нет — приватность держится на соглашениях и одном механизме языка:

• _x — «внутреннее, не трогайте»: чистое соглашение, доступ не ограничен;
• __x — искажение имени (name mangling): интерпретатор переименовывает атрибут в _ИмяКласса__x; случайный доступ и конфликт имён в наследниках исключены, намеренный — возможен;
• @property — контролируемый доступ: снаружи атрибут, внутри метод с проверками.

class Account:
    def __init__(self):
        self._balance = 0

    @property
    def balance(self):              # чтение: acc.balance
        return self._balance

    @balance.setter
    def balance(self, value):       # запись: acc.balance = 100
        if value < 0:
            raise ValueError("баланс не может быть отрицательным")
        self._balance = value

Три вида методов в классе:

• обычный метод получает self — работает с конкретным экземпляром;
• классовый метод @classmethod получает cls — сам класс; типичное применение — альтернативные конструкторы: Date.from_string("17.08.2026");
• статический метод @staticmethod не получает ни self, ни cls — обычная функция, положенная в класс «по смыслу».

Множественное наследование и MRO

Python разрешает несколько базовых классов: class C(A, B). Возникает вопрос «ромба»: если A и B оба наследуют X и переопределяют его метод — чью версию получит C? Ответ даёт MRO (method resolution order) — линейный порядок поиска методов, вычисляемый алгоритмом C3-линеаризации: каждый класс встречается один раз, наследники всегда раньше предков, порядок перечисления баз сохраняется.

class X:
    def who(self): return "X"

class A(X):
    def who(self): return "A"

class B(X):
    def who(self): return "B"

class C(A, B):
    pass

C().who()      # "A"
C.__mro__      # (C, A, B, X, object)

Исключения в Python

Ошибки времени выполнения — объекты-исключения; они «летят» вверх по стеку вызовов, пока их не перехватят. Обработка — блок try:

try:
    x = int(input("Введите число: "))
    print(100 / x)
except ValueError:
    print("это не число")
except ZeroDivisionError as e:   # объект исключения доступен как e
    print("деление на ноль:", e)
else:                            # выполняется, если исключений НЕ было
    print("успех")
finally:                         # выполняется всегда — очистка ресурсов
    print("конец попытки")

• Исключения образуют иерархию классов (ValueError, TypeError, KeyError… — наследники Exception); except ловит указанный класс и всех его наследников.
• Своё исключение — класс-наследник Exception; возбуждается оператором raise.
• Для файлов и соединений вместо try/finally используют менеджер контекста: with open("f.txt") as f: — файл закроется сам даже при ошибке.
• Идиома Python «проще попросить прощения, чем разрешения»: попытаться и перехватить ошибку вместо цепочки предварительных проверок — стиль, дополняющий утиную типизацию.

GUI-библиотеки Python

Все настольные GUI строятся по одной схеме: окно из виджетов (кнопки, поля, списки) + цикл обработки событий (event loop), который ждёт действий пользователя и вызывает привязанные обработчики. Библиотеки отличаются происхождением и лицензией:

import tkinter as tk

def on_click():
    lbl["text"] = "Привет, " + entry.get()

root = tk.Tk()                 # главное окно
entry = tk.Entry(root);  entry.pack()
tk.Button(root, text="OK", command=on_click).pack()
lbl = tk.Label(root);    lbl.pack()
root.mainloop()                # цикл обработки событий

Менеджеры компоновки Tkinter — три способа расставить виджеты в окне:

• pack(side=...) — виджеты по очереди «прижимаются» к сторонам контейнера: быстро для простых форм;
• grid(row=, column=) — таблица строк и столбцов: основной способ для форм «подпись — поле»;
• place(x=, y=) — абсолютные координаты: полный контроль, но интерфейс не подстраивается под размер окна.

Тема 5.3

Веб-технологии: HTML, CSS, JavaScript

Теговая разметка и структура документа, применение CSS и селекторы, объектная модель документа — вопросы билетов №1, №17.

HTML: теговая разметка и структура документа

Принцип теговой разметки: содержимое документа размечается парными тегами <тег атрибут="значение">…</тег> (есть и одиночные: <img>, <br>, <input>). Теги задают структуру и смысл частей документа, а не внешний вид — вид определяет CSS. Теги могут вкладываться, образуя дерево.

<!DOCTYPE html>                  <!-- тип документа: HTML5 -->
<html lang="ru">
<head>                           <!-- служебная часть: не отображается -->
  <meta charset="utf-8">
  <title>Заголовок вкладки</title>
  <link rel="stylesheet" href="style.css">
</head>
<body>                           <!-- видимое содержимое -->
  <h1>Заголовок</h1>
  <p class="note">Абзац с <a href="…">ссылкой</a>.</p>
</body>
</html>

• Типы html-документов задаёт декларация <!DOCTYPE>: современный HTML5 (<!DOCTYPE html>) против исторических HTML 4.01 и XHTML (строгий XML-синтаксис) с длинными DTD-декларациями. DOCTYPE переключает браузер в стандартный режим разбора.
• Основные группы тегов: структурные (div, header, section), текстовые (h1–h6, p, ul/ol/li, table), гипертекст (a), медиа (img, video), формы (form, input, select, textarea).
• Глобальные атрибуты id (уникальное имя элемента) и class (метка группы) — «крючки», за которые элемент цепляют CSS и JavaScript.

Семантические теги HTML5 размечают роли частей страницы: header (шапка), nav (навигация), main (основное содержимое), article (самостоятельный материал), section (смысловой раздел), aside (боковая колонка), footer (подвал). Для отображения это те же блоки, что и div, но смысловая разметка помогает поисковым системам и программам чтения с экрана понять структуру.

<form action="/reg.php" method="post">
  <input type="text"     name="login" required minlength="3">
  <input type="password" name="pwd">
  <input type="email"    name="mail">    <!-- проверка формата почты -->
  <input type="number"   name="age" min="16" max="99">
  <select name="city">
    <option>Тамбов</option><option>Москва</option>
  </select>
  <textarea name="about"></textarea>
  <input type="submit" value="Отправить">
</form>

CSS: способы применения и селекторы

Синтаксис CSS: правило = селектор { свойство: значение; … }. Три способа применить стили к документу:

1. Внешняя таблица стилей — <link rel="stylesheet" href="style.css">: один файл на весь сайт, кэшируется браузером — основной способ.
2. Внутренняя — правила в теге <style> в head данной страницы.
3. Встроенный стиль — атрибут style="color:red" у конкретного элемента: самый высокий приоритет, но смешивает структуру с оформлением.

Виды селекторов:

Если элементу подходят несколько правил, побеждает более специфичный селектор (id > класс/атрибут/псевдокласс > тег), при равенстве — то, что объявлено позже (каскад). Часть свойств (шрифт, цвет) наследуется потомками.

Блочная модель и раскладка

Каждый элемент для браузера — прямоугольник из четырёх зон: содержимое (content) → внутренние отступы (padding) → рамка (border) → внешние отступы (margin). По умолчанию итоговая ширина складывается из width + padding + border; режим box-sizing: border-box включает отступы и рамку внутрь заданной width — с ним вёрстка предсказуемее.

• Блочные элементы (div, p, h1) занимают всю ширину и идут сверху вниз; строчные (span, a, b) текут внутри строки. Свойство display переключает поведение: block / inline / inline-block / none (скрыть).
• Позиционирование position: static (обычный поток) · relative (сдвиг относительно своего места) · absolute (координаты от ближайшего позиционированного предка, из потока изъят) · fixed (относительно окна, не прокручивается) · sticky (прилипает при прокрутке).
• Flexbox — современная раскладка рядов и колонок: контейнеру задают display:flex, элементы выстраиваются вдоль главной оси; justify-content распределяет их по главной оси, align-items — по поперечной. Отзывчивые интерфейсы без таблиц и обтеканий.

Язык JavaScript: типы, функции, замыкания

JavaScript — интерпретируемый язык с динамической типизацией, исполняемый в браузере (движки V8, SpiderMonkey): тип принадлежит значению, а не переменной. Подключается тегом <script src="app.js"></script> или блоком <script>…</script>.

• Типы данных: числа (единый тип number), строки, логический, undefined (значения нет), null (пусто намеренно), объекты {key: value}, массивы; функции — тоже значения.
• Объявление переменных: let — изменяемая, блочная область видимости; const — константа (выбор по умолчанию); историческое var — функциональная область видимости и «всплытие» объявления, источник ошибок.
• Сравнение: === — строгое, без преобразования типов; == — с приведением ("5" == 5 истинно!). Правило практики: всегда ===.
• Функции — значения первого класса: их передают аргументами и возвращают из функций; стрелочная запись x => x * 2; методы массивов map / filter / forEach принимают функции-обработчики.
• Замыкание — функция «помнит» переменные места, где была создана, даже после выхода из него: на этом держатся обработчики событий и сокрытие данных.
• JSON — текстовый формат обмена «объект как литерал»: JSON.stringify(obj) ↔ JSON.parse(str); стандарт обмена клиента с сервером.
• AJAX / fetch — запрос к серверу без перезагрузки страницы: fetch(url).then(r => r.json()).then(render); так работают «живые» интерфейсы — подсказки в поиске, бесконечные ленты.

function makeCounter() {
    let n = 0;                 // локальная переменная...
    return () => ++n;          // ...живёт, пока жива функция
}
const next = makeCounter();
next(); next(); next();        // 1, 2, 3 — n сохраняется между вызовами

JavaScript и объектная модель документа (DOM)

• Отношения элементов: у узла есть родитель (parentNode), дети (children, firstElementChild, lastElementChild) и соседи (previousElementSibling / nextElementSibling) — по дереву можно ходить в любую сторону.
• Методы поиска элементов: document.getElementById('top') — по id; getElementsByTagName, getElementsByClassName — живые коллекции; универсальные querySelector(css) / querySelectorAll(css) — по любому CSS-селектору.
• Свойства элементов: innerHTML (разметка внутри), textContent (только текст), value (у полей форм), style (встроенные стили), classList (add / remove / toggle классов), атрибуты — getAttribute / setAttribute.
• Создание и управление: document.createElement('li') → наполнить → вставить: parent.append(el), parent.prepend(el), ref.before(el) / ref.after(el); переместить — просто append в новое место (узел один, он переезжает); удалить — el.remove().
• События: el.addEventListener('click', fn) — браузер вызовет fn при клике; события всплывают от элемента к корню, обработчик получает объект события.

const ul = document.querySelector('#list');
ul.addEventListener('click', e => {
    const li = e.target.closest('li');   // на каком li случился клик
    if (li) li.classList.toggle('done');
});

Тема 5.4

Серверная сторона: PHP и MySQL

Обработка данных на сервере, передача данных форм, работа с СУБД — вопросы билетов №14, №15.

Архитектура веб-приложения: клиент–сервер

Веб построен на модели «клиент–сервер»: клиент (браузер) отправляет HTTP-запрос, сервер отвечает ресурсом или результатом работы программы. Динамические сайты используют трёхзвенную архитектуру:

1. Клиент — браузер: отображение (HTML/CSS) и поведение (JavaScript);
2. Сервер приложений — веб-сервер (Apache, nginx) + серверный язык (PHP): логика, проверка прав, формирование страниц;
3. Сервер БД — СУБД (MySQL): хранение и выборка данных.

Разделение позволяет масштабировать и заменять звенья независимо: интерфейс можно переписать, не трогая базу. Важно: HTTP — протокол без состояния, каждый запрос самостоятелен, сервер «не помнит» клиента — состояние передают поверх протокола (cookie, сессии).

PHP: обработка данных на сервере

PHP — интерпретируемый язык, выполняющийся на сервере: браузер запрашивает страницу → веб-сервер передаёт файл интерпретатору PHP → тот выполняет код и формирует HTML → браузеру уходит уже готовая разметка (кода PHP клиент никогда не видит). Код встраивается в HTML вставками <?php … ?>.

• Переменные начинаются с $, типизация динамическая: $x = 5; $s = "текст"; — объявления типов не нужны.
• Строки: в двойных кавычках переменные подставляются ("Привет, $name"); конкатенация — точкой: $a . $b.
• Массивы универсальны: индексные [1, 2, 3] и ассоциативные ["name" => "Иван"] — один тип данных; обход — foreach ($arr as $k => $v). Суперглобальные $_GET и $_POST — обычные ассоциативные массивы.
• Функции: function f($a, $b = 1) { return $a + $b; }; управляющие конструкции — как в C: if/else, for, while, switch.

Методы передачи данных из формы на сервер:

• GET — данные в строке адреса: search.php?q=SQL&page=2. Виден в адресе, можно сохранить в закладки, ограничен по длине. Для запросов, которые ничего не меняют (поиск, фильтры).
• POST — данные в теле HTTP-запроса: не видны в адресе, размер практически не ограничен. Для изменения данных, паролей, загрузки файлов.

Суперглобальные массивы доступны в любом месте программы: $_GET и $_POST — данные соответствующего метода (ключ — имя поля формы), $_REQUEST — объединение обоих, $_FILES — загруженные файлы, $_SESSION и $_COOKIE — состояние между запросами, $_SERVER — сведения о запросе и сервере.

<form action="hello.php" method="post">
  <input type="text" name="user">
  <input type="submit" value="Отправить">
</form>

<?php                                  // hello.php
$name = $_POST['user'] ?? 'гость';     // данные поля user
echo "Привет, " . htmlspecialchars($name);
?>

Состояние между запросами: cookie и сессии

Раз HTTP не хранит состояния, «залогиненность» и корзину покупателя реализуют поверх него:

• Cookie — небольшие пары «имя-значение», которые сервер просит браузер хранить (setcookie()) и которые браузер автоматически прикладывает к каждому следующему запросу этому сайту; в PHP доступны через $_COOKIE. Хранятся у клиента, поэтому подделываемы — секретов там не держат.
• Сессия — данные на сервере: session_start() выдаёт браузеру cookie со случайным идентификатором (PHPSESSID), а сами значения ($_SESSION['user']) лежат в файлах или памяти сервера. Клиент видит только идентификатор.

<?php                       // login.php — проверка входа
session_start();
if (check_password($_POST['user'], $_POST['pwd'])) {
    $_SESSION['user'] = $_POST['user'];   // запомнили на сервере
}

// шапка любой защищённой страницы
session_start();
if (!isset($_SESSION['user'])) {
    header("Location: login.php");        // не авторизован — на вход
    exit;
}
?>

PHP и MySQL

Для работы с СУБД в PHP есть расширение mysqli и универсальный интерфейс PDO (работает с разными СУБД). Схема всегда одна: соединиться → выполнить запрос → обработать результат → закрыть.

<?php
// 1. соединение с сервером БД: хост, пользователь, пароль, база
$db = new mysqli("localhost", "root", "secret", "userdata");

// 2а. добавление (модификация, удаление — так же)
$db->query("INSERT INTO users(name, city) VALUES('Иван', 'Тамбов')");
$db->query("UPDATE users SET city='Москва' WHERE id=3");
$db->query("DELETE FROM users WHERE id=7");

// 2б. выборка и обработка результатов
$res = $db->query("SELECT name, city FROM users");
while ($row = $res->fetch_assoc()) {          // строка → ассоц. массив
    echo $row['name'] . " — " . $row['city'] . "<br>";
}
$db->close();
?>

Подготовленные выражения обязательны, когда в запрос попадают данные пользователя: запрос с плейсхолдерами компилируется один раз, значения передаются отдельно и не могут изменить текст SQL — это защита от SQL-инъекций (ввод вида ' OR 1=1 -- в наивно склеенном запросе вернул бы всю таблицу).

$st = $db->prepare("SELECT * FROM users WHERE city = ?");
$st->bind_param("s", $_GET['city']);   // s — строковый параметр
$st->execute();
$res = $st->get_result();

mysqli или PDO? mysqli работает только с MySQL и существует в процедурном и объектном стиле. PDO — единый объектный интерфейс к разным СУБД (MySQL, PostgreSQL, SQLite…): смена базы — это смена строки подключения, а не переписывание кода. PDO поддерживает именованные плейсхолдеры и режим исключений при ошибках:

$pdo = new PDO("mysql:host=localhost;dbname=userdata", "root", "secret");
$st  = $pdo->prepare("SELECT * FROM users WHERE city = :city");
$st->execute(["city" => $_GET['city']]);
$rows = $st->fetchAll();

<?php
$pdo = new PDO("mysql:host=localhost;dbname=userdata", "root", "secret");
$st  = $pdo->prepare("SELECT name, city FROM users WHERE city = :c");
$st->execute(["c" => $_GET['city'] ?? 'Тамбов']);

echo "<table>";
while ($row = $st->fetch()) {
    echo "<tr><td>" . htmlspecialchars($row['name']) .
         "</td><td>" . htmlspecialchars($row['city']) . "</td></tr>";
}
echo "</table>";
?>

Тема 5.5

Архитектура мобильных приложений: Android

Слои платформы, компоненты приложения, жизненный цикл — вопрос билета №9.

Слои платформы Android

Android построен «слоёным пирогом» — каждый уровень пользуется службами нижнего:

1. Ядро Linux — процессы, память, драйверы устройств, энергопитание; каждое приложение — отдельный Linux-пользователь в своей «песочнице».
2. HAL и нативные библиотеки (C/C++) — доступ к камере, сенсорам, звуку; графика (OpenGL ES/Vulkan), SQLite, WebView.
3. ART (Android Runtime) — среда выполнения: код на Java/Kotlin компилируется в байт-код, ART выполняет его с JIT/AOT-компиляцией; у каждого приложения — свой экземпляр виртуальной машины.
4. Java API Framework — «кирпичи» для приложений: система окон и представлений (View), менеджеры активностей, уведомлений, пакетов, доступ к данным.
5. Приложения — системные и установленные; распространяются пакетами APK.

Компоненты приложения и жизненный цикл

Android-приложение — не одна «программа с main()», а набор компонентов, которые система запускает по необходимости; все они объявляются в манифесте (AndroidManifest.xml) вместе с разрешениями:

• Activity — один экран с интерфейсом; приложение — стопка активностей (навигация назад = снятие со стека);
• Service — длительная работа без интерфейса (музыка, синхронизация в фоне);
• Broadcast Receiver — реакция на широковещательные события (сеть появилась, батарея разряжена);
• Content Provider — предоставление данных другим приложениям через единый интерфейс (контакты, галерея).

Компоненты связываются интентами (Intent) — «намерение» запустить экран или действие, своё или чужое («открыть камеру», «поделиться текстом»).

// явный — конкретный класс своего приложения
startActivity(new Intent(this, SettingsActivity.class));

// неявный — «действие», исполнителя подберёт система
Intent i = new Intent(Intent.ACTION_SEND);
i.setType("text/plain");
i.putExtra(Intent.EXTRA_TEXT, "Привет!");
startActivity(i);                     // диалог «Поделиться»

Жизненный цикл Activity — цепочка обратных вызовов, которыми система сообщает экрану о смене состояния: onCreate (создание, построение интерфейса) → onStart (виден) → onResume (в фокусе, работает) → onPause (перекрыт) → onStop (не виден) → onDestroy (уничтожен). При повороте экрана активность пересоздаётся — поэтому состояние хранят вне её.

Вызовы парные: onCreate↔onDestroy, onStart↔onStop, onResume↔onPause — ресурс, занятый в одном, освобождают в парном. После onStop система вправе убить процесс ради памяти, поэтому важное сохраняют не позже onPause / onSaveInstanceState.

Современная рекомендуемая архитектура (Jetpack): слой интерфейса — разметка/Compose + ViewModel (хранит состояние экрана, переживает пересоздание Activity) — слой данных — Repository, объединяющий локальную БД (Room/SQLite) и сеть. Данные текут к интерфейсу реактивно (LiveData/Flow), длинные списки рисует RecyclerView, переиспользующий ячейки. Схема близка к MVVM: View ↔ ViewModel ↔ Model.

Ресурсы, разметка и файлы проекта

Интерфейс и константы выносятся из кода в ресурсы — каталог res/ проекта:

• res/layout/ — разметка экранов в XML: дерево контейнеров (LinearLayout, ConstraintLayout) и виджетов (TextView, Button, EditText). Активность загружает её в onCreate вызовом setContentView(R.layout.main), элементы находит findViewById(R.id.btn);
• res/values/ — строки (strings.xml), цвета, размеры; локализация — просто второй файл строк в values-en/;
• res/drawable/ — графика; квалификаторы ресурсов автоматически подставляют вариант под плотность экрана, язык и ориентацию.

На все ресурсы среда генерирует класс R с числовыми идентификаторами — обращения к ресурсам проверяются компилятором. Разделение кода и представления — та же идея, что HTML+CSS против «всего в коде».

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);  // res/layout/activity_main.xml

        TextView label = findViewById(R.id.label);
        Button btn    = findViewById(R.id.btn);
        btn.setOnClickListener(v -> label.setText("Нажали!"));
    }
}