JavaRush/Java блог/Java Developer/Отношения между классами. Наследование, композиция и агре...

Senior Java-разработчик в CodeGym

13.08.2026
284731просмотров
228комментариев

Отношения между классами. Наследование, композиция и агрегирование

участников

Между классами в Java есть три основных отношения. Наследование это связь «является» (IS A): потомок наследует поля и методы родителя, например Truck extends Car. Композиция и агрегирование это связь «является частью» (HAS A): объект содержит другие объекты. Они различаются строгостью: при композиции часть принадлежит только одному целому (двигатель у машины), при агрегировании часть может входить в несколько целых (пассажиры в машине). Привет! Сегодня мы подробно рассмотрим еще один принцип объектно-ориентированного программирования (ООП), наследование. Заодно изучим другие типы отношений между классами, композицию и агрегирование.

Кратко

Между классами есть три основных отношения: наследование, композиция и агрегирование.
Наследование это связь «является» (IS A): потомок наследует поля и методы родителя (например, Truck extends Car).
Главная выгода наследования это повторное использование кода: общее выносят в родителя.
Композиция и агрегирование это связь «является частью» (HAS A): объект содержит другие объекты.
Композиция это строгая связь: часть не может принадлежать другому объекту (двигатель у машины).
Агрегирование это свободная связь: объект может входить в несколько других (пассажиры, студент в кружках).

Эта тема не будет сложной: ты уже много раз сталкивался с наследованием и его примерами в прошлых лекциях. Сегодня главным будет закрепить твои знания, подробнее рассмотреть механизм наследования и еще раз пробежаться по примерам :) Итак, поехали!

Отношения между классами: наследование, композиция и агрегирование

Наследование в Java и его преимущества

Как ты наверняка помнишь, наследование (inheritance) это механизм, который позволяет описать новый класс на основе существующего (родительского). При этом свойства и функциональность родительского класса заимствуются новым классом. Давай вспомним пример наследования из предыдущих лекций:

public class Car {

   private String model;
   private int maxSpeed;
   private int yearOfManufacture;

   public Car(String model, int maxSpeed, int yearOfManufacture) {
       this.model = model;
       this.maxSpeed = maxSpeed;
       this.yearOfManufacture = yearOfManufacture;
   }


public void gas() {
       //...газ
   }

public void brake() {
       //...тормоз
   }
}


public class Truck extends Car {

   public Truck(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}



public class Sedan extends Car {
   public Sedan(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

Есть некая программа, в рамках которой мы работаем с различными типами автомобилей. Даже если ты не автолюбитель, наверняка знаешь, что типов этих самых автомобилей на свете великое множество :) Поэтому общие свойства автомобилей выделяем в общий класс-родитель, Car. А что общего у всех автомобилей вне зависимости от типа? У любой машины есть год выпуска, название модели и максимальная скорость. Эти свойства выносим в поля model, maxSpeed, yearOfManufacture. Что касается поведения, любая машина может газовать и тормозить :) Это поведение мы определяем в методах gas() и brake(). Какие выгоды это нам дает? Прежде всего, сокращение объема кода. Конечно, можем обойтись и без родительского класса. Но поскольку каждая машина должна уметь газовать и тормозить, нам придется создавать методы gas() и brake() в классе Truck, в классе Sedan, в классе F1Car, в классе Sportcar и во всех остальных классах машин. Представь, сколько лишнего кода мы при этом напишем. Не забывай и о полях model, maxSpeed и yearOfManufacture: если откажемся от родительского класса, будем создавать их в каждом из классов-машин! Без родительского класса общие поля и методы пришлось бы дублировать в каждом классе

Без родительского класса общие поля и методы пришлось бы дублировать в каждом классе

Когда у нас наберется пара десятков классов-машин, объем повторяющегося кода станет действительно серьезным. Вынесение общих полей и методов (еще говорят «состояния» и «поведения») в класс-родитель позволит нам сэкономить кучу времени и места. Если же у какого-то типа есть свойства или методы, уникальные только для него и отсутствующие у других типов машин, не беда. Их всегда можно создать в классе-потомке, отдельно от всех остальных.

public class F1Car extends Car {

