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

Тема 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).

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

В большинстве ООП-языков (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() выполняет разный код в зависимости от фактического класса объекта.

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

Механизм: для класса с виртуальными методами компилятор строит таблицу виртуальных методов (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()

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()                # цикл обработки событий

Тема 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.

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

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

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

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

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

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 при клике; события всплывают от элемента к корню, обработчик получает объект события.

Тема 5.4

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

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

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

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

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

• 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);
?>

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

Тема 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) — «намерение» запустить экран или действие, своё или чужое («открыть камеру», «поделиться текстом»).

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

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