> For the complete documentation index, see [llms.txt](https://frogs-organization-2.gitbook.io/oop.-sbornik./llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://frogs-organization-2.gitbook.io/oop.-sbornik./12.-osnovnye-ponyatiya-oop-inkapsulyaciya-nasledovanie-polimorfizm..md).

# 12. Основные понятия ООП: инкапсуляция, наследование, полиморфизм.

## Основные понятия ООП

### **Инкапсуляция**

1. **Определение**
   * Инкапсуляция — это процесс сокрытия деталей реализации объекта и предоставления интерфейса для взаимодействия с ним.
2. **Пример**

   * Объекты содержат приватные данные и публичные методы для работы с этими данными.

   ```cpp
   class BankAccount {
   private:
       double balance;
   public:
       void deposit(double amount) {
           balance += amount;
       }
       double getBalance() const {
           return balance;
       }
   };
   ```

### **Наследование**

1. **Определение**
   * Наследование позволяет создавать новый класс на основе существующего, унаследуя его свойства и методы.
2. **Пример**

   * Создание класса `SavingsAccount`, который наследует от `BankAccount`.

   ```cpp
   class BankAccount {
   protected:
       double balance;
   public:
       void deposit(double amount) {
           balance += amount;
       }
       double getBalance() const {
           return balance;
       }
   };

   class SavingsAccount : public BankAccount {
   private:
       double interestRate;
   public:
       void applyInterest() {
           balance += balance * interestRate;
       }
   };
   ```

### **Полиморфизм**

1. **Определение**
   * Полиморфизм позволяет объектам разного типа быть обработанными через один интерфейс.
2. **Пример**

   * Использование виртуальных функций и указателей на базовый класс для вызова переопределенных методов производных классов.

   ```cpp
   class Shape {
   public:
       virtual void draw() const {
           std::cout << "Drawing Shape" << std::endl;
       }
   };

   class Circle : public Shape {
   public:
       void draw() const override {
           std::cout << "Drawing Circle" << std::endl;
       }
   };

   Shape* shape = new Circle();
   shape->draw();  // Вывод: Drawing Circle
   ```

## Понятие объекта

1. **Определение**
   * Объект — это экземпляр класса, который содержит данные и методы для работы с этими данными.
2. **Пример**

   * Создание объекта класса `BankAccount`.

   ```cpp
   BankAccount myAccount;
   myAccount.deposit(100.0);
   std::cout << myAccount.getBalance();  // Вывод: 100.0
   ```

### Категории объектов

1. **Активные объекты**
   * Объекты, которые могут инициировать действия самостоятельно, например, потоки или процессы.
2. **Пассивные объекты**
   * Объекты, которые выполняют действия только по запросу, например, обычные данные или структуры.
3. **Абстрактные объекты**
   * Объекты, которые не имеют конкретной реализации и предназначены для предоставления интерфейса, например, абстрактные классы и интерфейсы.

### Отношения между объектами

1. **Ассоциация**

   * Простое отношение между объектами, которое показывает, что один объект знает о другом.

   ```cpp
   class Person {
   private:
       std::string name;
   public:
       Person(std::string n) : name(n) {}
       std::string getName() const { return name; }
   };

   class Car {
   private:
       Person owner;
   public:
       Car(Person p) : owner(p) {}
       std::string getOwnerName() const { return owner.getName(); }
   };
   ```
2. **Агрегация**

   * "Has-a" отношение, где один объект является частью другого, но может существовать отдельно.

   ```cpp
   class Engine {
   public:
       void start() {
           std::cout << "Engine started" << std::endl;
       }
   };

   class Car {
   private:
       Engine engine;
   public:
       void start() {
           engine.start();
           std::cout << "Car started" << std::endl;
       }
   };
   ```
3. **Композиция**

   * Сильная форма агрегации, где жизнь одного объекта зависит от другого.

   ```cpp
   class Engine {
   public:
       void start() {
           std::cout << "Engine started" << std::endl;
       }
   };

   class Car {
   private:
       Engine* engine;
   public:
       Car() {
           engine = new Engine();
       }
       ~Car() {
           delete engine;
       }
       void start() {
           engine->start();
           std::cout << "Car started" << std::endl;
       }
   };
   ```
4. **Наследование**
   * Отношение "is-a", где один класс является расширением другого.

## Понятие класса

1. **Определение**
   * Класс — это шаблон для создания объектов, который определяет их данные и методы.
2. **Пример**

   * Определение класса `BankAccount`.

   ```cpp
   class BankAccount {
   private:
       double balance;
   public:
       void deposit(double amount) {
           balance += amount;
       }
       double getBalance() const {
           return balance;
       }
   };
   ```

### Отношения между классами

1. **Наследование**
   * Класс может наследовать свойства и методы другого класса.
2. **Агрегация и композиция**
   * Классы могут содержать объекты других классов в качестве своих членов.
3. **Ассоциация**
   * Классы могут иметь ссылки или указатели на объекты других классов.

## Понятие домена

1. **Определение**
   * Домен — это область предметной области, которую охватывает программное обеспечение или система.
2. **Пример**

   * В банковской системе домен может включать учетные записи, транзакции, клиентов и т.д.

   ```cpp
   class Account {
   private:
       std::string accountNumber;
       double balance;
   public:
       Account(std::string number, double initialBalance)
           : accountNumber(number), balance(initialBalance) {}
       // Методы для управления учетной записью
   };
   ```