   public void pitStop() {

       //...пит-стоп делают только гоночные автомобили
   }

   public static void main(String[] args) {

       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

Возьмем случай с гоночными машинами Формулы-1. У них, в отличие от «сородичей», есть уникальное поведение: время от времени они заезжают на пит-стоп. Нам это не мешает. Общее поведение мы уже описали в родительском классе Car, а специфическое поведение классов-потомков можем добавить внутри классов. Уникальное поведение потомка (пит-стоп у F1Car) добавляют в сам класс-потомок

Уникальное поведение потомка (пит-стоп у F1Car) добавляют в сам класс-потомок

Это касается и полей: если у дочернего класса есть уникальные свойства, спокойно объявляем эти поля внутри него и не переживаем :) Возможность повторного использования кода это главное преимущество наследования. Для программиста очень важно не писать лишний объем кода. Ты не раз столкнешься с этим в работе. Как именно вызывается конструктор родителя через super(), подробно разобрано в статье Конструкторы базовых классов. Пожалуйста, запомни еще одну крайне важную вещь: в Java нет множественного наследования. Каждый класс наследуется только от одного класса. О причинах этого подробнее поговорим в будущих лекциях, пока просто запомни. Этим Java, кстати, отличается от некоторых других ООП-языков. Например, в С++ множественное наследование есть. С наследованием все более-менее ясно, идем дальше.

Композиция и агрегирование

Классы и объекты могут быть связаны друг с другом. Наследование описывает связь «является» (или по-английски «IS A»). Лев является Животным. Такое отношение легко выразить с помощью наследования, где Animal будет родительским классом, а Lion потомком. Однако не все связи отношения в мире описываются таким образом. К примеру, клавиатура определенно как-то связана с компьютером, но она не является компьютером. Руки как-то связаны с человеком, но они не являются человеком. В этих случаях в его основе лежит другой тип отношения: не «является», а «является частью» («HAS A»). Рука не является человеком, но является частью человека. Клавиатура не является компьютером, но является частью компьютера. Отношения HAS A можно описать в коде, используя механизмы композиции и агрегирования. Разница между ними заключается в «строгости» этих связей. Приведем простой пример: У нас есть наш Car, машина. У каждой машины есть двигатель. Кроме того, у каждой машины есть пассажиры внутри. В чем же принципиальная разница между полями Engine engine и Passenger [] passengers? Если у машины внутри сидит пассажир А, это не значит, что в ней не могут находиться пассажиры B и C. Одна машина может соответствовать нескольким пассажирам. Кроме того, если всех пассажиров высадить из машины, она продолжит спокойно функционировать. Связь между классом Car и массивом пассажиров Passenger [] passengers менее строгая. Она называется агрегацией. Есть неплохая статья на эту тему: Отношения между классами (объектами). В ней приведен еще один хороший пример агрегации. Допустим, у нас есть класс Student, обозначающий студента, и класс StudentsGroup (группа студентов). Студент может входить и в клуб любителей физики, и в студенческий фан-клуб «Звездных войн» или команду КВН. Композиция это более строгий тип связи. При использовании композиции объект не только является частью какого-то объекта, но и не может принадлежать другому объекту того же типа. Самый простой пример это двигатель автомобиля. Двигатель является частью автомобиля, но не может быть частью другого автомобиля. Как видишь, их связь гораздо более строгая, чем у Car и Passengers. Композиция это строгая связь часть-целое, агрегирование более свободная

Композиция это строгая связь часть-целое, агрегирование более свободная

Все три отношения между классами удобно свести в таблицу:

Отношение	Тип связи	Строгость	Пример
Наследование	«является» (IS A)	потомок это разновидность родителя	`Truck` это `Car`; `Lion` это `Animal`
Композиция	«является частью» (HAS A)	строгая: часть принадлежит только одному целому	двигатель у машины
Агрегирование	«является частью» (HAS A)	свободная: часть может входить в несколько целых	пассажиры в машине; студент в кружках

Больше о наследовании можно почитать в документации Oracle (Inheritance).

Вопросы и ответы

Какие бывают отношения между классами в Java?

Три основных: наследование (связь «является», IS A), композиция и агрегирование (обе связь «является частью», HAS A). Композиция и агрегирование различаются строгостью.

Что такое наследование в Java?

Это механизм, позволяющий описать новый класс на основе существующего (родительского), заимствуя его поля и методы. Например, Truck extends Car. Главная выгода это повторное использование кода.

Чем композиция отличается от агрегирования?

И то, и другое это связь «является частью» (HAS A). При композиции часть принадлежит только одному объекту и не может быть частью другого (двигатель у машины). При агрегировании связь свободнее: объект может входить в несколько других (пассажиры, студент в кружках).

Что такое связь IS A и HAS A?

IS A («является») это наследование: потомок это разновидность родителя (лев это животное). HAS A («является частью») это композиция или агрегирование: один объект содержит другой (у машины есть двигатель).

Есть ли в Java множественное наследование?

Нет. Каждый класс наследуется только от одного класса. В этом Java отличается, например, от C++, где множественное наследование есть.

Когда использовать наследование, а когда композицию?

Наследование, когда один класс это разновидность другого (IS A). Композицию или агрегирование, когда один объект содержит другой как часть (HAS A), например у машины есть двигатель и пассажиры.

Василий Малик

Senior Java-разработчик в CodeGym

Василий начал программировать еще в школе, но считал это занятие довольно скучным. Поэтому получил образование по электротехнике и ... [Читать полную биографию]

Комментарии (228)

популярные
новые
старые

Для того, чтобы оставить комментарий Вы должны авторизоваться

Grigoryvvv

Уровень 28

Expert

19 июля, 20:38

19.07.2026 / 18 уровень - лекция уже была на 18 уровне 08.08.2026 / 21 уровень - повторил

Rei

Уровень 32

17 февраля, 13:30

Если в коде:

class Car {
    private Engine engine = new Engine();
}

→ композиция. Если:

Engine engine = new Engine();
Car car = new Car(engine);

→ агрегация. То есть всё зависит от того, как ты строишь модель.

Семен

Уровень 28

30 июня, 09:50

Спасибо! Вы описали всю лекцию гораздо понятнее.

Алексей Тимошенко

Уровень 45

3 декабря 2025, 09:15

Статья написана непонятно о чем. Предположу, что речь шла просто о полях класса, в которых находятся объекты других классов. Через эти поля, мы получаем доступ к их функционалу: не нужно писать такой же код у себя в классе, просто через поле (чужой объект в нем) вызываем "чужие" методы. Притом, агрегирование - это когда мы получаем объект, как аргумент при вызове нашего конструктора (то есть, извне). Если же мы создаем чужой объект внутри нашего касса (через "new" в консрукторе или просто при объявлении переменной), то это композиция. Это всё, что нужно было сказать в статье, но сказано было всё, кроме этого. Как так? :) И всё таки, спасибо автору статьи за то, что помог вспомнить материал!

Riga Android Developer

5 мая 2025, 20:41

Вот что автор пытался донести) Агрегация — отношение когда один объект является частью другого. Например Студент входит в Группу любителей физики. Композиция — еще более «жесткое отношение, когда объект не только является частью другого объекта, но и вообще не может принадлежат еще кому-то. Например Машина и Двигатель. Хотя двигатель может быть и без машины, но он вряд ли сможет быть в двух или трех машинах одновременно. В отличии от студента, который может входить и в другие группы тоже. Такие описания всегда несколько условны, но тем не менее

