Как работают принципы ООП в Java: примеры
Принципы и понятия объектно-ориентированного программирования (ООП, или OOPS, Object-Oriented Programming Concepts) очень важны. Не разбираясь в понятиях ООП, вы не сможете проектировать системы в модели объектно-ориентированного программирования.
Модель объектно-ориентированного программирования
Модель объектно-ориентированного программирования построена вокруг понятия объекта. Объект – это экземпляр класса. Он содержит свойства и функции. По сути они похожи на объекты реального мира: как, например, машина, дом, ноутбук и т. д. У них есть свои свойства и определенные методы для выполнения действий. Что такое класс? Класс определяет схему объектов. Он определяет свойства и функции объектов. К примеру, книга — это класс, а конкретно ваша книга — его экземпляр.
Принципы ООП
Основными принципами ООП являются:
- Абстракция
- Инкапсуляция
- Полиморфизм
- Наследование
- Ассоциация и агрегация
- Композиция
Теперь по порядку рассмотрим эти понятия объектно-ориентированного программирования. Чтобы вы лучше поняли, как реализовать концепции ООП, мы будем использовать фрагменты кода на языке программирования Java.
Абстракция
Абстракция — это скрытие внутренних деталей и описание вещей простыми терминами. Возьмем, к примеру, метод, который складывает два целых числа . Внутренняя обработка метода скрыта от внешнего мира. Достичь абстракци в ООП можно несколькими способами, например, через инкапсуляцию и наследование. Отличным примером абстракции является программа на Java: язык программирования сам заботится о преобразовании простых операторов в машинный язык и скрывает детали внутренней реализации от внешнего мира.
Инкапсуляция
Инкапсуляция — это метод, используемый для реализации абстракции в ООП. Она ограничивает доступ к членам и методам класса. Для инкапсуляции в ООП применяются ключи модификаторов доступа. Например, в языке java инкапсуляция достигается с помощью ключевых слов private, protected и public.
Полиморфизм
Полиморфизм указывает, что в разных ситуациях объект ведет себя по-разному. Существует два типа полиморфизма – полиморфизм во время компиляции и во время выполнения. Полиморфизм во время компиляции достигается перегрузкой метода.
Для примера рассмотрим такой класс:
public class Circle public void draw() System.out.println("Drwaing circle with default color Black and diameter 1 cm."); > public void draw(int diameter) System.out.println("Drwaing circle with default color Black and diameter"+diameter+" cm."); > public void draw(int diameter, String color) System.out.println("Drwaing circle with color"+color+" and diameter"+diameter+" cm."); > > Все методы draw, которые встречаются в этом коде, ведут себя по-разному. Это пример перегрузки метода, потому что имена методов одинаковы, а аргументы разные. Поскольку компилятор сможет определить метод вызова во время компиляции, данный метод называется полиморфизмом во время компиляции. Полиморфизм во времени выполнения реализуется, когда между объектами есть отношения наследования «IS-A». Также этот подход называется переопределением метода, поскольку подкласс должен переопределить метод суперкласса. Фактический класс определяется во время выполнения с точки зрения суперкласса. Компилятор не может решать, какой метод класса будет вызван. Это решение принимается во время выполнения, отсюда и название – «полиморфизм во время выполнения» или «динамическая диспетчеризация методов».
package com.journaldev.test; public interface Shape public void draw(); > package com.journaldev.test; public class Circle implements Shape @Override public void draw() System.out.println("Drwaing circle"); > > package com.journaldev.test; public class Square implements Shape @Override public void draw() System.out.println("Drawing Square"); > >
Тут Shape — это суперкласс, у которого есть два подкласса, Circle и Square. Ниже приведен пример полиморфизма во время выполнения.
Shape sh = new Circle(); sh.draw(); Shape sh1 = getShape(); //some third party logic to determine shape sh1.draw();
В этих примерах компилятор Java не знает фактического класса реализации Shape, который будет использоваться во время выполнения.
Наследование
Наследование — это понятие объектно-ориентированного программирования, которое указывает, что один объект основан на другом объекте, вытекает из него. Проще говоря, наследование — это механизм повторного использования кода. Наследуемый объект называется суперклассом, а объект, который наследует суперкласс, называется подклассом. В java для реализации наследования используется ключевое слово extends. Давайте посмотрим на следующий пример наследования в java.
package com.journaldev.java.examples1; class SuperClassA public void foo() System.out.println("SuperClassA"); > > class SubClassB extends SuperClassA public void bar() System.out.println("SubClassB"); > > public class Test public static void main(String args[]) SubClassB a = new SubClassB(); a.foo(); a.bar(); > >
Ассоциация
Такое поняте ООП, как ассоциация, определяет связи между объектами, а также разнообразие самих объектов. Предположим, что у нас есть объекты “Учитель” и “Ученик”: множество учеников может общаться с одним учителем, и, конечно, один ученик также может общаться с несколькими учителями.
Агрегация
Агрегация – это особый тип ассоциации. Это понятие подразумевает, что все объекты имеют свой собственный жизненный цикл, но со взаимосвязью «HAS-A» – то есть один дочерний объект может принадлежать одному родительскому . Каждый раз, когда вы встречаете взаимосвязь «HAS-A» между объектами, знайте – это называется агрегацией.
Композиция
Композиция – специальная “ограничительная” форма агрегации. В композиции содержащийся в отношении «HAS-A» объект не может существовать сам по себе. Представим, например, комнату, которая находится в доме . Одна комната не может быть частью двух разных домов. Конечно, если вы удалите дом, комната тоже будет удалена.
Больше примеров кода вы найдете в нашем репозитории GitHub .
Объектно ориентированное программирование ява
Концепции ООП являются основополагающими элементами и составляют основу языка программирования Java. В рамках данного подхода выделяют следующие термины: абстракция, инкапсуляция, наследование и полиморфизм. Понимание данных принципов служит ключом к построению целостной картины того, как работают программы, написанные на Java. По большому счету, объектно-ориентированный подход позволяет нам описывать классы, определять методы и переменные таким образом, чтобы затем использовать их вновь, частично либо полностью, без нарушения безопасности.
- Абстракция. Абстракция означает использование простых вещей для описания чего-то сложного. Например, мы все знаем как пользоваться телевизором, но в тоже время нам не нужно обладать знаниями о том, как он работает чтобы смотреть его. В Java под абстракцией подразумеваются такие вещи, как объекты, классы и переменные, которые в свою очередь лежат в основе более сложного кода. Использование данного принципа позволяет избежать сложности при разработке ПО.
- Инкапсуляция. Под инкапсуляцией подразумевается сокрытие полей внутри объекта с целью защиты данных от внешнего, бесконтрольного изменения со стороны других объектов. Доступ к данным (полям) предоставляется посредством публичных методов (геттеров/сеттеров). Это защитный барьер позволяет хранить информацию в безопасности внутри объекта.
- Наследование. Это особая функциональность в объектно-ориентированных языках программирования, которая позволяет описывать новые классы на основе уже существующих. При этом поля и методы класса-предка становятся доступны и классам-наследникам. Данная фича делает классы более чистыми и понятным за счет устранения дублирования программного кода.
- Полиморфизм. Данный принцип позволяет программистам использовать одни и те же термины для описания различного поведения, зависящего от контекста. Одной из форм полиморфизма в Java является переопределение метода, когда различные формы поведения определяются объектом из которого данный метод был вызван. Другой формой полиморфизма является перегрузка метода, когда его поведение определяется набором передаваемых в метод аргументов.
Концепции ООП в Java позволяют программистам создавать компоненты, которые можно переиспользовать в различных частях программы не подвергая данные опасности.
Основная цель использования данной концепции — это уменьшение сложности компонентов программы за счет скрытия от программиста, использующего эти компоненты, ненужных ему подробностей. Это позволяет реализовать более сложную логику поверх предоставленной абстракции, не вдаваясь в подробности ее реализации.
Приготовление кофе с помощью кофемашины является хорошим примером абстракции. Все, что нам надо знать, что бы ей пользоваться: как налить воды, засыпать кофейные зерна, включить и выбрать вид кофе, который хотим получить. А, как машина будет варить кофе — нам знать не нужно.
В данном примере кофемашина представляет собой абстракцию, которая от нас скрывает все подробности варки кофе. Нам лишь остается просто взаимодействовать с простым интерфейсом, который не требует от нас каких-либо знаний о внутренней реализации машины.
Этот же подход можно использовать и в объектно-ориентированных языках программирования, таких как Java.
Инкапсуляция позволяет нам пользоваться возможностями класса без создания угрозы безопасности данных за счет ограничения прямого доступа к его полям. Также она позволяет изменять код классов не создавая проблем их пользователям (другим классам). В Java данный принцип достигается за счет использования ключевого слова private .
Наследование — еще одна важная концепция ООП, которая позволяет сэкономить время на написании кода. Возможности наследования раскрываются в том, что новому классу передаются свойства и методы уже описанного ранее класса. Класс, который наследуется называется дочерним (или подклассом). Класс, от которого наследуется новый класс — называется родительским, предком и т. д. В языке программирования Java используется ключевое слово extends для того, чтобы указать на класс-предок.
Полиморфизм предоставляет возможность единообразно обрабатывать объекты с различной реализацией при условии наличия у них общего интерфейса или класса. По-простому: способность вызывать нужные методы у объектов, имеющие разные типы (но находящиеся в одной иерархии). При этом происходит автоматический выбор нужного метода в зависимости от типа объекта.
Рассмотрим примеры полиморфизма в Java: переопределение и перегрузка методов.
В случае с переопределением метода, дочерний класс, используя концепцию полиморфизма, может изменить (переопределить) поведение метода родительского класса. Это позволяет программисту по разному использовать один и тот же метод, определяя поведение из контекста вызова (вызывается метод из класса предка или класса наследника).
В случае же с перегрузкой, метод может проявлять различное поведение в зависимости от того, какие аргументы он принимает. В данном случае контекст вызова определяется набором параметров метода.