Какие знаешь основные принципы ООП?

Основные принципы объектно-ориентированного программирования (ООП)

Объектно-ориентированное программирование базируется на четырёх фундаментальных принципах, которые обеспечивают гибкость, масштабируемость и поддержку кода. Эти принципы глубоко интегрированы в язык C# и платформу .NET.

1. Инкапсуляция

Инкапсуляция — это механизм сокрытия внутреннего состояния объекта и деталей реализации от внешнего мира, предоставляя контролируемый интерфейс для взаимодействия.

Ключевые аспекты в C#:

• Использование модификаторов доступа: private, protected, internal, public
• Свойства (properties) для контролируемого доступа к полям
• Методы доступа (getters/setters)

public class BankAccount
{
    // Поле инкапсулировано (private)
    private decimal _balance;
    
    // Контролируемый доступ через свойство
    public decimal Balance 
    {
        get { return _balance; }
        private set { _balance = value; }
    }
    
    // Публичный интерфейс для работы с объектом
    public void Deposit(decimal amount)
    {
        if (amount > 0)
            _balance += amount;
    }
    
    public bool Withdraw(decimal amount)
    {
        if (amount > 0 && amount <= _balance)
        {
            _balance -= amount;
            return true;
        }
        return false;
    }
}

2. Наследование

Наследование позволяет создавать новые классы на основе существующих, заимствуя их функциональность и расширяя её.

Особенности в C#:

• Поддержка одиночного наследования классов (от одного базового класса)
• Поддержка множественной реализации интерфейсов
• Ключевые слова: class, :, base, virtual, override, abstract

// Базовый класс
public abstract class Vehicle
{
    public string Make { get; set; }
    public string Model { get; set; }
    
    public virtual void Start()
    {
        Console.WriteLine("Vehicle starting...");
    }
    
    public abstract void DisplayInfo();
}

// Производный класс
public class Car : Vehicle
{
    public int Doors { get; set; }
    
    public override void Start()
    {
        base.Start(); // Вызов метода базового класса
        Console.WriteLine("Car engine running");
    }
    
    public override void DisplayInfo()
    {
        Console.WriteLine($"Car: {Make} {Model}, Doors: {Doors}");
    }
}

3. Полиморфизм

Полиморфизм позволяет объектам разных типов обрабатываться через общий интерфейс, при этом каждый тип может предоставлять свою собственную реализацию.

Виды полиморфизма в C#:

• Параметрический (статический) — через перегрузку методов
• Полиморфизм подтипов (динамический) — через виртуальные методы и переопределение
• Полиморфизм через интерфейсы

public interface IShape
{
    double CalculateArea();
    void Draw();
}

public class Circle : IShape
{
    public double Radius { get; set; }
    
    public double CalculateArea() => Math.PI * Radius * Radius;
    
    public void Draw() => Console.WriteLine("Drawing circle");
}

public class Rectangle : IShape
{
    public double Width { get; set; }
    public double Height { get; set; }
    
    public double CalculateArea() => Width * Height;
    
    public void Draw() => Console.WriteLine("Drawing rectangle");
}

// Использование полиморфизма
public void ProcessShapes(List<IShape> shapes)
{
    foreach (var shape in shapes)
    {
        shape.Draw(); // Вызовется соответствующая реализация
        Console.WriteLine($"Area: {shape.CalculateArea()}");
    }
}

4. Абстракция

Абстракция — это процесс выделения существенных характеристик объекта и игнорирования несущественных деталей.

Реализация в C#:

• Абстрактные классы (abstract class)
• Интерфейсы (interface)
• Абстрактные методы

// Абстракция через интерфейс
public interface IDatabaseRepository
{
    Task<T> GetByIdAsync<T>(int id) where T : class;
    Task AddAsync<T>(T entity) where T : class;
    Task UpdateAsync<T>(T entity) where T : class;
    Task DeleteAsync<T>(int id) where T : class;
}

// Конкретная реализация
public class SqlServerRepository : IDatabaseRepository
{
    private readonly DbContext _context;
    
    public async Task<T> GetByIdAsync<T>(int id) where T : class
    {
        return await _context.Set<T>().FindAsync(id);
    }
    
    // Реализация остальных методов...
}

Дополнительные принципы (SOLID)

Помимо основных четырёх принципов, в современной разработке на C# активно применяются принципы SOLID:

• S — Single Responsibility Principle (Принцип единственной ответственности)
• O — Open/Closed Principle (Принцип открытости/закрытости)
• L — Liskov Substitution Principle (Принцип подстановки Барбары Лисков)
• I — Interface Segregation Principle (Принцип разделения интерфейсов)
• D — Dependency Inversion Principle (Принцип инверсии зависимостей)

Практическое значение в C# Backend:

• Инкапсуляция обеспечивает защиту данных и контролируемый доступ
• Наследование позволяет повторно использовать код и создавать иерархии
• Полиморфизм обеспечивает гибкость и расширяемость систем
• Абстракция упрощает сложные системы, скрывая детали реализации

Эти принципы являются фундаментом для создания поддерживаемого, тестируемого и масштабируемого кода в enterprise-приложениях на C#. Они активно применяются в архитектурных паттернах, таких как Domain-Driven Design, Repository Pattern, Service Layer и других, что делает их критически важными для backend-разработчика.