+11

Cryptosin Crypto Magnat

15 февраля 2025, 15:24

Композиция и агрегирование в Java Композиция и агрегирование — это два типа отношений "has-a" (имеет) между классами в объектно-ориентированном программировании. Оба они представляют собой отношения, в которых один класс содержит ссылки на объекты другого класса. Однако между ними есть важные различия. 1. Композиция (Composition) Композиция — это жесткая форма отношения "целое-часть", при которой часть (компонент) не может существовать без своего контейнера (основного объекта). Если основной объект уничтожается, уничтожаются и его компоненты. Ключевые особенности композиции ✅ Жесткая связь между объектами. ✅ Часть не может существовать без целого. ✅ Объект-компонент создается и управляется объектом-контейнером. ✅ Уничтожение контейнера ведет к уничтожению всех его компонентов.

class Engine {
    private String type;

    public Engine(String type) {
        this.type = type;
    }

    public void start() {
        System.out.println("Engine " + type + " is starting...");
    }
}

class Car {
    private final Engine engine; // Композиция: двигатель создается внутри машины

    public Car() {
        this.engine = new Engine("V8"); // Создание компонента внутри контейнера
    }

    public void startCar() {
        engine.start(); // Машина управляет жизненным циклом двигателя
        System.out.println("Car is running...");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.startCar();
        // При удалении объекта Car, объект Engine тоже удаляется
    }
}

