Наследование, композиция, агрегация
Нередко случается, что решив разобраться с какой-то новой темой, понятием, инструментом программирования, я читаю одну за другой статьи на различных сайтах в интернете. И, если тема сложная, то эти статьи могут не на шаг не приблизить меня к понимаю. И вдруг встречается статья, которая моментально дает озарение и все паззлы складываются воедино. Трудно определить, что отличает такую статью от других. Правильно подобранные слова, оптимальная логика изложения или же просто более релевантный пример. Я не претендую на то, что моя статься окажется новым словом в C# или же лучшей обучающей статьей. Но, возможно для кого-то она станет именно той, которая позволит разобраться, запомнить и начать правильно применять те понятия, о которых пойдет речь.
В объектно-ориентированных языках программирования существует три способа организации взаимодействия между классами. Наследование — это когда класс-наследник имеет все поля и методы родительского класса, и, как правило, добавляет какой-то новый функционал или/и поля. Наследование описывается словом «является». Легковой автомобиль является автомобилем. Вполне естественно, если он будет его наследником.
Ассоциация – это когда один класс включает в себя другой класс в качестве одного из полей. Ассоциация описывается словом «имеет». Автомобиль имеет двигатель. Вполне естественно, что он не будет являться наследником двигателя (хотя такая архитектура тоже возможна в некоторых ситуациях).
Выделяют два частных случая ассоциации: композицию и агрегацию.
Композиция – это когда двигатель не существует отдельно от автомобиля. Он создается при создании автомобиля и полностью управляется автомобилем. В типичном примере, экземпляр двигателя будет создаваться в конструкторе автомобиля.
Агрегация – это когда экземпляр двигателя создается где-то в другом месте кода, и передается в конструктор автомобиля в качестве параметра.
Хотя ведутся дискуссии о преимуществах того или иного способа организации взаимодействия между классами, какого-либо абстрактного правила не существует. Разработчик выбирает тот или иной путь основываясь на элементарной логике (“является” или “имеет”), но также принимает во внимание возможности и ограничения, которые дают и накладывают эти способы. Для того, чтобы увидеть эти возможности и ограничения, я попытался написать пример. Достаточно простой, чтобы код оставался компактным, но и достаточно развитый, чтобы в рамках одной программы можно было применить все три способа. И, главное, я попытался сделать этот пример как можно менее абстрактным – все объекты и экземпляры понятны и осязаемы.
Напишем простенькую игру – танковый бой. Играют два танка. Они поочередно стреляют и проигрывает тот, здоровье которого упало до нуля. В игре будут различные типы снарядов и брони. Для того, чтобы нанести урон необходимо во-первых, попасть по танку противника, во-вторых, пробить его броню. Если броня не пробита, урон не наносится. Логика игры построена на принципе «камень-ножницы-бумага»: то есть броня одного типа хорошо противостоит снарядам определенного типа, но плохо держит другие снаряды. Кроме того, снаряды, которые хорошо пробивают броню, наносят малый «заброневой» урон, и, напротив, наиболее «летальные» снаряды имеют меньше шансов пробить броню.
Создадим простенький класс для пушки. Он будет иметь два приватных поля: калибр и длину ствола. От калибра зависит урон, и, частично, способность к пробитию брони. От длины ствола – точность стрельбы.
Сделаем также конструктор для пушки:
Сделаем метод для получения калибра из других классов:
Помните, что для поражения цели должно произойти две вещи: попадание в цель и пробитие брони? Так вот, пушка будет отвечать за первую из них: попадание. Поэтому делаем булевый метод IsOnTarget, который принимает случайную величину (dice) и возвращает результат: попали или нет:
Целиком класс пушки выглядит следующим образом:
Здесь мы применили агрегацию. Где-то будет создана пушка. Потом к этой пушке будут создаваться снаряды, которые имеют указатель на пушку.
Теперь сделаем разные типы снарядов, которые будут наследовать абстрактный снаряд: фугасный, кумулятивный, подкалиберный. Фугасный наносит самый большой урон, кумулятивный – меньше, подкалиберный – еще меньше. Дочерние классы не имеют полей и вызывают конструктор базового снаряда, передавая ему пушку, и строковый тип. В дочернем классе переопределяется метод GetDamage() – вносятся коэффициенты, которые увеличат или уменьшат урон по сравнению с дефолтным.
Фугасный (дефолтный урон):
Кумулятивный (дефолтный урон х 0.6):
Подкалиберный (дефолтный урон х 0.3):
Обратите внимание, что в переопределенном методе GetDamage вызывается и метод базового класса. То есть, переопределив метод, мы также сохраняем возможность обратиться к дефолтному методу, использовав ключевое слово base).
Итак, для снарядов мы применили и агрегацию (пушка в базовом классе), и наследование.
Создадим теперь броню для танка. Здесь применим только наследование. Любая броня имеет толщину. Поэтому абстрактный класс брони будет иметь поле thickness, и строковое поле type, которое будет определятся при создании дочерних классов.
Броня будет в нашей игре определять пробита они или нет. Поэтому, у нее будет лишь один метод, который будет переопределяться в дочерних, в зависимости от типа брони.
Для того, чтобы конструктор танка остался более-менее компактным, сделаем два вспомогательных приватных метода, которые добавляют три типа брони соответствующей толщины, и наполняют боеукладку 10 снарядами каждого из трех типов:
Теперь конструктор танка выглядит вот таким образом:
Пользовательский интерфейс танка состоит из трех методов: выбрать броню, зарядить пушку, выстрелить.
Как я упомянул в начале, в этом примере я старался максимально уйти от абстрактных понятий, которые нужно все время держать в голове. Поэтому каждый экземпляр снаряда у нас равен физическому снаряду, который положили в боеукладку перед боем. Следовательно, снаряды могут закончится в самый неподходящий момент!
Этот интерфейс требует реализации метода Clone(). Вот она:
Теперь все супер реалистично: при выстреле генерируется dice, пушка рассчитывает попадание своим методом IsOnTarget, и, если попадание есть, то метод Shoot вернет экземпляр снаряда, а если промах – то вернет null.
Последний метод танка – его поведение при попадании вражеского снаряда:
Все готово. Остается только написать консольный (или неконсольный) вывод, в котором будет обеспечен пользовательский интерфейс и в цикле реализованы поочередные ходы игроков.
Подведем итоги. Мы написали программу, в которой использовали наследование, композицию и агрегацию, надеюсь, поняли и запомнили различия. Активно задействовали возможности полиморфизма, во-первых, когда любые экземпляры дочерних классов можно сложить в список, имеющий тип данных родительского, а во-вторых, создавая методы, которые принимают в качестве параметра родительский экземпляр, но внутри которых вызываются методы дочернего. По ходу текста я упоминал возможные альтернативные реализации – замену наследования на агрегацию, и, универсального рецепта тут нет. В нашей реализации наследование дало нам легкость добавления новых деталей в игру. Например, чтобы добавить новый тип снаряда нам нужно лишь:
Ниже – приведена диаграмма наших классов.
В финальном коде игры все «магические числа», которые использовались в тексте, вынесены в отдельный статический класс Config. К публичным полям статического класса мы можем обратиться из любого фрагмента нашего кода и его экземпляр не нужно (и невозможно) создавать. Вот так он выглядит:
Что такое ассоциация и агрегация в Java?
Когда вы пишете программу на Java, если вы хотите связать один класс с другим, используя его ссылку, вы можете использовать Aggregation в Java. Итак, давайте узнаем, как работает агрегация в Java.
Что такое агрегация?
Прежде чем понять, что такое агрегация, давайте узнаем об ассоциации в Java. Ассоциация называется отношением между двумя отдельными классами, которое устанавливается через их Объекты.
Это может быть один к одному, один ко многим, многие к одному, многие ко многим. Давайте разберемся в ассоциациях на примерах.
Вывод: Виан учится в классе Java.
Vian is a student of Java Class.
Теперь давайте посмотрим, что такое агрегация в Java.
Агрегация на самом деле является особой формой ассоциации. Это означает, что это упоминается как отношения между двумя классами, такими как Ассоциация. Тем не менее, это направленная ассоциация, что означает, что она строго следует односторонней ассоциации. Это представляет отношения HAS-A.
Это рассматривается как более специализированная версия отношений Ассоциации. Класс Aggregate содержит ссылку на другой класс и считается владельцем этого класса. Каждый класс, на который есть ссылка, считается частью класса Aggregate.
Теперь, скажем, например, если класс A содержит ссылку на класс B, а класс B содержит ссылку на класс A, то не может быть определено четкое владение, и это просто отношение ассоциации.
Давайте посмотрим на этот пример:
Теперь у вас может возникнуть вопрос: почему должны использовать эту агрегацию в Java?
Зачем нужна?
Основная причина, по которой вам нужна агрегация, заключается в поддержании возможности повторного использования кода. Например, если вы создаете класс, такой же, как в примере выше, вам необходимо сохранить сведения о сотруднике. И вам не нужно снова и снова использовать один и тот же код, а вместо этого использовать ссылку на класс, пока вы его определяете.
Композиция, агрегация и ассоциация в Java
Изучите свойства и представление композиции, агрегации и ассоциации в Java.
1. введение
Объекты имеют отношения между собой, как в реальной жизни, так и в программировании. Иногда трудно понять или реализовать эти отношения.
В этом уроке мы сосредоточимся на подходе Java к трем иногда легко смешиваемым типам отношений: композиция, агрегация и ассоциация.
2. Состав
В качестве альтернативы, мы часто называем это отношением “имеет-а” (в отличие от отношения “есть-а”, которое является наследованием ).
Например, комната принадлежит зданию, или, другими словами, в здании есть комната. Таким образом, в основном, называем ли мы это “принадлежит” или “имеет”, это только вопрос точки зрения.
Композиция-это сильный вид отношений “имеет-а”, потому что содержащий объект владеет им. Таким образом, жизненные циклы объектов связаны. Это означает, что если мы уничтожим объект-владельца, его члены также будут уничтожены вместе с ним. Например, комната разрушается вместе со зданием в нашем предыдущем примере.
Обратите внимание, что это не означает, что содержащий объект не может существовать без какой-либо из его частей. Например, мы можем снести все стены внутри здания, следовательно, уничтожить комнаты. Но здание все равно будет существовать.
2.1. UML
В UML мы обозначаем композицию следующим символом:
Обратите внимание, что алмаз находится в содержащем его объекте и является основанием линии, а не наконечником стрелы. Для ясности мы тоже часто рисуем наконечник стрелы:
Итак, мы можем использовать эту конструкцию UML для нашего примера здания:
2.2. Исходный код
В Java мы можем смоделировать это с помощью нестатического внутреннего класса:
В качестве альтернативы мы также можем объявить этот класс в теле метода. Не имеет значения, является ли это именованный класс, анонимный класс или лямбда:
Обратите внимание, что очень важно, чтобы наш внутренний класс был нестатическим, поскольку он связывает все свои экземпляры с содержащим классом.
Обычно содержащий объект хочет получить доступ к своим членам. Поэтому мы должны хранить их ссылки:
Обратите внимание, что все внутренние объекты класса хранят неявную ссылку на содержащийся в них объект. В результате нам не нужно хранить его вручную, чтобы получить к нему доступ:
3. Агрегация
Агрегация также является отношением “есть-есть”. Что отличает его от композиции, так это то, что он не предполагает владения. В результате жизненный цикл объектов не привязан: каждый из них может существовать независимо друг от друга.
Например, автомобиль и его колеса. Мы можем снять колеса, и они все еще будут существовать. Мы можем установить другие (уже существующие) колеса или установить их на другой автомобиль, и все будет работать просто отлично.
3.1. UML
Агрегация очень похожа на композицию. Единственное логическое различие заключается в том, что агрегация-это более слабая связь.
Поэтому представления UML также очень похожи. Разница лишь в том, что алмаз пуст:
Тогда для автомобилей и колес мы бы сделали:
3.2. Исходный код
В Java мы можем моделировать агрегацию с помощью простой старой ссылки:
Членом может быть любой тип класса, кроме нестатического внутреннего класса.
В приведенном выше фрагменте кода оба класса имеют свой отдельный исходный файл. Однако мы также можем использовать статический внутренний класс:
Обратите внимание, что Java создаст неявную ссылку только в нестатических внутренних классах. Из-за этого мы должны поддерживать отношения вручную там, где нам это нужно:
4. Ассоциация
Ассоциация означает только то, что объекты “знают” друг друга. Например, мать и ее ребенок.
4.1. UML
В UML мы можем отметить ассоциацию стрелкой:
Если связь двунаправленная, мы можем использовать две стрелки, стрелку с наконечником на обоих концах или линию без наконечников:
Мы можем представить мать и ее ребенка в UML, тогда:
4.2. Исходный код
В Java мы можем моделировать ассоциацию так же, как и агрегацию:
Но подождите, как мы можем определить, означает ли ссылка агрегацию или ассоциацию?
Ну, мы не можем. Разница только логична: является ли один из объектов частью другого или нет.
Кроме того, мы должны поддерживать ссылки вручную на обоих концах, как мы делали с агрегацией:
5. UML Sidenote
Для ясности иногда мы хотим определить мощность отношения на диаграмме UML. Мы можем сделать это, записав его на концах стрелки:
Обратите внимание, что нет смысла писать ноль в качестве мощности, потому что это означает, что нет никакой связи. Единственное исключение-это когда мы хотим использовать диапазон для указания необязательной связи:
Также обратите внимание, что, поскольку в составе есть только один владелец, мы не указываем его на диаграммах.
6. Сложный Пример
Давайте рассмотрим (немного) более сложный пример!
Мы смоделируем университет, в котором есть свои кафедры. На каждой кафедре работают профессора, у которых также есть друзья друг среди друга.
Будут ли кафедры существовать после того, как мы закроем университет? Конечно, нет, поэтому это композиция.
Но профессора все равно будут существовать (надеюсь). Мы должны решить, что более логично: считать ли профессоров частью кафедр или нет. Альтернативно: являются ли они членами департаментов или нет? Да, это так. Следовательно, это агрегация. Кроме того, профессор может работать на нескольких кафедрах.
Отношения между профессорами являются ассоциативными, потому что нет никакого смысла говорить, что профессор является частью другого.
В результате мы можем смоделировать этот пример со следующей диаграммой UML:
И код Java выглядит следующим образом:
7. Заключение
В этой статье мы рассмотрели свойства и представление композиции, агрегации и ассоциации. Мы также видели, как моделировать эти отношения в UML и Java.
Агрегации MongoDB С Использованием Java
Узнайте, что такое агрегации MongoDB и как их применять в Java, используя пример набора данных.
1. Обзор
2. Что Такое Агрегации?
Агрегации используются в MongoDB для анализа данных и получения из них значимой информации|/.
Они обычно выполняются на различных этапах, и этапы образуют конвейер – таким образом, что выходные данные одного этапа передаются в качестве входных данных на следующий этап.
Наиболее часто используемые этапы можно резюмировать следующим образом:
| проект | выбирает только необходимые поля, также может использоваться для вычисления и добавления производных полей в коллекцию | ВЫБИРАТЬ |
| совпадение | фильтрует коллекцию в соответствии с указанными критериями | ГДЕ |
| группа | собирает входные данные вместе в соответствии с указанными критериями (например, количество, сумма), чтобы вернуть документ для каждой отдельной группы | СГРУППИРОВАТЬ ПО |
| сортировать | сортирует результаты в порядке возрастания или убывания данного поля | ЗАКАЗ ПО |
| считать | подсчитывает документы, содержащиеся в коллекции | СЧИТАТЬ |
| предел | ограничивает результат указанным количеством документов, вместо того чтобы возвращать всю коллекцию | ПРЕДЕЛ |
| из | записывает результат в именованную коллекцию; этот этап приемлем только как последний в конвейере | ВЫБЕРИТЕ В НОВОЙ ТАБЛИЦЕ |
То Эквивалент SQL для каждого этапа агрегации приведено выше, чтобы дать нам представление о том, что означает указанная операция в мире SQL.
В ближайшее время мы рассмотрим примеры кода Java для всех этих этапов. Но до этого нам нужна база данных.
3. Настройка базы данных
3.1. Набор данных
Первое и главное требование для изучения всего, что связано с базой данных,-это сам набор данных!
3.2. Импорт в MongoDB
Успешный импорт должен дать нам коллекцию из 250 документов.
4. Примеры агрегирования на Java
Но прежде чем мы это сделаем, нам нужно установить соединение с базой данных:
Во всех следующих примерах мы будем использовать вспомогательный класс Агрегаты , предоставляемый драйвером Java MongoDB .
Для лучшей читабельности наших фрагментов мы можем добавить статический импорт:
4.1. сопоставление и подсчет
Для начала давайте начнем с чего-нибудь простого. Ранее мы отмечали, что набор данных содержит информацию о языках.
Теперь предположим, что мы хотим проверить количество стран в мире, где английский является официальным языком :
Во-первых, мы отфильтровываем коллекцию, чтобы она соответствовала только тем документам, которые содержат английский в поле языки|/. Эти документы можно представить как временную или промежуточную коллекцию, которая станет материалом для нашего следующего этапа, count. Это подсчитывает количество документов на предыдущем этапе.
4.2. сгруппировать (с суммой) и отсортировать
В этом примере наша цель состоит в том, чтобы выяснить географический регион, содержащий максимальное количество стран :
Во-первых, мы собираем количество стран в каждом регионе, накапливая сумму их вхождений в переменную подсчет. Это дает нам промежуточный набор документов, каждый из которых содержит два поля: регион и список стран в нем. Затем мы сортируем его в порядке убывания и извлекаем первый документ, чтобы получить регион с максимальным количеством стран.
4.3. сортировка, ограничение и вывод
Теперь давайте используем сортировку , ограничение и выход для извлечения семи крупнейших стран по площади и записи их в новую коллекцию :
4.4. проект, группа (с макс.), соответствие
5. Заключение
Для дальнейшего чтения, Spring Data MongoDB предоставляет альтернативный способ обработки прогнозов и агрегаций в Java.
Ассоциация, состав и агрегация в Java
ассоциация
Ассоциация — это связь между двумя отдельными классами, которая устанавливается через их Объекты. Ассоциация может быть один-к-одному, один-ко-многим, многие-к-одному, многие-ко-многим.
В объектно-ориентированном программировании объект взаимодействует с другим объектом для использования функциональных возможностей и услуг, предоставляемых этим объектом. Состав и агрегация — это две формы ассоциации.
// Java-программа для иллюстрации
// концепция объединения
private String name;
public String getBankName()
private String name;
public String getEmployeeName()
// Ассоциация между
// классы в основном методе
public static void main (String[] args)
Bank bank = new Bank( «Axis» );
Employee emp = new Employee( «Neha» );
» is employee of » + bank.getBankName());
В приведенном выше примере два отдельных класса Bank и Employee связаны через свои объекты. В банке может быть много сотрудников, так что это отношения один ко многим.
агрегирование
Это особая форма объединения, где:
// Java-программа для иллюстрации
// Концепция агрегации.
Student(String name, int id, String dept)
/ * Класс кафедры содержит список студентов
Объекты. Это связано со студентом
Класс через свой объект (ы). * /
private List students;
Department(String name, List students)
public List getStudents()
/ * Учебный класс содержит список кафедр
Объекты. Это связано с отделом
Класс через его Объект (ы). * /
private List departments;
Institute(String instituteName, List departments)
// подсчитать общее количество студентов всех кафедр
// в данном институте
public int getTotalStudentsInInstitute()
int noOfStudents = 0 ;
for (Department dept : departments)
for (Student s : students)
public static void main (String[] args)
List cse_students = new ArrayList ();
List ee_students = new ArrayList ();
List departments = new ArrayList ();
// создание экземпляра института.
System.out.print( «Total students in institute: » );
Сочинение
Композиция — это ограниченная форма агрегации, в которой две сущности сильно зависят друг от друга.
// Java-программа для иллюстрации
// Концепция композиции
public String title;
public String author;
Book(String title, String author)
// Класс Libary содержит
// список книг.
// ссылка для ссылки на список книг.
private final List books;
Library (List books)
public List getTotalBooksInLibrary()<
public static void main (String[] args)
// Создание класса Objects of Book.
// Создание списка, который содержит
List books = new ArrayList ();
Library library = new Library(books);
List bks = library.getTotalBooksInLibrary();
System.out.println( «Title : » + bk.title + » and «
В приведенном выше примере библиотека может не иметь. книг по тем же или различным предметам. Таким образом, если библиотека будет уничтожена, то все книги в этой конкретной библиотеке будут уничтожены. т.е. книга не может существовать без библиотеки. Вот почему это композиция.
Агрегация против состава
// Java-программа для иллюстрации
// разница между агрегацией
// Сочинение.
// Класс двигателя, который будет
// быть использованным на машине. так «Автомобиль»
// класс будет иметь поле
// Тип двигателя.
System.out.println( «Engine of car has been started » );
// Для машины, чтобы двигаться,
// для этого нужен двигатель.
private final Engine engine; // Сочинение
// частный движок двигателя; // Агрегация
// автомобиль начинает движение при запуске двигателя
System.out.println( «Car is moving » );
public static void main (String[] args)
// создание двигателя путем создания
// экземпляр класса Engine.
Engine engine = new Engine();
// Делаем машину с двигателем.
// так что мы проходим двигатель
// экземпляр в качестве аргумента while
Car car = new Car(engine);
В случае агрегирования, автомобиль также выполняет свои функции через двигатель. но двигатель не всегда является внутренней частью автомобиля. Двигатель можно заменить или даже снять с автомобиля. Вот почему мы делаем поле Тип двигателя не финальным.
Пожалуйста, пишите комментарии, если вы обнаружите что-то неправильное или вы хотите поделиться дополнительной информацией по обсуждаемой выше теме.
