Similar presentations:
КТП_Лекция_1_Основы_языка_Java_и_ООП_2026
1.
Основы языка Javaи объектно-ориентированное
программирование
2. План лекции
Пять блоков: от устройства платформы Java до принципов ООПслайды
4–11
1
слайды
12–21
2
слайды
22–29
3
Java как язык
и платформа
Данные и типы
Управляющие конструкции
и массивы
История, WORA, JDK/JRE/JVM,
байт-код, JIT-компиляция
Структура программы, переменные,
восемь примитивов, приведение типов
if, switch, циклы, массивы,
минимум по работе со String
4
слайды
30–36
5
Классы и объекты
Принципы ООП
Поля, методы, конструкторы, доступ,
static, сборка мусора
Абстракция, инкапсуляция,
наследование, полиморфизм
слайды
37–46
2
3. Что мы должны понять сегодня
Восемь вопросов, на которые вы сможете ответить к концу лекции01
Почему Java-программа работает на любой
платформе
02
Чем различаются JDK, JRE и JVM
03
Что происходит с программой от .java до её
выполнения
04
Какие типы данных есть в языке и как они
хранятся в памяти
05
Как записать ветвление, цикл и работу с
массивом
06
Что такое класс, объект, поле, метод и
конструктор
07
Зачем нужны четыре принципа ООП
08
Как наследование и полиморфизм убирают
дублирование кода
3
4. Место Java среди языков программирования
Как исходный текст программы превращается в действия процессораКОМПИЛИРУЕМЫЕ
ИНТЕРПРЕТИРУЕМЫЕ
ГИБРИДНЫЕ
C, C++, Rust
Python, JavaScript, PHP
Java, C#, Kotlin, Scala
Компилятор сразу переводит
Исходный код читает и выполняет
Компилятор переводит код в байт-
исходный код в машинный код
интерпретатор — отдельная
код — промежуточное
конкретного процессора и
программа, свой вариант для
представление, которое исполняет
операционной системы.
каждой платформы.
виртуальная машина.
+ максимальная скорость
− своя сборка под каждую ОС
+ один и тот же текст везде
− заметно медленнее
+ переносимость и скорость
+ оптимизация при выполнении
Java сочетает оба подхода: компиляция один раз — в байт-код, а исполнение — виртуальной машиной,
которая существует для каждой платформы.
4
5. Краткая история Java
От управления бытовой техникой до главной корпоративной платформы1991
1995
2006
2010
2014
2018→
Проект Green
Java 1.0
Открытый
код
Oracle
Java 8
Новый цикл
Sun Microsystems,
команда Джеймса
Гослинга.
Язык Oak для
бытовых
Первый публичный
выпуск
и принцип WORA:
Write Once, Run
Anywhere
Sun открывает
исходный
код языка.
Появляется
проект OpenJDK
Oracle покупает Sun
Microsystems и
продолжает
развитие языка
Лямбда-выражения
и Stream API —
крупнейшее
обновление языка
Выпуск каждые
полгода;
версии с долгой
поддержкой: 11, 17, 21,
25
устройств
Ключ к успеху языка — платформенная независимость: один и тот же откомпилированный код запускается
везде, где есть JVM.
5
6. Принцип WORA
Write Once, Run Anywhere — «Напиши один раз, запускай везде»WORA — программа, написанная на Java, компилируется в байт-код один раз и затем выполняется на любой
платформе, где установлена виртуальная машина Java (JVM), без изменений и повторной компиляции.
ОДИН ИСХОДНЫЙ ТЕКСТ
Program.java
↓ javac
Program.class
Windows
JVM для Windows
✓
Linux
JVM для Linux
✓
macOS
JVM для macOS
✓
байт-код
одинаковый
для всех систем
Переносим не исходный текст, а результат компиляции. Различия операционных систем скрывает виртуальная
машина.
6
7. JDK, JRE и JVM
Три вложенных понятия, которые часто путаютJDK · DEVELOPMENT KIT
JVM
Java Virtual Machine
Виртуальная машина: исполняет байт-код на конкретной
платформе, скрывая различия операционных систем.
JRE · RUNTIME ENVIRONMENT
JRE
JVM · VIRTUAL MACHINE
Исполняет байт-код.
Java Runtime Environment
Среда выполнения: JVM плюс стандартные библиотеки.
Достаточна, чтобы запускать готовые программы.
Загружает классы, проверяет байт-код,
интерпретирует его и включает JIT-компиляцию.
+ стандартные библиотеки Java
JDK
Java Development Kit
Комплект разработчика: JRE плюс компилятор javac, отладчик
и документатор. Нужен, чтобы писать код.
+ компилятор javac, отладчик, javap, javadoc
JDK ⊃ JRE ⊃ JVM. Для учебных работ устанавливают JDK — он включает всё остальное.
7
8. Путь программы: от .java до выполнения
Жизненный цикл программы на языке Java1
2
3
4
5
Исходный код
Компиляция
Байт-код
Загрузка в JVM
Выполнение
Program.java
javac Program.java
Program.class
java Program
интерпретация + JIT
Текст программы,
Компилятор
Платформенно-
ClassLoader загружает
Байт-код
написанный
проверяет
независимые
и проверяет классы
превращается
человеком
синтаксис и типы
инструкции для JVM
в машинный код
Компиляция происходит один раз, а исполнение — каждый раз при запуске. Именно поэтому один и тот же файл
.class работает и в Windows, и в Linux.
Начиная с Java 11 однофайловую программу можно запустить одной командой: java Program.java — компиляция
выполнится в памяти.
8
9. Байт-код (bytecode)
Промежуточный язык, который понимает виртуальная машинаБайт-код — набор компактных инструкций для стековой виртуальной машины. Он не привязан ни к процессору,
ни к операционной системе.
ИСХОДНЫЙ КОД · Sum.java
public class Sum {
public static int add(int a, int b) {
return a + b;
}
}
БАЙТ-КОД · javap -c Sum.class
public static int add(int, int);
Code:
0: iload_0
// взять a
1: iload_1
// взять b
2: iadd
// сложить
3: ireturn
// вернуть
Один файл — один класс
Проверяется перед запуском
Читается человеком
Компилятор создаёт отдельный .class для
каждого класса
Bytecode Verifier не пропустит
некорректный или опасный код
Команда javap -c показывает байт-код в
понятном виде
Байт-код — это «общий язык» платформы: на JVM работают не только Java, но и Kotlin, Scala, Groovy, Clojure.
9
10. JIT-компиляция
Just-In-Time compilation — компиляция во время выполненияJIT-компиляция — механизм, при котором JVM во время работы программы находит часто исполняемые участки
байт-кода и переводит их в машинный код конкретного процессора.
Интерпретатор
Профилировщик
выполняет команду за
считает вызовы участков
командой
кода
Что даёт
Чем платим
• горячий код → машинный код
• растёт расход памяти
Кеш — скомпилированный участок
сохраняется и повторно не компилируется
• оптимизация под процессор
• первые секунды — «прогрев»
Байт-код
.class
JIT-компилятор
→ машинный код
JIT-компиляция позволяет горячим участкам кода приблизиться по производительности к нативному коду.
10
11. Основные особенности языка Java
Восемь свойств, определяющих характер языкаПростой
Объектноориентированный
Надёжный
Безопасный
Simple
Object-Oriented
Robust
Secure
Синтаксис унаследован от C и
Всё, кроме примитивных
Строгая типизация, проверки
Проверка байт-кода и модель
C++, но убраны указатели и
типов, — объекты; принципы
при компиляции, исключения,
«песочницы» ограничивают
ручное управление памятью
ООП встроены в язык
сборка мусора
опасный код
Независимый
от архитектуры
Переносимый
Многопоточный
Высокопроизводительный
Architecture-neutral
Portable
Multithreaded
High performance
Байт-код не привязан к
Принцип WORA: программа
Параллельное выполнение
JIT-компиляция приближает
процессору; размеры типов
выполняется везде, где есть
поддержано самим языком
скорость к компилируемым
везде одинаковы
JVM
языкам
11
12. Структура простейшей Java-программы
Разбираем классическую программу «Hello World» по частямpublic
public class JavaHelloWorldProgram {
модификатор доступа: класс виден отовсюду
class
public static void main(String[] args) {
System.out.println("Hello World");
}
}
ключевое слово: объявляем класс
JavaHelloWorldProgram
имя класса — совпадает с именем файла
main
точка входа: с этого метода начинается работа
Правила, о которых нужно помнить
• В файле может быть несколько классов, но только один public
• Имя файла обязано совпадать с именем public-класса:
JavaHelloWorldProgram.java
System.out.println
вывод строки в консоль с переводом строки
{ }
фигурные скобки задают границы блока
• Java различает регистр: Main и main — разные имена
Любой исполняемый код в Java находится внутри класса — «свободных» функций вне классов в языке нет.
12
13. Метод main. Компиляция и запуск
Точка входа программы и команды, которые превращают текст в результатpublic static void main(String[] args) { ... }
public
static
void
main
String[] args
доступен извне: JVM
принадлежит классу:
ничего не возвращает
имя, которое ищет JVM
массив аргументов
вызывает его из
вызывается без
вызывающей стороне
при запуске
командной строки
другого класса
создания объекта
КАК ЗАПУСТИТЬ ПРОГРАММУ
$ javac JavaHelloWorldProgram.java
$ java JavaHelloWorldProgram
Hello World
программы
Если сигнатура записана иначе
JVM не найдёт точку входа и завершит работу с ошибкой:
NoSuchMethodError: main
Первая команда создаёт файл .class — байт-код. Вторая запускает JVM, которая загружает класс и вызывает main.
13
14. Переменные
Именованная область памяти, хранящая значение определённого типаВ Java переменная всегда объявляется вместе с типом — тип задаётся на этапе компиляции и в дальнейшем не
меняется.
ОБЪЯВЛЕНИЕ И ИНИЦИАЛИЗАЦИЯ
Имя переменной
Буквы, цифры, _ и $; не может начинаться с цифры
int count;
count = 10;
// объявление
// инициализация
double price = 99.90;
final int MAX = 100;
var name = "Иван";
// сразу вместе
// константа
// тип выведет компилятор
Стиль именования
camelCase — переменные, UPPER_CASE — константы
Область видимости
Переменная живёт внутри своего блока { }
Инициализация
Использовать до присваивания значения нельзя
final запрещает повторное присваивание — так в Java объявляют константы. var (с Java 10) не отменяет типизацию:
тип выводится из значения.
14
15. Типы данных в Java: общая картина
Две большие категории, различающиеся способом хранения значенияТипы данных Java
ПРИМИТИВНЫЕ
primitive types
Хранят само значение. Всего восемь, других быть не может.
Целые
byte
short
Вещественные
float
double
Символьный
Логический
ССЫЛОЧНЫЕ
reference types
Хранят ссылку на объект в памяти.
Классы
String, Scanner, свои классы
Интерфейсы
List, Comparable
char
Массивы
int[], String[][]
boolean
Перечисления
enum Season { WINTER, ... }
int
long
void — особый тип: он не описывает значение, а сообщает, что метод ничего не возвращает.
15
16. Восемь примитивных типов
Размер каждого типа одинаков на всех платформахЗначение по умолчанию
для полей и элементов массива
Тип
Размер
Диапазон значений
byte
8 бит
−128 … 127
0
byte b = 100;
short
16 бит
−32 768 … 32 767
0
short s = 5000;
int
32 бита
−2 147 483 648 … 2 147 483 647
0
int i = 42;
long
64 бита
≈ ±9,22 · 10¹⁸
0L
long l = 10000000000L;
float
32 бита
≈ ±3,4 · 10³⁸, 7 значащих цифр
0.0f
float f = 3.14f;
double
64 бита
≈ ±1,8 · 10³⁰⁸, 15–16 цифр
0.0d
double d = 3.14159;
char
16 бит
кодовая единица UTF-16: 0 … 65 535
boolean
1 бит*
только true или false
'\u0000'
false
Пример
char c = 'A';
boolean ok = true;
* Размер boolean не задан спецификацией: JVM обычно отводит
char — 16-битная кодовая единица UTF-16; для большинства
целый байт.
символов это и есть один символ.
16
17. Ссылочные типы. Стек и куча
Упрощённая модель памяти JavaСТЕК · STACK
КУЧА · HEAP
Локальные переменные метода: существуют, пока
метод выполняется.
Все объекты и массивы. Память освобождает сборщик
мусора, а не программист.
int x
10
значение лежит здесь
объект Point
double xCoord = 5.0
double y
2.5
значение лежит здесь
Point p
0x7fa3…
адрес объекта в куче
Переменная примитивного типа хранит значение,
double yCoord = 3.0
int x = 10;
Point p = new Point(5, 3);
// в стеке
// объект — в куче
переменная ссылочного типа — ссылку.
Присваивание Point p2 = p; копирует не объект, а только ссылку: обе переменные будут указывать на один и тот же
объект в куче.
17
18. Неявное (расширяющее) преобразование типов
Widening conversion — выполняется автоматически, без явного приведенияЗначение «меньшего» типа помещается в «больший». Компилятор делает это сам: переполнение при
расширении диапазона невозможно.
byte
short
char → int → long …
int
long
float
double
Тип char расширяется до int и далее — символ превращается в свой Unicode-код.
Переполнения не будет
int a = 10;
long b = a;
// int → long
int g = 42;
double h = g;
// int → double, 42.0
Диапазон целевого типа шире — значение поместится.
Но точность может теряться
int и long → float/double: у float всего ~7 значащих цифр.
Исключение: boolean не преобразуется ни в один другой тип, и ни один тип не преобразуется в него.
18
19. Явное (сужающее) преобразование типов
Narrowing conversion — программист указывает приведение сам и отвечает за результатЗначение «большего» типа помещают в «меньший». Возможна потеря точности или переполнение, поэтому
требуется приведение в скобках: (тип) значение.
Потеря точности
long c = 1000000L;
int d = (int) c;
// long → int
double e = 123.456;
float f = (float) e;
// double → float
float k = 123456789f;
int l = (int) k;
// 123456792
Что происходит при сужении
double i = 9.99;
int j = (int) i;
System.out.println(j);
// дробная часть
// 9 — не 10!
boolean нельзя привести ни к одному типу — и наоборот.
Такая попытка вызовет ошибку компиляции.
• У целых типов отбрасываются старшие биты
• У вещественных отбрасывается дробная часть (не
округляется)
Компилятор не подсказывает, «правильно» ли сужение: он
лишь фиксирует, что решение принял программист.
19
20. Продвижение типов в арифметике
Результат операции получает самый «широкий» из участвующих типов1
2
3
4
Есть double — результат
double
Есть float (но нет double)
— результат float
Есть long (но нет float и
double) — результат long
byte, short и char
сначала преобразуются
в int
double x = 1.5;
int y = 2;
double r = x + y;
// 3.5
float z = 1.25f;
int w = 3;
float r2 = z * w;
// 3.75
long v = 10L;
int n = 3;
long r3 = v * n;
// 30
byte a = 10;
byte b = 20;
int r4 = a + b;
// int
Типичная ошибка: int a = 7, b = 2; → a / b даёт 3, а не 3.5 — оба операнда целые, значит и деление
целочисленное. Чтобы получить 3.5, нужно (double) a / b.
20
21. Операторы Java
Инструменты для вычислений, сравнений и построения условийАРИФМЕТИЧЕСКИЕ
СРАВНЕНИЯ
ЛОГИЧЕСКИЕ
ПРИСВАИВАНИЯ
+
==
&&
=
−
*
/
!=
сложение, вычитание,
умножение, деление
равно, не равно
И: истинно, когда истинны обе
части
присвоить значение
%
<
||
+=
остаток от деления: 7 % 3 → 1
меньше, больше и нестрогие
ИЛИ: истинно, когда истинна
a += 5 равносильно a = a + 5
варианты
хотя бы одна
instanceof
!
&
проверка принадлежности
типу
НЕ: меняет значение на
противоположное
побитовые операции и сдвиги
++
−−
увеличение и уменьшение на
единицу
>
<=
>=
−=
|
*=
^
~
/=
<<
>>
Сокращённое вычисление
Сравнение строк
&& и || не вычисляют правую часть, если результат уже ясен
Для строк == сравнивает ссылки, а не текст. Сравнивать
по левой.
содержимое нужно методом equals().
21
22. Условная конструкция if / else
Программа выбирает, какой блок кода выполнить, по значению логического выраженияif (score >= 90) {
grade = "отлично";
} else if (score >= 75) {
grade = "хорошо";
} else if (score >= 60) {
grade = "удовлетворительно";
} else {
grade = "неудовлетворительно";
}
Как это читается
Условие в скобках обязано иметь тип boolean. Проверки
идут сверху вниз; выполняется первая подошедшая,
остальные пропускаются.
Тернарный оператор
Короткая запись if/else, возвращающая значение:
String r = (n > 0) ? "плюс" : "минус";
Отличие от других языков
Частые ошибки
В Java условие не может быть числом: запись if (1) —
• = вместо == — это присваивание, а не сравнение
ошибка компиляции. Допустимо только логическое
• Пропущенные { } — к if отнесётся только одна строка
выражение.
22
23. Конструкция switch
Выбор одного варианта из многих по значению переменнойКЛАССИЧЕСКАЯ ФОРМА
СТРЕЛОЧНАЯ ФОРМА · С JAVA 14
switch (day) {
case 1: name = "Понедельник"; break;
case 2: name = "Вторник";
break;
case 6:
case 7: name = "Выходной";
break;
default: name = "Неизвестно";
}
String name = switch (day) {
case 1 -> "Понедельник";
case 2 -> "Вторник";
case 6, 7 -> "Выходной";
default -> "Неизвестно";
};
Зачем нужен break
Преимущество стрелочной формы
Без него выполнение «проваливается» в следующий case —
break не нужен, «проваливания» не происходит, и switch может
иногда это удобно, но чаще становится источником ошибок.
возвращать значение как выражение.
Допустимые типы для switch: byte, short, char, int, String и перечисления enum.
23
24. Цикл for и цикл for-each
Повторение действий, когда число шагов известно или нужно обойти весь массивКЛАССИЧЕСКИЙ FOR
FOR-EACH · РАСШИРЕННЫЙ ЦИКЛ
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
// напечатает 0 1 2 3 4
int i = 0
инициализация — один раз перед началом
i < 5
условие — проверяется перед каждым шагом
i++
изменение — выполняется после каждого
шага
int[] marks = {5, 4, 5, 3};
int sum = 0;
for (int m : marks) {
sum += m;
}
// sum = 17
Когда выбирать for-each
Нужно пройти все элементы подряд и не требуется индекс.
Короче и безопаснее: выйти за границу массива невозможно.
Переменная i, объявленная в заголовке цикла, существует только внутри него — после цикла она недоступна.
24
25. Циклы while и do-while
Повторение, когда число шагов заранее неизвестноWHILE · УСЛОВИЕ ПРОВЕРЯЕТСЯ ДО ШАГА
int n = 100;
int steps = 0;
DO-WHILE · УСЛОВИЕ ПРОВЕРЯЕТСЯ ПОСЛЕ ШАГА
int value;
do {
while (n > 1) {
n = n / 2;
steps++;
}
value = readNumber();
} while (value < 0);
Если условие ложно с самого начала, тело цикла не
Тело выполняется минимум один раз — удобно для
выполнится ни разу.
ввода данных с проверкой.
// хотя бы один ввод произойдёт
break — немедленный выход из цикла; continue — переход к следующему шагу без выполнения оставшегося тела. Забытое
изменение переменной в условии даёт бесконечный цикл.
25
26. Массивы: объявление и создание
Пронумерованный набор элементов одного типа фиксированной длиныМассив (array) — ссылочный тип: сам массив всегда находится в куче, а переменная хранит ссылку на него. Длина
задаётся при создании и не меняется.
КАК УСТРОЕН МАССИВ b
int[] a = new int[5];
// 5 нулей
int[] b = {10, 20, 30};
// сразу значения
String[] names = new String[3];
b[0] = 15;
int first = b[0];
int len = b.length;
// запись
// чтение
// длина: 3
15
20
30
индекс 0
индекс 1
индекс 2
b.length = 3
Индексы начинаются с 0 и заканчиваются length - 1.
Обращение за границу даёт ArrayIndexOutOfBoundsException.
Значения по умолчанию при создании через new
0 — для целых типов; 0.0 — для вещественных; false — для boolean; '\u0000' — для char; null — для ссылочных типов,
включая String.
26
27. Работа с массивами
Обход, поиск и многомерные массивыОБХОД ПО ИНДЕКСУ И ПОИСК МАКСИМУМА
ДВУМЕРНЫЙ МАССИВ — «МАССИВ МАССИВОВ»
int[] marks = {4, 5, 3, 5, 2};
int max = marks[0];
int[][] table = new int[3][4];
table[1][2] = 7;
for (int i = 1; i < marks.length; i++) {
if (marks[i] > max) {
max = marks[i];
}
}
// max = 5
for (int i = 0; i < table.length; i++) {
for (int j = 0; j < table[i].length; j++) {
System.out.print(table[i][j] + " ");
}
System.out.println();
}
Полезные методы класса Arrays
Строки массива могут быть разной длины
Arrays.sort(a) — сортировка; Arrays.toString(a) — вывод.
Поэтому во внутреннем цикле пишут table[i].length, а не
общую ширину.
27
28. Промежуточный пример: простые числа до 100
Условия, циклы и собственный метод в одной программеМетод isPrime
public class Primes {
public static void main(String[] args) {
for (int n = 2; n <= 100; n++) {
if (isPrime(n)) {
System.out.print(n + " ");
}
}
}
Отдельный метод с понятным именем делает
главный цикл читаемым
Условие i * i <= n
Достаточно проверить делители до корня из n
— так быстрее
Оператор %
public static boolean isPrime(int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
}
Остаток от деления равен нулю → число делится
нацело
// делится
return false
Досрочный выход: как только делитель найден,
продолжать незачем
Эта задача — первое задание лабораторной работы № 1. Вторая задача — проверка строки на палиндром.
28
29. Минимальная работа со String для ЛР №1
Четыре метода, которых достаточно для проверки строки на палиндромlength()
String s = "level";
Длина строки — количество символов
int len = s.length();
char c = s.charAt(0);
// 5
// 'l'
charAt(index)
String reversed = "";
Символ по индексу; индексы от 0 до length() - 1
for (int i = s.length() - 1; i >= 0; i--) {
reversed += s.charAt(i);
}
equals(other)
boolean palindrome = s.equals(reversed);
Сравнивает содержимое строк — используйте его
// true
для текста
==
l
e
v
e
l
Индексация начинается с нуля
0
1
2
3
4
Индексы: 0 … s.length() - 1
Сравнивает ссылки, а не текст: для строк не
применять
Эти методы понадобятся во второй задаче лабораторной работы № 1 — проверке строки на палиндром.
29
30. Зачем нужно ООП
Задача — управлять сложностью программы, когда её объём растётБЕЗ ООП: НАБОР ПРОЦЕДУР
✕ Данные и работающий с ними код разбросаны по
С ООП: МОДЕЛЬ ПРЕДМЕТНОЙ ОБЛАСТИ
✓
программе
✕
✕
✕
✕
Любая часть программы может испортить любые данные
Изменение структуры данных ломает десятки функций
Похожий код копируется и правится в нескольких местах
Программу тяжело разделить между разработчиками
✓
✓
✓
✓
Данные и методы объединены в одном классе
Внутреннее состояние защищено модификаторами
доступа
Общее поведение выносится в базовый класс
Классы можно менять независимо друг от друга
Программа собирается из понятных «деталей»
ООП — парадигма программирования, в которой программа строится как взаимодействие объектов, объединяющих
данные и поведение.
Java — объектно-ориентированный язык с классовой моделью; при этом в языке существуют примитивные типы и
статические члены.
30
31. Класс и объект
Описание и его воплощение — два разных понятияКласс (class) — описание: какие данные хранит объект
Объект (object) — конкретный экземпляр класса,
и что он умеет делать. Памяти под данные класс не
созданный в памяти оператором new. У каждого
занимает.
объекта свои значения полей.
СОЗДАЁМ ТРИ ОБЪЕКТА ОДНОГО КЛАССА
public class Point2d {
private double xCoord;
private double yCoord;
public Point2d(double x, double y) {
xCoord = x;
yCoord = y;
}
}
Point2d a = new Point2d(0, 0);
Point2d b = new Point2d(5, 3);
Point2d c = new Point2d(-2, 7);
a
b
c
(0, 0)
свои значения
(5, 3)
свои значения
(−2, 7)
свои значения
Аналогия: класс — чертёж детали, объект — деталь по этому чертежу. Чертёж один, деталей сколько угодно.
31
32. Поля и методы
Из чего состоит классПоле (field)
public class Student {
private String name;
private int course;
Переменная класса: хранит состояние объекта. Без
// поле
// поле
явного значения получает значение по умолчанию.
Метод (method)
public String getName() {
return name;
}
// метод-геттер
public void promote() {
if (course < 4) {
course++;
}
}
// метод-действие
Поведение объекта: тип результата, имя и список
параметров.
Сигнатура метода
}
Имя и типы параметров. По ней компилятор различает
перегруженные методы.
Ключевое слово this
Ссылка на текущий объект. Нужна, когда параметр
назван так же, как поле.
static перед полем или методом означает, что он принадлежит классу, а не объекту: обращение идёт по имени класса
— Math.PI, Integer.parseInt(s).
32
33. Конструкторы
Специальный метод, который готовит объект к работеКонструктор — метод, имя которого совпадает с именем класса и который не имеет типа возвращаемого значения.
Вызывается оператором new.
Имя и отсутствие типа
public class Point2d {
private double xCoord;
private double yCoord;
Совпадает с именем класса; не пишется даже void
Конструктор по умолчанию
public Point2d(double x, double y) {
xCoord = x;
yCoord = y;
}
public Point2d() {
this(0, 0);
}
// с параметрами
// по умолчанию
// вызов другого конструктора
}
Point2d p1 = new Point2d(); → точка (0, 0);
Если своих конструкторов нет, компилятор создаст пустой
сам
Перегрузка
Конструкторов может быть несколько — с разными
списками параметров
this(...)
Вызов другого конструктора того же класса; должен быть
первой строкой
Point2d p2 = new Point2d(5, 3); → точка (5, 3)
33
34. Модификаторы доступа
Кто имеет право обращаться к полю, методу или классуМодификатор
Свой класс
Пакет
Наследник
в другом пакете
Любой
класс
Как выбирать
public
public
✓
✓
✓
✓
protected
✓
✓
✓
✕
protected
(без модификатора)
✓
✓
✕
✕
по умолчанию
private
✓
✕
✕
✕
private
интерфейс класса для внешнего мира
то, что нужно наследникам
внутренняя кухня одного пакета
всё остальное — выбор по умолчанию
Пакет (package)
Каталог с группой связанных классов. Именно границей пакета определяются
два средних уровня доступа.
Правило по умолчанию: поля делают private, а доступ к ним
открывают методами.
public class Account {
private double balance;
public double getBalance() {
return balance;
}
}
34
35. Статическая переменная: счётчик объектов
Считаем созданные объекты: поле static принадлежит классу, а не отдельному объектуСОЗДАЁМ ДВА ОБЪЕКТА
public class Student {
private static int count = 0;
private String name;
public Student(String name) {
this.name = name;
count++;
}
// одно на весь класс
// своё у каждого объекта
new Student("Анна");
new Student("Иван");
System.out.println(Student.getCount());
// 2
// считаем создание
Обычное поле
public static int getCount() {
return count;
}
Своё у каждого объекта: у Анны и Ивана разные name
static-поле
}
Одно на весь класс: count общий для всех объектов
объект #1
объект #2
класс Student
name = "Анна"
name = "Иван"
count = 2
Вызов
Обращение по имени класса: Student.getCount()
Счётчик созданных объектов — обязательный элемент лабораторной работы № 2 по методическим указаниям.
35
36. Сборка мусора (garbage collection)
Java освобождает память автоматически — вручную объекты не удаляютСборщик мусора — часть JVM, которая находит в куче объекты, на которые больше не ведёт ни одна ссылка, и
освобождает занятую ими память.
1
Объект создан
2
Ссылка потеряна
3
Объект недостижим
4
Память
освобождена
new помещает объект в кучу,
переменной присвоили null
ни от одной «живой»
сборщик мусора удаляет
переменная хранит ссылку
или она вышла из области
переменной
объект,
видимости
до объекта не добраться
когда сочтёт нужным
Point2d p = new Point2d(5, 3);
p = null;
// объект стал недостижим
// память освободится позже
Что это значит для программиста
• Не нужно вручную освобождать память: нет delete и free
• Утечка возможна, если хранить ненужные ссылки на объекты
• Момент сборки не гарантирован — полагаться на него нельзя
Программисту не нужно вручную освобождать память через delete/free. Однако утечки памяти возможны, если
программа продолжает хранить ненужные ссылки на объекты.
36
37. Четыре принципа ООП
Основа, на которой строится объектная модель Java1
2
3
4
Абстракция
Инкапсуляция
Наследование
Полиморфизм
Abstraction
Encapsulation
Inheritance
Polymorphism
Выделяем существенные
Объединяем данные и
Создаём новый класс на
Один и тот же вызов
характеристики объекта и
методы в одном классе и
основе существующего,
приводит к разному
скрываем несущественные
закрываем прямой доступ к
переиспользуя его поля и
поведению в зависимости от
детали
данным
методы
типа объекта
Что объект делает — важно.
Состояние меняется только
Общее — в родителе,
Один интерфейс —
Как именно — нет.
через методы класса.
особенное — в наследнике.
много реализаций.
Дальше разберём каждый принцип отдельно — с определением, примером кода и объяснением, зачем он нужен.
37
38. Абстракция (abstraction)
Выделяем главное и отбрасываем детали, несущественные для задачиАбстракция — выделение наиболее значимых характеристик объекта с сокрытием деталей реализации. Модель
описывает объект настолько подробно, насколько это нужно решаемой задаче.
ОДИН И ТОТ ЖЕ СТУДЕНТ В РАЗНЫХ СИСТЕМАХ
Учебный отдел
ФИО, группа, курс, оценки
Библиотека
ФИО, номер билета, выданные книги
Поликлиника
ФИО, дата рождения, полис, диагнозы
АБСТРАКЦИЯ В КОДЕ: ОБЩИЙ ШАБЛОН ПОВЕДЕНИЯ
abstract class Shape {
abstract double area();
}
// что делает
// как — решит наследник
class Circle extends Shape {
private double radius;
@Override
double area() {
return Math.PI * radius * radius;
}
}
Пользователю класса Shape достаточно знать, что у фигуры есть площадь. Формула — деталь реализации.
38
39. Инкапсуляция (encapsulation)
Скрываем внутреннее устройство объекта и открываем только проверенные операцииpublic class Account {
private double balance;
Инкапсуляция — сокрытие внутренней
// скрытые данные
public void deposit(double amount) {
if (amount > 0) balance += amount;
}
через методы класса.
// проверка!
public void withdraw(double amount) {
if (balance >= amount && amount > 0) {
balance -= amount;
} else {
System.out.println("Недостаточно средств.");
}
}
public double getBalance() { return balance; }
}
реализации объекта и доступ к данным только
private double balance
Поле недоступно снаружи: испортить баланс
напрямую нельзя
deposit / withdraw
Единственные способы изменить баланс — и оба
проверяют аргумент
getBalance()
Чтение без права записи: наружу отдаём копию
значения
Инкапсуляция защищает не от «хакера», а от ошибки: объект невозможно перевести в некорректное состояние в обход
его же методов.
39
40. Наследование (inheritance)
Новый класс получает поля и методы существующего и добавляет своёclass Animal {
protected String name;
Animal
public void eat() {
System.out.println(name + " ест.");
}
Dog
Cat
}
class Dog extends Animal {
// наследуем
public void bark() {
// добавляем своё
System.out.println(name + " лает.");
}
}
extends
Ключевое слово, задающее
родительский класс
Один родитель
Множественное наследование классов
запрещено
protected
Поле доступно наследникам, но
закрыто для посторонних классов
super
Обращение к полям, методам и
конструктору родителя
Конструкторы
Не наследуются; вызов super(...) —
первой строкой
dog.eat() вызывает метод родителя, dog.bark() — собственный
метод класса Dog.
40
41. Полиморфизм: перегрузка методов
Статический полиморфизм — нужный метод выбирает компиляторПолиморфизм — способность объектов разных типов по-разному отвечать на одно и то же обращение. Бывает
статическим (перегрузка) и динамическим (переопределение).
class Calculator {
public int add(int a, int b) {
return a + b;
}
public double add(double a, double b) {
return a + b;
}
Что такое перегрузка
Несколько методов с одним именем и разными
списками параметров в одном классе.
Когда принимается решение
На этапе компиляции — по типам аргументов в
}
месте вызова. Отсюда название «статический».
Calculator calc = new Calculator();
calc.add(5, 7);
// 12
— метод с int
calc.add(5.5, 7.5); // 13.0 — метод с double
Различать методы только по типу возвращаемого
значения нельзя — это ошибка компиляции.
41
42. Переопределение методов
Динамический полиморфизм — метод выбирается во время выполненияclass Animal {
public void makeSound() {
System.out.println("Животное издаёт звук.");
}
}
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Мяу!");
}
}
Переопределение (override) — наследник
заменяет реализацию метода родителя, сохраняя
его имя и список параметров.
Ключевой момент
Тип переменной — Animal, но вызовется метод
класса Cat. Решение принимает JVM во время
выполнения — по фактическому типу объекта.
@Override — аннотация: компилятор проверит, что
Animal animal = new Cat();
animal.makeSound();
// Мяу!
Перегрузка — разные параметры, выбор при компиляции.
метод действительно переопределяет родительский.
super.makeSound() вызовет версию родителя.
Переопределение — те же параметры, выбор при выполнении.
42
43. Абстрактные классы
Общий шаблон поведения, который сам по себе не может существоватьabstract class Shape {
abstract double area();
}
Абстрактный класс — класс, от которого
// без тела
class Circle extends Shape {
private double radius;
public Circle(double radius) { this.radius = radius; }
@Override
double area() { return Math.PI * radius * radius; }
}
нельзя создать объект. Он задаёт общую часть
для наследников.
abstract метод
Объявлен без тела — наследник обязан его реализовать
Обычные методы и поля
Абстрактный класс может содержать и готовый код
class Rectangle extends Shape {
private double width, height;
public Rectangle(double w, double h) { width = w; height = h; }
@Override
double area() { return width * height; }
}
new Shape() — ошибка
Создать экземпляр абстрактного класса нельзя
Shape s = new Circle(5); → s.area() = 78.54
43
44. Интерфейсы
Контракт: что класс обязан уметь делатьinterface InterfaceA {
void methodA();
}
Интерфейс — набор объявлений методов без
// только объявление
interface InterfaceB {
void methodB();
}
class MyClass implements InterfaceA, InterfaceB {
@Override
public void methodA() { System.out.println("Метод А"); }
@Override
public void methodB() { System.out.println("Метод В"); }
}
Замена множественному наследованию
реализации. Может содержать константы и
методы по умолчанию (default).
ПРОБЛЕМА РОМБА
class A { void m() { ... } }
class B extends A { void m() { ... } }
class C extends A { void m() { ... } }
// class D extends B, C
— запрещено!
Если бы D наследовал и B, и C, было бы неясно, чей метод
m() вызывать. Java запрещает такую ситуацию.
Класс расширяет только один класс, но может реализовать сколько
угодно интерфейсов — и получить требуемый набор возможностей.
44
45. Вложенные классы
Класс, объявленный внутри другого классаСтатический
вложенный
Внутренний
Локальный
Анонимный
static nested
inner
local
anonymous
Объявлен с ключевым словом
Нестатический. Связан с
Объявлен внутри метода.
Класс без имени, создаваемый
static. Не имеет доступа к
конкретным объектом
Виден только в этом методе.
прямо в выражении — чаще
полям экземпляра внешнего
внешнего класса и видит все
всего для реализации
класса.
его поля.
интерфейса.
Outer.Inner x =
new Outer.Inner();
Outer o = new Outer();
Outer.Inner x =
o.new Inner();
void run() {
class Helper { }
}
var r = new Runnable() {
public void run() { }
};
Зачем это нужно: вложенный класс объявляют, когда он имеет смысл только внутри внешнего класса. Это повышает
связность кода и позволяет скрыть вспомогательный тип от остальной программы.
45
46. Итоговый пример: всё вместе
Абстракция, инкапсуляция, наследование и полиморфизм в одной программеabstract class Employee {
// абстракция
private final String name;
// инкапсуляция
public Employee(String name) { this.name = name; }
public String getName() { return name; }
abstract double salary();
// контракт
}
class Lecturer extends Employee {
// наследование
private final int hours;
public Lecturer(String n, int h) { super(n); hours = h; }
@Override
double salary() { return hours * 1200; }
// полиморфизм
}
class Engineer extends Employee {
private final double rate;
public Engineer(String n, double r) { super(n); rate = r; }
@Override
double salary() { return rate; }
}
Employee[] staff = {
new Lecturer("Иванов", 120),
new Engineer("Петров", 90000)
};
for (Employee e : staff) {
System.out.println(
e.getName() + ": " + e.salary());
}
Новая должность — это один новый класс.
Абстракция
Employee задаёт наличие зарплаты,
но не способ расчёта
Инкапсуляция
Поля private final задаются один раз в
конструкторе
Наследование
Общая часть — в Employee, различия
— в наследниках
Полиморфизм
Один вызов e.salary() — разный
результат
46
47. Основные выводы
Что нужно унести с этой лекции01
03
05
Java — гибридный язык
02
JDK ⊃ JRE ⊃ JVM
Компиляция в байт-код плюс исполнение виртуальной
JVM исполняет байт-код, JRE добавляет библиотеки, JDK —
машиной. Отсюда переносимость (WORA) и приемлемая
скорость благодаря JIT.
инструменты разработчика. Для работы нужен JDK.
Восемь примитивных типов
04
Расширение — само, сужение — вручную
Переменная хранит само значение. Всё остальное —
Неявное преобразование безопасно, явное требует скобок и
ссылочные типы: переменная хранит ссылку, объект
создаётся в куче.
может привести к потере точности.
Класс описывает, объект существует
Класс — чертёж с полями и методами; объект создаётся
оператором new, память освобождает сборщик мусора.
06
Четыре принципа ООП
Абстракция выделяет главное, инкапсуляция защищает
данные, наследование убирает дублирование, полиморфизм
даёт единый интерфейс.
Дальше в курсе: класс Object, исключения, строки, коллекции, многопоточность, Stream API, Maven и Gradle, Spring.
ЛР № 1: простые числа и проверка строки на палиндром.
ЛР № 2: иерархия классов, четыре принципа ООП, конструкторы, геттеры и сеттеры, static-счётчик объектов.
47
programming