🔹 Engine не может существовать без Car. Двигатель создается внутри Car и уничтожается вместе с ним.

+71

Cryptosin Crypto Magnat

15 февраля 2025, 15:25

2. Агрегирование (Aggregation) Агрегирование — это более слабая форма связи "целое-часть", при которой часть (компонент) может существовать независимо от контейнера. В этом случае контейнер просто ссылается на объект-компонент, но не управляет его жизненным циклом. Ключевые особенности агрегирования ✅ Слабая связь между объектами. ✅ Часть может существовать без целого. ✅ Объект-компонент передается в контейнер извне. ✅ Уничтожение контейнера не ведет к уничтожению части. Пример агрегирования:

class Engine {
    private String type;

    public Engine(String type) {
        this.type = type;
    }

    public void start() {
        System.out.println("Engine " + type + " is starting...");
    }
}

class Car {
    private Engine engine; // Агрегирование: объект передается в конструктор

    public Car(Engine engine) {
        this.engine = engine; // Engine передается извне
    }

    public void startCar() {
        engine.start();
        System.out.println("Car is running...");
    }
}

public class Main {
    public static void main(String[] args) {
        Engine engine = new Engine("V8"); // Двигатель создается независимо от Car
        Car car = new Car(engine); // Car использует уже существующий объект Engine
        car.startCar();

        // Если удалить объект Car, Engine продолжит существовать
    }
}

🔹 Engine создается отдельно и передается в Car. Если удалить Car, Engine может использоваться в другом контексте.

+53

Cryptosin Crypto Magnat

15 февраля 2025, 15:26

3. Главное различие Фактор Композиция Агрегирование Связь Жесткая (strong) Слабая (weak) Жизненный цикл Зависят друг от друга Объект-компонент существует независимо Передача объекта Создается внутри класса Передается в конструктор извне Удаление контейнера Удаляет все компоненты Компоненты остаются в памяти 4. Когда использовать? Используйте композицию, если объект-компонент не должен существовать без основного объекта. Например, сердце и человек. Используйте агрегирование, если объект-компонент может существовать отдельно и использоваться в других объектах. Например, студенты и университет.

+26

Cryptosin Crypto Magnat

15 февраля 2025, 15:26

5. Пример с университетом (Агрегирование)

import java.util.ArrayList;
import java.util.List;

class Student {
    private String name;
    public Student(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}
🔹 Студенты могут существовать отдельно от университета, поэтому здесь используется агрегирование.


class University {
    private List<Student> students; // Агрегирование: список студентов
    public University() {
        students = new ArrayList<>();
    }
    public void addStudent(Student student) {
        students.add(student);
    }
    public void showStudents() {
        for (Student student : students) {
            System.out.println("Student: " + student.getName());
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Student s1 = new Student("Alice");
        Student s2 = new Student("Bob");

        University university = new University();
        university.addStudent(s1);
        university.addStudent(s2);
        university.showStudents();
        // Если удалить university, студенты останутся в памяти
    }
}

+15

Cryptosin Crypto Magnat

15 февраля 2025, 15:27

6. Пример с человеком и сердцем (Композиция)

class Heart {
    public void beat() {
        System.out.println("Heart is beating...");
    }
}

class Human {
    private final Heart heart; // Композиция: сердце создается внутри Human
    public Human() {
        this.heart = new Heart();
    }

