885 lines
109 KiB
TeX
885 lines
109 KiB
TeX
\documentclass[../j-spec.tex]{subfiles}
|
||
|
||
\begin{document}
|
||
\section{Специализация: ООП}
|
||
\begin{longtable}{|p{35mm}|p{135mm}|}
|
||
\hline
|
||
Экран & Слова \\ \hline
|
||
\endhead
|
||
|
||
Титул & Перейдём к интересному: что можно хранить в джаве, как оно там хранится, и как этим манипулировать \\ \hline
|
||
|
||
На прошлом уроке & На прошлом уроке мы рассмотрели базовый функционал языка, то есть основную встроенную функциональность, такую как математические операторы, условия, циклы, бинарные операторы. Также разобрали способы хранения и представления данных в Java, и в конце поговорили о способах манипуляции данными, то есть о функциях (в терминах языка называющиеся методами) \\ \hline
|
||
|
||
На этой лекции: классы и объекты; управление памятью; инкапсуляция; наследование; полиморфизм. & После разбора типов данных попробуем с помощью примеров разобраться в таких основополагающих в джава вещах, как классы и объекты, а также с тем, как применять на практике основные принципы ООП: наследование, полиморфизм и инкапсуляцию. Дополнительно поговорим об устройстве памяти в джава. \\ \hline
|
||
|
||
Класс & Начнём с базового, фундаментального понятия класс.\\ \hline
|
||
|
||
Чертёж (набросок рисунка) кота & Что такое класс? С точки зрения ООП, класс определяет форму и сущность объекта и является логической конструкцией, на основе которой построен весь язык Java. Наиболее важная особенность класса состоит в том, что он определяет новый тип данных, которым можно воспользоваться для создания объектов этого типа, т.е. класс — это шаблон (чертёж), по которому создаются объекты (экземпляры класса). Для определения формы и сущности класса указываются данные, которые он должен содержать, а также код, воздействующий на эти данные.\\ \hline
|
||
|
||
Котик и стопки документов & Если мы хотим работать в нашем приложении с документами, то необходимо для начала объяснить приложению, что такое документ, описать его в виде класса (чертежа) Document. Рассказать какие у него должны быть свойства: название, содержание, количество страниц, информация о том, кем он подписан и т.д. В этом же классе мы описываем что можно делать с документами: печатать в консоль, подписывать, изменять содержание, название и т.д. Результатом такого описания и будет класс Document. Однако это по-прежнему всего лишь чертеж.\\ \hline
|
||
|
||
Буквы, написанные по трафарету чтобы было видно сам трафарет. документы, одинаковые по структуре и разные по содержанию. & Если нам нужны конкретные документы, а нам они обязательно нужны, то необходимо создавать объекты: документ №1, документ №2, документ №3. Все эти документы будут иметь одну и ту же структуру (название, содержание, ...), с ними можно выполнять одни и те же действия (печатать, подписать, ...) НО наполнение будет разным (например, в первом документе содержится приказ о назначении работника на должность, во втором, о выдаче премии отделу разработки и т.д.). \\ \hline
|
||
|
||
03-Структура & Начнём с малого, напишем свой первый класс. Представим, что нам необходимо работать в нашем приложении с котами. Java ничего не знает о том, что такое коты, поэтому нам необходимо создать новый класс (тип данных), и объяснить что же такое кот. Создадим проект, его структура нам не в новизну, и будет иметь вид как на слайде, в мейне пока что простой хелловорлд, а вот с новым файлом кота пойдём разбираться, Создадим его для простоты в том же пакете, что и мейн \\ \hline
|
||
|
||
лайвкод 03-кот & Начнем описывать класс Cat. как мы все прекрасно помним, имя класса должно совпадать с именем файла, в котором он объявлен, т.е. класс Cat должен находиться в файле Cat.java. Пусть у котов есть три свойства: name (кличка), color (цвет) и age (возраст); и они пока ничего не умеют делать. Класс Cat будет иметь следующий вид. (String name; String color; int age;)\\ \hline
|
||
|
||
03-экземпляр-кота & Мы рассказали Java что такое коты, теперь если мы хотим создать в нашем приложении конкретного кота, а я напомню, что в 90\% случаев мы сильно хотим создавать те или иные экземпляры, следует воспользоваться оператором new Cat(); в основном классе программы. Более подробно разберём, что происходит в этой строке, чуть позже. Пока же нам достаточно знать, что мы создали объект типа Cat (экземпляр класса Cat), и запомнить эту конструкцию. Для того чтобы с ним (экземпляром) работать, можем положить его в переменную, которой дать идентификатор cat1. \\ \hline
|
||
|
||
лайвкод 03-разные-коты & Припоминаем разницу между объявлением, присваиванием и инициализацией, становится понятно, что тут произошло и как ещё можно создавать котов. Припоминаем также, что в переменной не лежит сам объект, а только ссылка на него, подробнее, как и обещал, позже. Объект cat1 создан по чертежу Cat, и значит у него есть поля name, color, age, с которыми можно работать (получать или изменять их значения). Для доступа к полям объекта служит оператор точка, которая связывает имя объекта с именем поля. Например, чтобы присвоить полю color объекта cat1 значение "Белый", нужно выполнить следующий код: cat1.color = "Белый"; Прошу, не запутайтесь, класс кота мы описали в отдельном файле, а создавать объекты и совершать манипуляции следует в мейне, не может же кот сам себе имя назначить \\ \hline
|
||
|
||
лайвкод 03-два-кота & Операция-точка служит для доступа к полям и методам объекта по его имени. Рассмотрим пример консольного приложения, работающего с объектами класса Cat. создадим двух котов, один будет белым барсиком 4х лет, второй чёрным мурзиком шести лет, и просто выведем информацию о них в терминал \\ \hline
|
||
|
||
03-класс-объекты1 & Вначале мы создали два объекта типа Cat: cat1 и cat2, соответственно они имеют одинаковый набор полей name, color, age, почему? потому что они принадлежат одному классу, созданы по одному шаблону. Однако каждому из них мы в эти поля записали разные значения. Как видно из результата печати в консоли, изменение значения полей одного объекта, никак не влияет на значения полей другого объекта. Данные объектов cat1 и cat2 изолированы друг от друга. А значит мы делаем вывод о том, поля хранятся в классе, а значения полей хранятся в объектах. \\ \hline
|
||
|
||
Объекты & Как создавать новые типы данных (классы) мы разобрались, мельком посмотрели и как создаются объекты наших классов \\ \hline
|
||
|
||
Cat cat1;
|
||
cat1 = new Cat(); & Подробнее разберем как создавать объекты, и что при этом происходит. Создание объекта как любого ссылочного типа данных проходит в два этапа. Мы это помним из рассказа о массивах. Сначала создается переменная, имеющая интересующий нас тип, в нее мы можем записать ссылку на объект. Затем необходимо выделить память под наш объект, создать и положить объект в выделенную часть памяти, и сохранить ссылку на этот объект в памяти в нашу переменную. Для непосредственного создания объекта применяется оператор new, который динамически резервирует память под объект и возвращает ссылку на него, в общих чертах эта ссылка представляет собой адрес объекта в памяти, зарезервированной оператором new. \\ \hline
|
||
|
||
03-разные-коты & В первой строке кода переменная cat1 объявляется как ссылка на объект типа Cat и пока ещё не ссылается на конкретный объект (первоначально значение переменной cat1 равно null). В следующей строке выделяется память для объекта типа Cat, и в переменную cat1 сохраняется ссылка на него. После выполнения второй строки кода переменную cat1 можно использовать так, как если бы она была объектом типа Cat. Обычно новый объект создается в одну строку (Cat cat1 = new Cat()). \\ \hline
|
||
|
||
Оператор new
|
||
|
||
[квалификаторы] ИмяКласса имяПеременной = new ИмяКласса();
|
||
& Раз уж начали про объекты - нельзя не сказать про оператор new. Оператор new динамически выделяет память для нового объекта, общая форма применения этого оператора имеет вид как на слайде, но на самом деле справа - не имя класса, как могло показаться на первый взгляд ИмяКласса() в правой части выполняет вызов конструктора данного класса, который подготавливает вновь создаваемый объект к работе. \\ \hline
|
||
|
||
лайвкод 03-один-кот & Именно от оператора нью будет зависеть, сколько именно объектов будет создано в программе. На первый взгляд может показаться, что переменной cat2 присваивается ссылка на копию объекта cat1, т.е. переменные cat1 и cat2 будут ссылаться на разные объекты в памяти. Но это не так. На самом деле cat1 и cat2 будут ссылаться на один и тот же объект. Присваивание переменной cat1 значения переменной cat2 не привело к выделению области памяти или копированию объекта, лишь к тому, что переменная cat2 содержит ссылку на тот же объект, что и переменная cat1.\\ \hline
|
||
|
||
03-один-кот-2 & Таким образом, любые изменения, внесённые в объекте по ссылке cat2, окажут влияние на объект, на который ссылается переменная cat1, поскольку это один и тот же объект в памяти, как и в примере на слайде, где мы как будто бы указали возраст второго кота 6 лет, а при выводе, возраст 6 лет оказался и у первого кота.
|
||
\\ \hline
|
||
|
||
Метод - это функция, принадлежащая классу & Ранее мы уже говорили о том, что в языке Java любая программа состоит из классов и функций, которые могут описываться только внутри них. Именно поэтому все функции в языке Java являются методами. А метод, как мы помним, это - функция, являющаяся частью некоторого класса, которая может выполнять операции над данными этого класса. \\ \hline
|
||
|
||
03-нестатик & Метод для своей работы может использовать поля объекта и/или класса, в котором определен, напрямую, без необходимости передавать их во входных параметрах. Это похоже на использование глобальных переменных в функциях, но в отличие от глобальных переменных, метод может получать прямой доступ только к членам класса. Самые простые методы работают с данными объектов.\\ \hline
|
||
|
||
Лайвкод 03-метод & Вернёмся к примеру с котиками. Все мы знаем, что котики умеют урчать, мяукать и смешно прыгать. В целях демонстрации мы в описании этих действий просто будем делать разные выводы в консоль, хотя мы и можем научить нашего котика выбирать минимальное значение из массива, но это было бы неожиданно. Итак опишем метод например подать голос и прыгать. \\ \hline
|
||
|
||
Лайвкод 03-метод-вызов & Обращение к методам выглядит очень похожим на стандартный способом, через точку, как к полям. Теперь когда мы хотим позвать нашего котика, он нам скажет, мяу, я имя котика, а если мы решили что котику надо прыгать, он решит, прилично-ли это - прыгать в его возрасте. Как видно, барсик замечательно прыгает, а мурзик от прыжков воздержался, хотя попрыгать мы попросили их обоих \\ \hline
|
||
|
||
шрифтом курьер слово static
|
||
|
||
викисловарь - статика этимология & Теперь, когда мы более-менее хорошо знаем, что такое класс и объект, хотелось бы остановиться на специальном модификаторе - static, делающем переменную или метод "независимыми" от объекта. Если формально, то: Static — модификатор, применяемый к полю, блоку, методу или внутреннему классу, он указывает на привязку субъекта к текущему классу. Для использования таких полей и методов, соответственно, объект создавать не нужно. В Java большинство членов служебных классов являются статическими.\\ \hline
|
||
|
||
\begin{itemize}
|
||
\item статические методы;
|
||
\item статические переменные;
|
||
\item статические вложенные классы;
|
||
\item статические блоки.
|
||
\end{itemize} &
|
||
Мы можем использовать это ключевое слово в четырех контекстах:
|
||
|
||
статические методы;
|
||
статические переменные;
|
||
статические вложенные классы;
|
||
статические блоки.
|
||
|
||
Рассмотрим подробнее только первые два пункта, о третьем поговорим чуть позже, а четвёртый потребует от нас знаний, выходящих не только за этот урок, но и за десяток следующих. \\ \hline
|
||
|
||
Статические методы - методы класса & Статические методы также называются методами класса, потому что статический метод принадлежит классу, а не его объекту. Что логично, нестатические называются методами объекта. Статические методы обладают интересным свойством - их можно вызывать напрямую через имя класса, не обращаясь к объекту и вообще объект не создавая. Что это и зачем нужно? Например, умение кота мяукать можно вывести в статическое поле, потому что, например, мы весной можем открыть окно, не увидеть ни одного экземпляра котов, но зато услышать их, и точно знать, что мяукают не дома и не машины, а коты \\ \hline
|
||
|
||
03-статические-поля & Аналогично статическим методам, статические поля принадлежат классу и совершенно ничего не знают об объектах. Важной отличительной чертой статических полей является то, что их значения также хранятся в классе, в отличие от обычных полей, чьи значения хранятся в объектах. На слайде довольно понятно это показано. Изображение на слайде именно в этом виде я настоятельно рекомендую если не заучить, то хотя бы хорошо запомнить, оно нам ещё пригодится. Из этой же картинки можно сделать несколько выводов, о которых сейчас поговорим \\ \hline
|
||
|
||
лайвкод 03-статическое-поле-код & Помимо того, что статические поля - это полезный инструмент создания общих свойств это ещ§ и опасный инструмент создания общих свойств. Так, например, мы знаем, что у котов четыре лапы, а не 6 и не 8. Не создавая никакого барсика будет понятно, что у кота - 4 лапы. Это полезное поведение \\ \hline
|
||
|
||
лайвкод 03-статическое-поле-ошибка & Посмотрим на опасность. Мы видим, что у каждого кота есть имя, и помним, что коты хранят значение своего имени каждый сам у себя. А знают экземпляры о названии поля потому что знают, какого класса они экземпляры. Но что если мы по невнимательности добавим свойство статичности к имени кота? \\ \hline
|
||
|
||
03-статическое-поле-признак & Создав тех же самых котов, которых мы создавали весь урок, мы получим двух мурзиков и ни одного барсика. Почему это произошло? По факту переменная у нас одна на всех, и значение тоже одно, а значит каждый раз мы меняем именно его, а все остальные коты ничего не подозревая смотрят на значение общей переменной и бодро его возвращают. Поэтому, чтобы не запутаться, к статическим переменным, как правило, обращаются не по ссылке на объект — cat1.name, а по имени класса — Cat.name. \\ \hline
|
||
|
||
03-статические-поля & К слову, статические переменные — редкость в Java. Вместо них применяют статические константы. Они определяются ключевыми словами static final и по соглашению о внешнем виде кода пишутся в верхнем регистре. \\ \hline
|
||
|
||
Введение в управление памятью & Понимая поверхностно, как организовано создание и хранение объектов, можем углубиться в эту тему. Это факультативная часть, выходящая достаточно далеко за рамки джуниор позиции. \\ \hline
|
||
|
||
03-память & Это глубокое погружение в управление памятью Java позволит расширить ваши знания о том, как работает куча, ссылочные типы и сборка мусора. Поможет лучше понять глубинные процессы и, как следствие, писать более хорошие программы. Для оптимальной работы приложения JVM делит память на область стека (stack) и область кучи (heap). Всякий раз, когда мы объявляем новые переменные, создаем объекты или вызываем новый метод, JVM выделяет память для этих операций в стеке или в куче. Далее будет представлена модель организации памяти в Java. Чуть позже мы её рассмотрим подробнее, а начнем со стека. \\ \hline
|
||
|
||
стопка блинов LIFO (Last-In, First-Out. Последний-зашел, Первый-вышел) & Стековая память отвечает за хранение ссылок на объекты кучи и за хранение типов значений (также известных в Java как примитивные типы), которые содержат само значение, а не ссылку на объект из кучи. Данная память в Java работает по схеме LIFO (Последний-зашел-Первый-вышел).\\ \hline
|
||
|
||
НУЖЕН РЕКВИЗИТ ТРИ ТАРЕЛКИ С ПЕЧЕНЬЯМИ ИЛИ КОНФЕТАМИ & Кроме того, переменные в стеке имеют определенную область видимости. Программой используются только объекты из активной области. Например, если ЖВМ выполняет тело метода, она помещает весь используемый в методе контекст на стек и может получить доступ только к объектам из стека, которые находятся внутри тела метода. Она не может получить доступ к другим локальным переменным, так как они не выходят в область видимости. Когда метод завершается и возвращается результат его работы, верхняя часть стека выталкивается, и активная область видимости изменяется. \\ \hline
|
||
|
||
03-многопоточность & Немного забегая вперёд можно сказать, что все потоки, работающие в JVM, имеют свой стек. Для нас пока достаточно отождествлять поток и собственно исполнение нашей программы. Стек в свою очередь держит информацию о том, какие методы вызвал поток. Я буду называть это «стеком вызовов». Стек вызовов возобновляется, как только поток завершает выполнение своего кода. каждый слой стека вызовов содержит все локальные переменные для вызываемого метода и потока. Все локальные переменные примитивных типов полностью хранятся в стеке потоков и не видны другим потокам \\ \hline
|
||
|
||
на слайд перечисление справа
|
||
& Особенности стека:
|
||
\begin{itemize}
|
||
\item Он заполняется и освобождается по мере вызова и завершения новых методов;
|
||
\item Переменные на стеке существуют до тех пор, пока выполняется метод в котором они были созданы;
|
||
\item Если память стека будет заполнена, Java бросит исключение java.lang.StackOverflowError;
|
||
\item Доступ к этой области памяти осуществляется быстрее, чем к куче;
|
||
\item Является потокобезопасным, поскольку для каждого потока создается свой отдельный стек.
|
||
\end{itemize}\\ \hline
|
||
|
||
03-устройство памяти & Куча содержит все объекты, созданные в вашем приложении, независимо от того, какой поток создал объект. Неважно, был ли объект создан и присвоен локальной переменной или создан как переменная-член другого объекта, он хранится в куче. со всеми своими примитивными и не примитивными данными внутри. В случае, когда локальная переменная примитивного типа, она хранится на стеке потока.\\ \hline
|
||
|
||
03-началось & Локальная переменная также может быть ссылкой на объект. В этом случае ссылка (локальная переменная) хранится на стеке, но сам объект хранится в куче. Объект использует методы, эти методы содержат локальные переменные. Эти локальные переменные также хранятся на стеке, несмотря на то, что объект, который использует метод, хранится в куче. Переменные-члены класса хранятся в куче вместе с самим классом. Это верно как в случае, когда переменная-член имеет примитивный тип, так и в том случае, если она является ссылкой на объект. Статические переменные класса также хранятся в куче вместе с определением класса.
|
||
В общем случае, эти объекты имеют глобальный доступ и могут быть получены из любого места программы. \\ \hline
|
||
|
||
\begin{itemize}
|
||
\item Young generation
|
||
\item Old (Tenured) Generation
|
||
\item Permanent Generation
|
||
\end{itemize} & Куча разбита на несколько более мелких частей, называемых поколениями:
|
||
Young Generation — область где размещаются недавно созданные объекты. Когда она заполняется, происходит быстрая сборка мусора;
|
||
Old (Tenured) Generation — здесь хранятся долгоживущие объекты. Когда объекты из Young Generation достигают определенного порога «возраста», они перемещаются в Old Generation;
|
||
Permanent Generation — эта область содержит метаинформацию о классах и методах приложения, но начиная с Java 8 данная область памяти была упразднена. В Java 8 PermGen заменён на Metaspace - его динамически изменяемый по размеру аналог. Важно упоминуть, что именно здесь живут статические поля. \\ \hline
|
||
|
||
Особенности кучи: список из правой части &
|
||
\begin{itemize}
|
||
\item В общем случае, размеры кучи на порядок больше размеров стека
|
||
\item Когда эта область памяти полностью заполняется, Java бросает java.lang.OutOfMemoryError;
|
||
\item Доступ к ней медленнее, чем к стеку;
|
||
\item Эта память, в отличие от стека, автоматически не освобождается. Для сбора неиспользуемых объектов используется сборщик мусора;
|
||
\item В отличие от стека, куча не является потокобезопасной и ее необходимо контролировать, правильно синхронизируя код.
|
||
\end{itemize} \\ \hline
|
||
|
||
Сборщик мусора & Вроде разобрались, разделили память так, как её разделяет ЖВМ. Предлагаю взглянуть на то, как ЖВМ осуществляет управление неиспользуемыми объектами \\ \hline
|
||
|
||
список справа & Но, прежде чем углубиться в детали, давайте сначала упомянем несколько вещей:
|
||
\begin{itemize}
|
||
\item Этот процесс запускается автоматически Java, и Java решает, запускать или нет этот процесс;
|
||
\item На самом деле это дорогостоящий процесс. При запуске сборщика мусора все потоки в вашем приложении приостанавливаются (в зависимости от типа GC);
|
||
\item На самом деле это гораздо более сложный процесс, чем просто сбор мусора и освобождение памяти.
|
||
\end{itemize} \\ \hline
|
||
|
||
03-System.gc(); & Несмотря на то, что Java решает, когда запускать сборщик мусора, нам доступен метод класса System, который мы можем явно вызвать и ожидать, что сборщик мусора будет запускаться при выполнении этой строки кода, верно? Это ошибочное предположение. Вы только как бы просите Java запустить сборщик мусора, но, опять же, Java решать, делать это или нет. В любом случае явно вызывать System.gc() не рекомендуется. \\ \hline
|
||
|
||
03-устройство памяти & Поскольку это довольно сложный процесс и может повлиять на производительность всего приложения, он реализован весьма разумно. Для этого используется так называемый процесс «Mark and Sweep» (отмечай и подметай). Java анализирует переменные из стека и «отмечает» все объекты, которые необходимо поддерживать в рабочем состоянии. Затем все неиспользуемые объекты очищаются. Фактически, чем больше мусора и чем меньше объектов помечены как живые, тем быстрее идет процесс. Чтобы сделать это еще более оптимизированным, память кучи состоит из нескольких частей, как показано на слайде. \\ \hline
|
||
|
||
03-молодое-поколение & Все новые объекты начинаются с молодого поколения. Как только они выделены в коде Java, они попадают в этот подраздел, называемый eden space. В конце концов пространство эдема заполняется объектами. На этом этапе происходит незначительная сборка мусора, так называемая minor collection. Некоторые объекты (те, на которые есть ссылки) помечаются, а некоторые (те, на которые нет ссылок) - нет. Те, которые были отмечены, затем переходят в другой подраздел молодого поколения под названием S0 пространства выживших (обратите внимание, что само пространство выживших разделено на две части, S0 и S1). Те, которые остались немаркированными, удаляются автоматической сборкой мусора. \\ \hline
|
||
|
||
03-выжившее-поколение & Так будет продолжаться до тех пор, пока пространство eden снова не заполнится; на этом этапе начинается новый цикл. События minor collection повторяются, но в этом цикле немного иначе. S0 был заполнен, и поэтому все отмеченные объекты, которые выживают как из пространства eden, так и из S0, фактически попадают во вторую часть пространства survivor, называемую S1. На приведенной на слайде диаграмме видно, что они помечены как из пространства выживших и в пространство выживших соответственно. \\ \hline
|
||
|
||
03-третье-поколение & Следует отметить одну очень важную вещь: любые объекты, попадающие в пространство выживших, помечаются счетчиком возраста. Алгоритм проверит это, чтобы увидеть, соответствует ли он пороговому значению для перехода в старое поколение.
|
||
|
||
При следующей второстепенной сборке повторяется тот же процесс. Однако на этот раз пространства выживших переключаются. Объекты, на которые даны ссылки, перемещаются в S0. Главная мысль в том, что объекты не обязательно переходят из S0 в S1 пространства выживших. На самом деле, они просто чередуются с тем, куда они переключаются при каждой minor сборке мусора.
|
||
|
||
Если эти процессы обобщить, то по существу все новые объекты начинаются в пространстве eden, а затем в конечном итоге попадают в пространство survivor, поскольку они переживают несколько циклов сборки мусора. \\ \hline
|
||
|
||
03-старое-поколение & Старое поколение можно рассматривать как место, где лежат долгоживущие объекты. По сути, если объекты достигают определенного возрастного порога после нескольких событий сборки мусора в молодом поколении, то затем они могут быть перемещены в старое поколение. Когда объекты собирают мусор из старого поколения, происходит крупное событие сборки мусора.
|
||
|
||
Предлагаю рассмотреть, как выглядит продвижение из пространства выживших молодого поколения в старое поколение. В приведенном выше примере все выжившие объекты, достигшие возрастного порога в 8 циклов — и это всего лишь пример, поэтому специально не запоминайте это число — перемещаются алгоритмом в старое поколение.
|
||
|
||
Старое поколение состоит только из одной секции, называемой постоянным поколением. \\ \hline
|
||
|
||
Постоянное поколение & Обратите внимание, что постоянное поколение не заполняется, когда объекты старого поколения достигают определенного порога, а затем перемещаются (повышаются) в постоянное поколение. Скорее, постоянное поколение немедленно заполняется JVM метаданными, которые представляют классы и методы приложений во время выполнения. JVM иногда может следовать определенным правилам для очистки постоянного поколения, и когда это происходит, это называется полной сборкой мусора major collection.
|
||
|
||
Также, хотелось бы ещё раз упомянуть событие под названием остановить мир. Когда происходит небольшая сборка мусора (для молодого поколения) или крупная сборка мусора (для старого поколения), мир останавливается; другими словами, все потоки приложений полностью останавливаются и должны ждать завершения события сборки мусора. \\ \hline
|
||
|
||
Сборщик мусора. Реализации
|
||
\begin{itemize}
|
||
\item последовательный
|
||
\item параллельный
|
||
\item CMS
|
||
\item G1
|
||
\item ZGC
|
||
\end{itemize} & Стоит упомянуть, что JVM имеет пять типов реализаций GC:
|
||
|
||
- Последовательный сборщик мусора. Это самая простая реализация GC, поскольку она в основном работает с одним потоком. В результате эта реализация GC замораживает все потоки приложения при запуске. Поэтому не рекомендуется использовать его в многопоточных приложениях, таких как серверные среды;
|
||
|
||
- Параллельный сборщик мусора. Это GC по умолчанию для JVM, который иногда называют сборщиками пропускной способности. В отличие от последовательного сборщика мусора, он использует несколько потоков для управления пространством кучи, но также замораживает другие потоки приложений во время выполнения GC. Если мы используем этот GC, мы можем указать максимальные потоки сборки мусора и время паузы, пропускную способность и занимаемую площадь (размер кучи);
|
||
|
||
- Сборщик мусора CMS. Реализация Concurrent Mark Sweep (CMS) использует несколько потоков сборщика мусора для сбора мусора. Он предназначен для приложений, которые требуют более коротких пауз при сборке мусора и могут позволить себе совместно использовать ресурсы процессора со сборщиком мусора во время работы приложения. Проще говоря, приложения, использующие этот тип GC, в среднем работают медленнее, но не перестают отвечать, чтобы выполнить сборку мусора. Здесь следует отметить, что, поскольку этот GC является параллельным, вызов явной сборки мусора, такой как использование System.gc() во время работы параллельного процесса, приведет к сбою или прерыванию параллельного режима;
|
||
|
||
- Сборщик мусора G1. Сборщик мусора G1 (Garbage First) предназначен для приложений, работающих на многопроцессорных компьютерах с большим объемом памяти. Он доступен с обновления 4 JDK7 и в более поздних версиях. Сборщик G1 заменит сборщик CMS, поскольку он более эффективен;
|
||
|
||
- Z сборщик мусора. ZGC (Z Garbage Collector) - это масштабируемый сборщик мусора с низкой задержкой, который дебютировал в Java 11 в качестве экспериментального варианта для Linux. JDK 14 представил ZGC под операционными системами Windows и macOS. ZGC получил статус production начиная с Java 15. ZGC выполняет всю дорогостоящую работу одновременно, не останавливая выполнение потоков приложений более чем на 10 мс, что делает его подходящим для приложений, требующих низкой задержки.\\ \hline
|
||
|
||
Итоги рассмотрения устройства памяти
|
||
\begin{itemize}
|
||
\item куча доступна везде, объекты доступны отовсюду
|
||
\item все объекты хранятся в куче, все локальные переменные хранятся на стеке
|
||
\item стек недолговечен
|
||
\item и стек и куча могут быть переполнены
|
||
\item куча много больше стека, но стек гораздо быстрее
|
||
\end{itemize}
|
||
&
|
||
- Куча используется всеми частями приложения в то время как стек используется только одним потоком исполнения программы;
|
||
- Объекты в куче доступны с любой точки программы, в то время как стековая память не может быть доступна для других потоков;
|
||
- Всякий раз, когда создается объект, он всегда хранится в куче, а в памяти стека содержится ссылка на него. Память стека содержит только локальные переменные примитивных типов и ссылки на объекты в куче;
|
||
- Стековая память существует лишь какое-то время работы программы, а память в куче живет с самого начала до конца работы программы;
|
||
- Если память стека полностью занята, то Java Runtime бросает java.lang.StackOverflowError, а если память кучи заполнена, то бросается исключение java.lang.OutOfMemoryError: Java Heap Space;
|
||
- Размер памяти стека намного меньше памяти в куче. Из-за простоты распределения памяти (LIFO), стековая память работает намного быстрее кучи. \\ \hline
|
||
|
||
КОНСТРУКТОР & После такого, копания в шестерёнках, время расслабиться и перейти к разбору конструкторов Java. Вернёмся к нашим барсикам. \\ \hline
|
||
|
||
03-два-кота & Чтобы создать объект мы тратим одну строку кода (Cat cat1 = new Cat()). Поля этого объекта заполнятся автоматически значениями по-умолчанию (целочисленные - 0, логические - false, ссылочные - null и т.д.). Нам бы хотелось дать коту какое-то имя, указать его возраст и цвет, поэтому мы пишем ещё три строки кода. В таком подходе есть несколько недостатков: во-первых, мы напрямую обращаемся к полям объекта (чего не стоит делать, в соответствии с принципами инкапсуляции, о которых речь пойдет чуть позже), а во-вторых, если полей у класса будет намного больше, то для создания всего лишь одного объекта будет уходить 5-10-15 строк кода, что очень громоздко и утомительно. Было бы неплохо иметь возможность сразу, при создании объекта указывать значения его полей. \\ \hline
|
||
|
||
03-плохой-конструктор лайвкод & Для инициализации объектов при создании в Java предназначены конструкторы. Конструктор - это частный случай метода в том смысле, что он тоже выполняет какие-то действия. Имя конструктора обязательно должно совпадать с именем класса, возвращаемое значение не пишется. Если создать конструктор класса Cat как показано на слайде, он автоматически будет вызываться при создании объекта. Теперь, при создании объектов класса Cat, все коты будут иметь одинаковые имена, цвет и возраст (это будут белые двухлетние Барсики). \\ \hline
|
||
|
||
03-параметризированный-конструктор лайвкод & При использовании конструктора из предыдущего примера, все созданные коты будут одинаковыми, пока мы вручную не поменяем значения их полей. Чтобы можно было указывать начальные значения полей наших объектов необходимо создать параметризированный конструктор. В приведенном на слайде примере, в параметрах конструктора используется первая буква от названия поля, это сделано для упрощения понимания логики заполнения полей объекта. И очень скоро будет заменено на более корректное использование ключевого слова this. \\ \hline
|
||
|
||
03-вызов-параметризированного лайвкод & При такой форме конструктора, когда мы будем создавать в программе кота, необходимо будет обязательно указать его имя, цвет и возраст. Набор полей, которые будут заполнены через конструктор, вы определяете сами, то есть вы не обязаны заполнять все поля, которые есть в классе записывать в параметры конструктора, но при вызове обязаны заполнить аргументами все, что есть в параметрах, как при вызове метода.
|
||
|
||
Наборы значений имён, цветов и возрастов будут переданы в качестве аргументов конструктора (n, c, a), а конструктор уже перезапишет полученные значения в поля объект (name, color, age). То есть начальные значения полей каждого из объектов будет определяться тем, что мы передадим ему в конструкторе. Как видите, теперь нам нет необходимости обращаться напрямую к полям объектов, и мы в одну строку можем инициализировать наш новый объект. \\ \hline
|
||
|
||
03-перегрузка-конструктора лайвкод & Мы можем как не объявлять ни одного конструктора, так и объявить их несколько. Также как и при перегрузке методов, имеет значение набор аргументов, не может быть нескольких конструкторов с одинаковым набором аргументов. В наш пример мы допишем конструктор, принимающий только один параметр - имя, а значит цвет будет неизвестен, а возраст, например, равен единице. \\ \hline
|
||
|
||
03-вызов-перегрузки лайвкод & В этом случае допустимы будут следующие варианты создания объектов - с полным набором параметров и только с именем. Соответствующий перегружаемый конструктор вызывается в зависимости от аргументов, указываемых при выполнении оператора new. Не лишним будет напомнить что у классов всегда есть или лучше сказать всегда должен быть конструктор, даже если вы не пропишите свою реализацию конструктора. \\ \hline
|
||
|
||
03-конструктор-по-умолчанию лайвкод & Пока мы недалеко ушли от вызовов конструкторов, важно упомянуть, что как только вы создали в классе свою реализацию конструктора, пустой конструктор, называемый также конструктором по-умолчанию автоматически создаваться не будет. И если вам понадобится такая форма конструктора (в которой нет параметров, и которая ничего не делает), необходимо будет создать его вручную: public Cat() {}. То есть компилятор как-бы думает, что если вы не описали конструкторы, значит вам не важно, как будет создаваться объект, а значит, хватит пустого конструктора, ну а если конструктор написан, значит выкручивайтесь сами. (здесь можно показать конструкторы в скомпилированных класс-файлах) \\ \hline
|
||
|
||
ключевое слово this
|
||
|
||
this - это указатель на текущий экземпляр класса.
|
||
|
||
нужен когда одинаковые имена полей и параметров
|
||
|
||
нужен чтобы вызвать конструктор из конструктора & Рассмотрим ещё один момент. Пару слайдов назад я упомянул о ключевом слове this, значит посмотрим, на часть ситуаций, в которых его используют. В контексте конструкторов, применять this нужно в двух случаях:
|
||
|
||
\begin{itemize}
|
||
\item Когда у переменной экземпляра класса и переменной метода/конструктора одинаковые имена;
|
||
\item Когда нужно вызвать конструктор одного типа (например, конструктор по умолчанию или параметризированный) из другого. Это еще называется явным вызовом конструктора.
|
||
\end{itemize}
|
||
|
||
на самом деле, это ключевое слово используется чаще, но в основном с этими целями, не так много, — всего два случая, в контексте конструкторов. Рассмотрим обе ситуации на примерах. \\ \hline
|
||
|
||
03-параметризированный-конструктор & Вспоминаем наш конструктор, видим, что переменные в параметрах называются не так, как проименованы поля класса. Многим программистом казалось это странным — вводить переменную с новым именем, если в итоге речь идет об одном и том же. Об имени, цвете или возрасте в классе Cat. Поэтому, разработчики языка задумались о том, чтобы удобно сделать использование одного имени переменной. Другими словами, зачем иметь два имени для переменной, обозначающей одно и то же.\\ \hline
|
||
|
||
03-параметризированный-конструктор-2 & хотелось бы сделать как-то так. Но в этом случае возникает проблема. У нас теперь две переменные, которые называются одинаково. Один String name принадлежит классу Cat, а другой String name находится в локальной видимости конструктора. А жвм как и любой другой электрический прибор всегда идёт по пути наименьшего сопротивления, когда не знает, какую переменную вы имеете ввиду. То есть, когда пишете строку name = name; Java берёт самую близкую name из конструктора и для левой и для правой части оператора присваивания, и получается, что вы просто присваиваете значение переменной name из конструктора, ей же. Что не имеет никакого смысла. Для решения этой проблемы и некоторых других было введено ключевое слово this, которое в данном случае укажет, что нужно вызывать переменную не конструктора, а класса Cat. \\ \hline
|
||
|
||
03-правильный-конструктор & То есть this сошлется на вызвавший объект, как было сказано в начале. В результате чего имя котика через конструктор будет установлено создаваемому объекту. Таким образом, здесь this позволяет не вводить новые переменные для обозначения одного и того же, что позволяет сделать код менее перегруженным дополнительными переменными. \\ \hline
|
||
|
||
03-один-из-другого & Второй случай частого использования this с конструкторами - вызов одного конструктора из другого. это может пригодиться когда у вас (как ни странно) несколько конструкторов и вам не хочется в новом конструкторе переписывать код инициализации, приведенный в конструкторе ранее. Все не так страшно как кажется. Напишем немного синтетический пример, который, тем не менее, должен многое объяснить. Здесь вызывается обычный конструктор с тремя параметрами, который принимает имя цвет и возраст, но, допустим, когда котята рождаются возраст им задавать смысла немного, поэтому нам может пригодиться и конструктор просто с именем и цветом, а зачем писать присваивание имени и цвета несколько раз, если можно вызвать соответствующий конструктор? Но на такой вызов есть ограничение, конструктор из конструктора можно вызвать только один раз и только на первой строке конструктора. \\ \hline
|
||
|
||
public Cat (Cat cat) {
|
||
this(cat.name, cat.color, cat.age);
|
||
} & Есть еще один вид конструктора - это конструктор копирования. Чтобы создать конструктор копирования, мы можем объявить конструктор, который принимает объект того же типа, в нашем случае котика, в качестве параметра, а в самом конструкторе аналогично конструктору, заполняющему все параметры, заполнить каждое поле входного объекта в новый экземпляр. Но у нас уже есть конструктор, который заполняет все поля, зачем нам очень похожий, спросите вы и будете правы
|
||
|
||
(лайвкод) благодаря имеющемуся у нас конструктору со всеми нужными параметрами, с помощью ключевого слова this явно вызвать конструктор заполняющий все поля кота, значениями из переданного объекта, фактически, его копирующий.
|
||
|
||
То, что мы имеем здесь, – это неглубокая копия, что удобно и довольно просто, поскольку все наши поля – int и два String в данном случае являются либо примитивными, либо неизменяемыми типами. Если класс Java имеет изменяемые поля, например, массивы, то мы можем вместо простой сделать глубокую копию внутри его конструктора копирования. При глубокой копии вновь созданный объект не должен зависеть от исходного, потому что мы создаем отдельную копию каждого изменяемого объекта, а значит, например, просто скопировать ссылку на массив будет недостаточно. Такая вложенность может быть любая и определяется поставленной задачей. \\ \hline
|
||
|
||
Инкапсуляция & Получше узнав о классах и объектах в джава, добавив для себя понимания организации этого добра в памяти, можно приступить к полному погружению в ООП. Начнём с Инкапсуляции.\\ \hline
|
||
|
||
Инкапсуляция - определение (от лат...) & Инкапсуляция связывает данные с манипулирующим ими кодом и позволяет управлять доступом к членам класса из отдельных частей программы, предоставляя доступ только с помощью определенного ряда методов, что позволяет предотвратить злоупотребление этими данными. То есть класс должен представлять собой "черный ящик", которым возможно пользоваться, но его внутренний механизм защищен от повреждений. \\ \hline
|
||
|
||
чёрный ящик, 03-useless-box & Как работает той или иной поисковик, которым вы пользуетесь? Как именно он ищет информацию по тем или иным словам, которые вы вводите? Почему одни результаты находятся сверху в результатах поиска, а не какие-то другие? Хотя мы и используем поисковые средства каждый день, но, мало кто знает ответы на эти вопросы. Но это и не важно. Ведь это никому не нужно знать, когда поисковики выполняются свою задачу - ведь только это и важно. Все это возможно благодаря одному из главных принципов объектно-ориентированного программирования — инкапсуляции. Изначальное значение слова «инкапсуляция» в программировании — объединение данных и методов работы с этими данными в одной упаковке ("капсуле"). \\ \hline
|
||
|
||
кот в мешке & В Java в роли упаковки-капсулы выступает класс. Класс содержит в себе и данные (поля класса), и действия (методы класса) для работы с этими данными. Также, можно встретить такое понятие как "сокрытие". Оно реализует два направления: сокрытие реализации и сокрытие данных. Хорошо, но с помощью чего достигается сокрытие? Все члены класса в языке Java - поля и методы - имеют модификаторы доступа. Мы уже сталкивались с модификатором public, создавая публичные классы и публичную точку входа в программу. public означает доступность отовсюду, обычно используется для методов. Модификаторы доступа позволяют задать допустимую область видимости для членов класса, то есть контекст, в котором можно употреблять данную переменную или метод. \\ \hline
|
||
|
||
03-МД-без-протекта-и-привата & Есть два модификатора, которые нам уже известны, это паблик и пекеж-приват, также известный как дефолтный, пакетный или отсутствующий модификатор. Что это значит? это значит, что вообще всё что мы пишем в джаве имеет уровень доступа и если мы не определили этот уровень явно, то джава отнесёт наши данные к уровню доступности внутри пакета. Про пакеты мы говорили в самом начале, и вот, если публичные классы находятся в одном пакете - им доступны поля и методы друг друга, имеющие модификатор пекеж-прайват.\\ \hline
|
||
|
||
03-МД-без-протекта & модификатор private определяет доступность только внутри класса, и предпочтительнее всех. Вообще, хорошая практика предоставлять минимальный доступ к переменным в своём классе, чтобы те, кто им пользуются не внесли какие-то неожиданные изменения в его работу. Возникает законный вопрос, как так получается, что мы пользуемся всякими сложными механизмами без особенно долгого осмысливания, как они устроены и на чем основана их работа? Как мы можем дёргать за все эти ниточки ЖРЕ, если максимальная приватность - это очень хорошо? Все просто: создатели всех библиотек предоставляют простой и удобный интерфейс к своим разработкам. \\ \hline
|
||
|
||
продублировать 3-26 (поля класса кот) лайвкод & Внимательно осмотрев класс кота мы приходим к выводу, что хранить возраст котов очень неудобно, потому что каждый год нужно будет обновлять это значение для каждого объекта кота в программе, а это может оказаться утомительно. Выходом может оказаться хранение не возраста, а неизменяемого параметра даты рождения и подсчёт возрастка каждый раз, когда его запрашивают. Ведь человеку, который запрашивает возраст котика, не интересно, каким образом получено значение, прочитано из поля или вычислено, ему важен конечный результат. Вот это и есть сокрытие реализации. \\ \hline
|
||
|
||
cat.name = "";
|
||
cat.color = "GREEEEEN";
|
||
cat.age = -12345;
|
||
лайвкод & Внимательно рассмотрим класс котика, хотя, конечно, мы его писали, что может пойти не так? А не так здесь может быть очень многое. Например, кто-то может создать хорошего кота, а потом его переименовать, перекрасить в зелёный цвет или сделать ему отрицательный возраст. Коту такое явно не понравится. \\ \hline
|
||
|
||
& \\ \hline
|
||
& \\ \hline
|
||
|
||
|
||
Какой ужас, взгляните на эти значения. Данный класс котика позволяет присваивать полям безумные значение. В результате в программе находятся объекты с некорректным состоянием, типа вот этого котика с зелёным цветом и с возрастом -12345 лет.
|
||
Какая же тут была допущена ошибка? Все поля находятся в публичном доступе. К ним можно обратиться в любом месте программы: достаточно просто создать объект Cat — и все, у любого программиста есть доступ к его данным напрямую через оператор “.”
|
||
Нам нужно как-то защитить наши данные от некорректного вмешательства извне.
|
||
Во-первых, все переменные экземпляра (поля) необходимо помечать модификатором private. Private — самый строгий модификатор доступа в Java. Если ты его используешь, поля класса Cat не будут доступны за его пределами.
|
||
Теперь поля вроде как защищены. Но получается, что доступ к ним закрыт “намертво”: в программе нельзя даже получить вес существующей кошки, если это понадобится. Это тоже не вариант: в таком виде наш класс практически нельзя использовать.
|
||
Что же, нам нужно решить вопросы с получением и изменением значений полей. На помощь к нам приходят геттеры и сеттеры.
|
||
Название происходит от английского “get” — “получать” (т.е. “метод для получения значения поля”) и set — “устанавливать”
|
||
Предлагаю посмотреть на класс со стороны применения этих методов:
|
||
|
||
public class Cat {
|
||
|
||
private String name;
|
||
private String color;
|
||
private int age;
|
||
|
||
public Cat(String name, String color, int age) {
|
||
this.name = name;
|
||
this.color = color;
|
||
this.weight = age;
|
||
}
|
||
|
||
public Cat() {
|
||
}
|
||
|
||
void voice() {
|
||
System.out.println(name + " meows");
|
||
}
|
||
|
||
void jump() {
|
||
if (this.age < 5) System.out.println(name + " jumps");
|
||
}
|
||
|
||
public String getName() {
|
||
return name;
|
||
}
|
||
|
||
public void setName(String name) {
|
||
this.name = name;
|
||
}
|
||
|
||
public int getAge() {
|
||
return age;
|
||
}
|
||
|
||
public void setAge(int age) {
|
||
this.age = age;
|
||
}
|
||
|
||
public String getColor() {
|
||
return color;
|
||
}
|
||
|
||
public void setColor(String color) {
|
||
this.color = color;
|
||
}
|
||
}
|
||
|
||
|
||
Теперь у нас есть возможность получать данные и устанавливать их. Например, с помощью getColor ьы можем получить значение окраса котика.
|
||
Давайте посмотрим пример создания такого котика:
|
||
|
||
public class Main {
|
||
|
||
public static void main(String[] args) {
|
||
|
||
Cat murka = new Cat("Мурка", "Чёрный", 4);
|
||
String murkaName = murka.getName();
|
||
String murkaColor = murka.getColor();
|
||
int murkaAge = murka.getAge();
|
||
|
||
System.out.println("Имя кота: " + murkaName);
|
||
System.out.println("Окрас кота: " + murkaColor);
|
||
System.out.println("Возраст кота: " + murkaAge);
|
||
}
|
||
}
|
||
|
||
|
||
Вывод в консоле:
|
||
|
||
Имя кота: Мурка
|
||
Окрас кота: Чёрный
|
||
Возраст кота: 5
|
||
|
||
|
||
Теперь из другого класса (Main) есть доступ к полям Cat, но только через геттеры. Обрати внимание — у геттеров стоит модификатор доступа public, то есть они доступны из любой точки программы.
|
||
А что, если нам хочется обновить возраст котика? Не проблема, тут спокойно можно использовать геттер:
|
||
|
||
public class Main {
|
||
|
||
public static void main(String[] args) {
|
||
|
||
Cat murka = new Cat("Мурка", "Чёрный", 4);
|
||
|
||
System.out.println("Изначальный возраст кота — " + murka.getAge());
|
||
barsik.setName(5);
|
||
System.out.println("Новый возраст кота — " + murka.getAge());
|
||
}
|
||
}
|
||
|
||
|
||
Вывод в консоль:
|
||
|
||
Изначальный возраст кота — 4
|
||
Новый возраст кота — Василий - 5
|
||
|
||
|
||
Сейчас у многих мог возникнуть вопрос, а в чём разница? Что сеттер — это полноценный метод. А в метод, в отличие от поля, ты можешь заложить необходимую тебе логику проверки, чтобы не допустить неприемлемых значений. Например, можно легко не позволить назначение отрицательного числа в качестве возраста:
|
||
|
||
public void setAge(int age) {
|
||
if (age >= 0) {
|
||
this.age = age;
|
||
} else {
|
||
System.out.println("Ошибка! Возраст не может быть отрицательным числом!");
|
||
}
|
||
}
|
||
|
||
|
||
Так вот это является одним из трёх китов ООП - Инкапсуляцией.
|
||
Еще один момент хотелось бы немного затронуть - это Enum. Кроме отдельных примитивных типов данных и классов в Java есть такой тип как enum или перечисление. Перечисления представляют набор логически связанных констант. Объявление перечисления происходит с помощью оператора enum, после которого идет название перечисления. Затем идет список элементов перечисления через запятую:
|
||
|
||
enum Season { WINTER, SPRING, SUMMER, AUTUMN }
|
||
|
||
|
||
Перечисление фактически представляет новый тип, поэтому мы можем определить переменную данного типа и использовать ее:
|
||
|
||
public class Main{
|
||
|
||
public static void main(String[] args) {
|
||
|
||
Season current = Season.SPRING;
|
||
System.out.println(current);
|
||
}
|
||
}
|
||
|
||
|
||
Выведет SPRING.
|
||
Каждое перечисление имеет статический метод values(). Он возвращает массив всех констант перечисления:
|
||
|
||
public class Main{
|
||
|
||
public static void main(String[] args) {
|
||
|
||
Season[] seasons = Season.values();
|
||
for (Season s : seasons) { System.out.println(s); }
|
||
}
|
||
}
|
||
|
||
|
||
А метод ordinal() возвращает порядковый номер определенной константы (нумерация начинается с 0).
|
||
Перечисления, как и обычные классы, могут определять конструкторы, поля и методы. Например:
|
||
|
||
\begin{verbatim}
|
||
public class Main{
|
||
|
||
public static void main(String[] args) {
|
||
|
||
System.out.println(Color.RED.getCode());
|
||
System.out.println(Color.GREEN.getCode());
|
||
}
|
||
}
|
||
|
||
enum Color{
|
||
RED("#FF0000"), BLUE("#0000FF"), GREEN("#00FF00");
|
||
private String code;
|
||
Color(String code){
|
||
this.code = code;
|
||
}
|
||
public String getCode(){ return code;}
|
||
}
|
||
|
||
\end{verbatim}
|
||
|
||
Перечисление Color определяет приватное поле code для хранения кода цвета, а с помощью метода getCode оно возвращается. Через конструктор передается для него значение. Следует отметить, что конструктор по умолчанию приватный, то есть имеет модификатор private. Любой другой модификатор будет считаться ошибкой. Поэтому создать константы перечисления с помощью конструктора мы можем только внутри перечисления.
|
||
Это было введение в первое часть ООП, дальше переходим ко второму - Наследование.
|
||
Наследование:
|
||
|
||
extends;
|
||
Object (глобальное наследование);
|
||
protected;
|
||
конструкторы в наследовании. Кто кого вызывает - авокадо
|
||
конструкторы по умолчанию при наследовании и что делать при ситуации, когда отсутствует у родителя - эксепшн
|
||
super, опираясь на this;
|
||
преобразование типов (скрины вспомнить. С ссылочными тыры-пыры);
|
||
final (переопределение - не надо, а предотвращение наследования);
|
||
абстракт
|
||
|
||
Давайте представим, что мы хотим создать помимо класса котиков, но и класс для собачек. Данный класса будет выглядеть так:
|
||
|
||
public class Dog {
|
||
|
||
public String name;
|
||
public String color;
|
||
public int age;
|
||
|
||
public Dog(String name, String color, int age) {
|
||
this.name = name;
|
||
this.color = color;
|
||
this.weight = age;
|
||
}
|
||
|
||
public Dog() {
|
||
}
|
||
|
||
void voice() {
|
||
System.out.println(name + " grrrr");
|
||
}
|
||
|
||
void jump() {
|
||
if (this.age < 5) System.out.println(name + " jumps");
|
||
}
|
||
|
||
public String getName() {
|
||
return name;
|
||
}
|
||
|
||
public void setName(String name) {
|
||
this.name = name;
|
||
}
|
||
|
||
public int getAge() {
|
||
return age;
|
||
}
|
||
|
||
public void setAge(int age) {
|
||
this.age = age;
|
||
}
|
||
|
||
public String getColor() {
|
||
return color;
|
||
}
|
||
|
||
public void setColor(String color) {
|
||
this.color = color;
|
||
}
|
||
}
|
||
|
||
|
||
Что же, вот и описание класса для собачек. Вроде выглядит неплохо, пока мы не сталкиваемся с необходимостью описать классы для целого зоопарка. Мы видим, что в наших классах есть очень много одинаковых полей и методов.
|
||
А как мы помним из занятия по циклам - если что-то повторяется в коде несколько раз - это очень плохо и надо срочно от этого избавиться, чтобы не плодить сотни строк кода, в которых даже разбираться никто не будет. Тут нам на помощь приходит наследование. И кот и пёс являются животными, и у всех описываемых нами животных есть имя, возраст, окрас. И все описываемые нами животные могут бегать, прыгать, и откликаться на имя. Создадим так называемый родительский, он же базовый, класс, животное. И поместим в него общие поля.
|
||
|
||
public class Animal {
|
||
|
||
private String name;
|
||
private String color;
|
||
private int age;
|
||
|
||
public Animal(String name, String color, int age) {
|
||
this.name = name;
|
||
this.color = color;
|
||
this.age = age;
|
||
}
|
||
|
||
public Animal() {
|
||
}
|
||
|
||
void jump() {
|
||
if (this.age < 5) System.out.println(name + " jumps");
|
||
}
|
||
|
||
public String getName() {
|
||
return name;
|
||
}
|
||
|
||
public void setName(String name) {
|
||
this.name = name;
|
||
}
|
||
|
||
public int getAge() {
|
||
return age;
|
||
}
|
||
|
||
public void setAge(int age) {
|
||
this.age = age;
|
||
}
|
||
|
||
public String getColor() {
|
||
return color;
|
||
}
|
||
|
||
public void setColor(String color) {
|
||
this.color = color;
|
||
}
|
||
}
|
||
|
||
|
||
Пока не очень ясно зачем мы так делаем, ну есть у нас класс животное и хорошо, всё отлично работает, можно больше ничего не писать. Но, не тут то было, несмотря на все свои сходства, наши животные, например, издают разные звуки, поэтому, унаследовав от родительского класса основные свойства и поведение, мы в классах наследниках описываем разные методы например, реакции на оклик.
|
||
Так что же нужно, чтобы унаследовать какой-то класс? Чтобы унаследовать один класс от другого, нужно после объявления нашего класса указать ключевое слово extends и написать имя родительского класса. Реализуем котика и собачку:
|
||
|
||
class Cat extends Аnimal {
|
||
void voice() {
|
||
System.out.println(getname() + " meows");
|
||
}
|
||
}
|
||
|
||
class Dog extends Аnimal {
|
||
void voice() {
|
||
System.out.println(name + " grrrr"); //name fail
|
||
}
|
||
}
|
||
|
||
|
||
У всей этой прекрасной объектной ориентированности есть одно ограничение: для каждого создаваемого подкласса можно указать только один суперкласс. В Java не поддерживается множественное наследование от нескольких суперклассов в одном подклассе. Если класс-родитель не указан, таковым считается класс Object. Также, мы не смогли бы определить поле имя, как показано в примере с собачкой, хотя могла получить доступ к методу геттеру получения значения имени.
|
||
Что же с ним не так? Вспоминаем информацию о модификаторах доступа и находим несостыковку. Модификатор private определяет область видимости только внутри класса, а если нам нужно чтобы переменную было видно ещё и в классах-наследниках, нужен модификатор доступа по умолчанию. А если мы создаём класс наследник в каком-то другом пакете, то и вовсе protected. Это просто нужно запомнить, что если мы хотим создавать наследников от нашего класса, то те поля, которые будут наследоваться, должны быть не приватными, а защищёнными.
|
||
Всё же, давайте чуток подробнее рассмотрим модификаторы доступа в наследовании.
|
||
К членам данных и методам класса можно применять следующие модификаторы доступа:
|
||
|
||
private. В этом случае член данных класса или метод класса доступен только из методов данного класса. Из методов подклассов и объектов (экземпляров) данного класса доступа нет;
|
||
protected (защищенный доступ). В этом случае есть доступ из данного класса, объекта этого класса а также подкласса. Тем не менее, нет доступа из объекта подкласса;
|
||
public. В этом случае есть доступ из данного класса, подкласса, объекта данного класса а также объекта подкласса.
|
||
|
||
Также, стоит упомянуть об особенностях каждого из модификаторов.
|
||
Если члены данных или методы класса объявлены с модификатором доступа private, тогда они считаются:
|
||
|
||
доступными из методов класса, в котором они объявлены;
|
||
недоступными для всех других методов любых классов (подклассов), экземпляров (объектов) любых классов.
|
||
|
||
Если члены данных или методы класса объявлены с модификатором доступа protected, тогда они считаются:
|
||
|
||
доступными из методов класса, в котором они объявлены;
|
||
доступными из методов подкласса. Это касается и случая, когда унаследованный класс объявляется в другом пакете;
|
||
доступными из экземпляров (объектов) данного класса;
|
||
доступными из экземпляров (объектов) подкласса.
|
||
|
||
Модификатор доступа public применяется если нужно получить доступ к члену данных или методу класса из любой точки программы. Доступ к public членам данных и методам класса имеют:
|
||
|
||
методы данного класса;
|
||
методы подкласса;
|
||
объекты данного класса;
|
||
объекты подкласса;
|
||
объекты, которые объявлены в методах классов, которые находятся в других пакетах.
|
||
|
||
И последний модификатор доступа - это default. Он не обозначается ключевым словом, поскольку установлен в Java по умолчанию для всех полей и методов.
|
||
Случаи его применения ограничены, как и у модификатора protected. Чаще всего default-доступ используется в пакете, где есть какие-то классы-утилиты, не реализующие функциональность всех остальных классов в этом пакете.
|
||
А теперь пришло время вернуться к конструкторам. Надо же разобраться какой и когда вызывается и после кого.
|
||
Будем снова рассматривать пример с животными.
|
||
Начнём мы с того, что при создании объекта в первую очередь вызывается конструктор его базового класса, а только потом — конструктор самого класса, объект которого мы создаем.
|
||
То есть при создании объекта Cat сначала отработает конструктор класса Animal, а только потом конструктор Cat.
|
||
Чтобы убедиться в этом — упростим классы и добавим в конструкторы Cat и Animal вывод в консоль.
|
||
|
||
public class Animal {
|
||
|
||
public Animal() {
|
||
System.out.println("Ctor Animal");
|
||
}
|
||
}
|
||
|
||
|
||
public class Cat extends Animal {
|
||
|
||
public Cat() {
|
||
System.out.println("Ctor Cat");
|
||
}
|
||
|
||
public static void main(String[] args) {
|
||
Cat cat = new Cat();
|
||
}
|
||
}
|
||
|
||
|
||
Вывод в консоль:
|
||
|
||
Ctor Animal
|
||
Ctor Cat
|
||
|
||
|
||
Мы можем явно вызвать конструктор базового класса в конструкторе класса-потомка. Базовый класс еще называют “суперклассом”, поэтому в Java для его обозначения используется ключевое слово super.
|
||
Давайте сделаем это с классами энимэл и котика. Возьмём старый класс энимал и модифицируем класс котика.
|
||
Класс энимэл с геттерами и сеттерами:
|
||
|
||
public class Animal {
|
||
private String name;
|
||
private String color;
|
||
private int age;
|
||
|
||
public Animal(String name, String color, int age) {
|
||
this.name = name;
|
||
this.color = color;
|
||
this.age = age;
|
||
}
|
||
|
||
public Animal() {
|
||
}
|
||
|
||
// getters and setters
|
||
// ...
|
||
}
|
||
|
||
|
||
И модифицированный класс котика:
|
||
|
||
public class Cat extends Animal {
|
||
private String voice;
|
||
|
||
public Cat(String name, String color, int age, String voice){
|
||
super(name, color, age);
|
||
this.voice = voice;
|
||
}
|
||
|
||
void voiceCat() {
|
||
System.out.println(getName() + " " + voice);
|
||
}
|
||
}
|
||
|
||
|
||
После, вызвать:
|
||
|
||
public class Main {
|
||
public static void main(String[] args) {
|
||
|
||
Cat cat = new Cat("Murka", "Black", 4, "muuuur");
|
||
cat.voiceCat();
|
||
}
|
||
}
|
||
|
||
|
||
Вывод в консоль:
|
||
|
||
Murka muuuur
|
||
|
||
|
||
В конструкторе Cat мы вызвали конструктор Animal и передали в него три поля. Нам осталось явно проинициализировать только одно поле — voice, которого в Animal нет.
|
||
Ранее, мы говорили о том, что при создании объекта в первую очередь вызывается конструктор класса-родителя. Так вот, именно поэтому слово super() всегда должно стоять в конструкторе первым!
|
||
Иначе логика работы конструкторов будет нарушена и программа выдаст ошибку.
|
||
Компилятор знает, что при создании объекта класса-потомка сначала вызывается конструктор базового класса. И если будет выполнена попытка вручную изменить это поведение - он не позволит этого сделать.
|
||
Перед продолжением, хотелось бы сделать небольшое отступление, раз уж мы заговорили о super(), нужно бы и пояснить разницу между им и this.
|
||
this и super - это два специальных ключевых слова в Java, которые представляют соответственно текущий экземпляр класса и его суперкласса. Java-программисты часто путают эти слова и обнаруживают слабую осведомленность об их специальных свойствах, о которых нередко спрашивают на интервью по Java Сore. Вот, например, пара вопросов, из того, что сразу приходит на ум, о this и super, Можно ли присвоить другое значение ключевому слову this в Java? и какая разница между ключевыми словами this и super в Java.
|
||
Так вот, как я уже сказал, главное отличие между this и super в Java в том, что this представляет текущий экземпляр класса, в то время как super - текущий экземпляр родительского класса. Вот один из примеров использования переменных this и super — мы уже разбирали примеры вызовов конструкторов одного из другого, т.н. вызовы конструкторов по цепочке, это возможно благодаря использованию ключевых слов this и super. Внутри класса для вызова своего конструктора без аргументов используется this(), тогда как super() используется для вызова конструктора без аргументов, или как его ещё называют, конструктора по умолчанию родительского класса. Ну или как мы сделали ранее, вообще любой другой конструктор, передав ему соответствующие параметры.
|
||
Ещё this и super в Java используются для обращения к переменным экземпляра класса и его родителя. Вообще-то, к ним можно обращаться и без префиксов super и this, но только если в текущем блоке такие переменные не перекрываются другими переменными, т.е. если в нем нет локальных переменных с такими же именами, в противном же случае использовать имена с префиксами придется обязательно, но это не беда, т.к. в таком виде они даже более читабельны. Классическим примером такого подхода является использование this внутри конструктора, который принимает параметр с таким же именем, как и у переменной экземпляра.
|
||
Теперь вернёмся к нашим котикам и собачкам с наследованием.
|
||
В этой иерархии классов можно проследить следующую цепь наследования: Object (все классы неявно наследуются от типа Object) -> Animal -> Cat|Dog.
|
||
Давайте рассмотрим картинку ниже и попробуем вспомнить о преобразовании типов.
|
||
|
||
Суперклассы обычно размещаются выше подклассов, поэтому на вершине наследования находится класс Object, а в самом низу Cat и Dog.
|
||
Объект подкласса также представляет объект суперкласса. Поэтому в программе мы можем написать следующим образом:
|
||
|
||
public class Main {
|
||
public static void main(String[] args) {
|
||
Object animal = new Animal("Cat", "Black", 3);
|
||
Object cat = new Cat("Murka", "Black", 4, "muuuur");
|
||
Object dog = new Dog("Bobik", "White", 2, "woof");
|
||
Animal dogAnimal = new Dog("Manya", "Grey", 3, "woof");
|
||
Animal catAnimal = new Cat("Marusya", "Orange", 1, "myau");
|
||
}
|
||
}
|
||
|
||
|
||
Это так называемое восходящее преобразование (от подкласса внизу к суперклассу вверху иерархии) или upcasting. Такое преобразование осуществляется автоматически.
|
||
Обратное не всегда верно. Например, объект Animal не всегда является объектом Cat или Dog. Поэтому нисходящее преобразование или downcasting от суперкласса к подклассу автоматически не выполняется. В этом случае нам надо использовать операцию преобразования типов.
|
||
|
||
Object animal = new Cat("Murka", "Black", 4, "muuuur");
|
||
Cat cat = (Cat)animal;
|
||
cat.voiceCat();
|
||
|
||
|
||
В данном случае переменная animal приводится к типу Cat. И затем через объект cat мы можем обратиться к функционалу объекта Cat.
|
||
Еще один момент из этой темы - это оператор instanceof.
|
||
Нередко данные приходят извне, и мы можем точно не знать, какой именно объект эти данные представляют. Соответственно возникает большая вероятность столкнуться с ошибкой. И перед тем, как провести преобразование типов, мы можем проверить, а можем ли мы выполнить приведение с помощью оператора instanceof:
|
||
|
||
Object cat = new Cat("Murka", "Black", 4, "muuuur");
|
||
if(cat instanceof Dog){
|
||
|
||
Dog dogIsCat = (Dog) cat;
|
||
dogIsCat.jump();
|
||
}
|
||
else{
|
||
System.out.println("Conversion is invalid");
|
||
}
|
||
|
||
|
||
Выражение cat instanceof Dog проверяет, является ли переменная cat объектом типа Dog. Но так как в данном случае явно не является, то такая проверка вернет значение false, и преобразование не сработает.
|
||
Вывод консоли:
|
||
|
||
Conversion is invalid
|
||
|
||
|
||
А вот выражение cat instanceof Animal выдало бы true и вывело бы Murka jumps:
|
||
|
||
Object cat = new Cat("Murka", "Black", 4, "muuuur");
|
||
if(cat instanceof Animal){
|
||
|
||
Animal catAnimal = (Animal) cat;
|
||
catAnimal.jump();
|
||
}
|
||
else{
|
||
System.out.println("Conversion is invalid");
|
||
}
|
||
|
||
|
||
Как хорошо, когда у нас есть возможность наследоваться от класса, но что, если нам стало нужно, чтобы от нашего класса никто больше не смог унаследоваться?
|
||
В java есть ключевое слово – final. Оно может применяться к классам, методам, переменным (в том числе аргументам методов).
|
||
Нам на данный момент интересен момент с классом, как можно запретить наследование.
|
||
Если мы взглянем на класс String, то увидим, что он объявлен как final. И унаследоваться от него нельзя:
|
||
|
||
public final class String{
|
||
//...
|
||
}
|
||
|
||
class SubString extends String{ //Ошибка компиляции
|
||
}
|
||
|
||
|
||
То есть, если мы логически понимаем, что у нас от котиков уже нельзя наследоваться, то мы их можем пометить этим ключевым словом:
|
||
|
||
public final class Cat extends Animal {
|
||
private String voice;
|
||
|
||
public Cat(String name, String color, int age, String voice){
|
||
super(name, color, age);
|
||
this.voice = voice;
|
||
}
|
||
|
||
void voiceCat() {
|
||
System.out.println(getName() + " " + voice);
|
||
}
|
||
}
|
||
|
||
|
||
И тогда, если мы в коде начнём писать класс и укажем, что наследуемся от кота, то у нас выведется Cannot inherit from final 'org.example.Cat.
|
||
Хорошо, мы разобрались с наследованием в целом, с поведением конструкторов, с преобразованием типов и т.д. Осталось разобрать момент, который называется абстракцией.
|
||
В ООП это означает, что при проектировании классов и создании объектов необходимо выделять только главные свойства сущности, и отбрасывать второстепенные.
|
||
Так вот, абстрактный класс — это максимально абстрактная, о-о-о-чень приблизительная «заготовка» для группы будущих классов. Эту заготовку нельзя использовать в готовом виде — слишком «сырая». Но она описывает некое общее состояние и поведение, которым будут обладать будущие классы — наследники абстрактного класса.
|
||
Рассмотрим пример абстрактного класса энимэл:
|
||
|
||
public abstract class Animal {
|
||
private String name;
|
||
private String color;
|
||
private int age;
|
||
|
||
public Animal(String name, String color, int age) {
|
||
this.name = name;
|
||
this.color = color;
|
||
this.age = age;
|
||
}
|
||
|
||
public Animal() {
|
||
}
|
||
|
||
public abstract void jump() ;
|
||
|
||
public abstract void voice();
|
||
|
||
public String getName() {
|
||
return name;
|
||
}
|
||
|
||
public void setName(String name) {
|
||
this.name = name;
|
||
}
|
||
|
||
public int getAge() {
|
||
return age;
|
||
}
|
||
|
||
public void setAge(int age) {
|
||
this.age = age;
|
||
}
|
||
|
||
public String getColor() {
|
||
return color;
|
||
}
|
||
|
||
public void setColor(String color) {
|
||
this.color = color;
|
||
}
|
||
}
|
||
|
||
|
||
Таким образом выглядит абстрактный класс энимал. Что в нём такого особенного? Прежде всего, он максимально абстрактно описывает нужную нам сущность — животное. Слово abstract находится здесь недаром. В мире не существует «просто животных». Есть губки, иглокожие, хордовые и т.д.
|
||
Данный абстрактный класс просто является чертежом по которому будут создаваться дальнейшие классы животных. Допишем для пример класс Dog:
|
||
|
||
public class Dog extends Animal{
|
||
private String voice;
|
||
|
||
public Dog(String name, String color, int age, String voice){
|
||
super(name, color, age);
|
||
this.voice = voice;
|
||
}
|
||
|
||
@Override
|
||
public void jump() {
|
||
if (getAge() < 5) System.out.println(getName() + " jumps");
|
||
}
|
||
|
||
@Override
|
||
public void voice() {
|
||
System.out.println(getName() + " " + voice);
|
||
}
|
||
}
|
||
|
||
|
||
Использование:
|
||
|
||
Animal dogAnimal = new Dog("Manya", "Grey", 3, "woof");
|
||
dogAnimal.jump();
|
||
dogAnimal.voice();
|
||
|
||
|
||
Вывод:
|
||
|
||
Manya jumps
|
||
Manya woof
|
||
|
||
|
||
Это во многом похоже на то, о чем мы говорили в наследовании. Только там у нас класс Animal и его методы не были абстрактными. Но у такого решения есть целый ряд минусов, которые в абстрактных классах исправлены.
|
||
Первое и главное — экземпляр абстрактного класса создать нельзя.
|
||
Тот же пример можно привести с животными. Представьте, если бы в программе появились объекты Animal — «просто животное». Какого оно вида, к какому семейству относится, какие у него характеристики — непонятно. Было бы странно увидеть его в программе. Никаких «просто животных» в природе не существует. Только собаки, кошки, лисы, кроты и другие.
|
||
|
||
\end{longtable}
|
||
|
||
\end{document}
|