    public void live() {
        heart.beat();
        System.out.println("Human is alive.");
    }
}

public class Main {
    public static void main(String[] args) {
        Human human = new Human();
        human.live();
        // При удалении human, сердце тоже исчезает
    }
}

🔹 Сердце не может существовать без человека, поэтому здесь используется композиция. Вывод 🔹 Композиция → Жесткая зависимость, уничтожение контейнера ведет к уничтожению частей. 🔹 Агрегирование → Слабая зависимость, части могут существовать отдельно. Выбор между композицией и агрегированием зависит от логики приложения. Если компонент должен существовать только в составе другого объекта → используйте композицию. Если объект-компонент может использоваться в разных местах или существовать отдельно → используйте агрегирование. 🚀

+41

Илья

Уровень 30

5 мая 2025, 07:35

Спасибо! Написано понятнее, чем статья)

Aura

Уровень 23

11 июля 2025, 14:51

Сотни поцелуев тебе

Алексей Тимошенко

Уровень 45

3 декабря 2025, 08:58

:) Человек пользуется нейросетью. Он не пишетсвои посты сам. Только копирует и вставлет текст. Спасибо нейросетям. С другой стороны, он это сделал и без него не было бы и такого. Так что, я тоже присоединяюсь к благодарности. Спасибо доброму пользователю нейросетей!

Ilya Klimchev Backend Developer

30 января 2025, 19:12

Насколько я знаю, JVM никак не реализует ограничения композиции. Т.е. со стороны двигателя никак нельзя ограничить, сколько машин на него сошлётся при создании. Это означает, что композиция как термин - информационный мусор

Yasin Akhmadov

Уровень 1

19 февраля 2025, 09:05

В принципе да. Эта тема используется нами на подсознательном уровне. Странно как-то придумывать жесткие определения. Хотя тема полезная.

Denis

Уровень 33

7 марта 2025, 07:53

Композиция - это не мусор, а теория архитектуры. Я на практике не смог найти этому применение. JVM не должна ограничивать Композицию. Точнее JVM не знает о её существовании различных теорий архитектур и паттернов. На практике достаточно не делать Геттеры и Сеттеры на двигатель автомобиля, что бы не дать возможность получить ссылку на двигатель и вставить её в другой автомобиль. Еще пример.....тело человека. В теле человека нет интерфейса доступа к сердцу. Сердце - это внутренний орган о котором внешний мир не знает. Сердце принадлежит системе внутренних органов и доступ к интерфейсу сердца есть тоже только у внутренних органов. Как сердце работает и кто управляет его работой - это сокрытие реализации. Получается ссылка на сердце хранится только внутри человека и если человека удалить, то GC удалит все остальные внутренний органы, т.к. ссылки на них больше ни где нет. Как то так.

Ilya Klimchev Backend Developer

7 марта 2025, 12:08

опять же, геттеры и сеттеры работают не со стороны двигателя, а со стороны машины. Сердце может быть пересажено, но это не суть. Единственный способ частичной реализации композиции - вложенный нестатический класс, но я ни в одном проекте такого порно не видел. А сокращение фразы "один объект может содержать ссылку на другой объект в качестве переменной" до слова "агрегирование" выглядит просто как очередная попытка сократить количество ~~кода~~ слов, но в результате выходит нагромождение бессмысленных определений

Евгений Пикин

Уровень 1

24 декабря 2024, 07:21

не согласен с двигателями и пассажирами. Как пассажир одновременно не может находиться в разных автомобилях, так и двигатель можно переставить в другой автомобиль. Сам лично ставил контрактник)

IronMan57

Уровень 28

27 января 2025, 16:06

Поддерживаю. Двигатель и автомобиль скорее относятся к примеру агрегации, т.к. его можно переставить (переподчинить другому объекту), а кроме того двигатель может существовать сам по себе. Хороший, по-моему, пример композиции увидел на стороннем ресурсе - здание и комнаты в нём. Конкретная комната всегда принадлежит какому-то зданию и не может существовать сама по себе. Снесли дом - пропали все комнаты, которые в нём были. Здание, при этом, может быть и без комнат внутри - "коробка" без внутренних перегородок.

Denis

Уровень 33

7 марта 2025, 08:01

Нет. Сейчас пассажир (ссылка на него) хранится в автомобиле, но при этом его ссылка хранится в метриках рождения его ребенка. Человек одновременно и пассажир и член семьи, и родитель, и чей-то ребенок и т.д. Здесь смысл в том, что человек как самостоятельная сущность и может одновременно исполнять много ролей. Его ссылка одновременно может быть в разных местах. Да, двигатель можно переставить в другой автомобиль, но его прямое назначение и функционал заключается не в том что бы его переставляли. Что бы переставить двигатель, нужно раскрытие реализации автомобиля. Если в вашей приложении это предусмотрено, то пожалуйста - переставляйте.

Denis

Уровень 33

7 марта 2025, 08:05

Двигатель не может быть связан агрегацией с автомобилем, потому что сам по себе двигатель на хер ни кому не нужен. Вы же не покупаете в место автомобиля двигатель? Вы покупаете автомобиль. Сам по себе двигатель бесполезен. Все зависит от приложения которое вы пишите. Если это магазин запчастей, то Да - двигатель связь агрегация.

Hofman Hagl

Уровень 32

22 декабря 2024, 12:35

Я дико извиняюсь, но даже чат - GPT лучше обьясняет, что такое композиция и агрегирование

Андрей

Уровень 14

27 октября 2024, 07:37

плохое изложение. непонятно, "что", и непонятно, "зачем". вместе с тем, почитав другие источники и допустив, что я понял, о чём речь, я изложил бы кратко иначе: - наследование - это создание нового класса, по сути "скопипастив" класс-родитель, т.е. используя его, как шаблон, и добавив к нему всё, что нам ещё нужно в создаваемом классе. - композиция - это использование другого класса в качестве поля (свойства) в создаваемом. преимущества: мы можем управлять видимостью этого поля - например, скрыть его для создаваемых объектов, если им не нужно обращаться напрямую к нему; а также при изменении кода исходного класса (к примеру, в его конструктор добавился параметр, либо тип одного из полей изменился) необходимо вносить изменения только в код создаваемого класса, а в случае наследования пришлось бы переписывать и все классы-потомки создаваемого. причём, вообще говоря, ничто не мешает заменить в случае одиночного поля композицию наследованием, в тексте есть прекрасный пример, который не получил развитие: класс "компьютер" можно создать и наследованием от класса "клавиатура", нужно только добавить к нему поля для всего остального - процессор, память, видеокарта, монитор, диски, порты и т.п. (даже лучше в виде массивов - современные компы могут иметь каждого компонента по несколько штук), и это будет вполне рабочий класс (этакая почти "каша из топора"), но разумнее создать новый класс (либо унаследовать от более общего класса, какие-либо "ЭлектронныеУстройства", "ВычТехника"), в котором в качестве одного из полей добавить "клавиатура" (или "клавиатура[]"). Тут и действует правило: класс "А" принадлежит классу "Б" или же класс "Б" является расширением класса "А"? если вы считаете, что компьютер произошёл от клавиатуры, то - наследование. на мой взгляд, даже ответ, который даёт старый chatGPT на вопрос "что такое композиция в java", более понятен, чем эта лекция. (хотел его тут процитировать, но превысил допустимое количество символов, так что проверьте сами)

Даниил Малофеев

Уровень 1

14 октября 2024, 05:43

Статья-вода. Если про наследование еще все понятно, но про агрегацию и композицию все размыто...

Отношения между классами. Наследование, композиция и агрегирование

Кратко

Наследование в Java и его преимущества

Композиция и агрегирование

Читайте также

Вопросы и ответы

Какие бывают отношения между классами в Java?

Что такое наследование в Java?

Чем композиция отличается от агрегирования?

Что такое связь IS A и HAS A?

Есть ли в Java множественное наследование?

Когда использовать наследование, а когда композицию?