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

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

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

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

Инкапсуляция — это упаковка данных и методов в единый класс с контролем доступа к ним.

public class Player {
    // Приватные поля — доступ только внутри класса
    private int health = 100;
    private float speed = 5f;
    
    // Публичные свойства — контролируемый доступ
    public int Health {
        get { return health; }
        set { health = Mathf.Max(0, value); } // Здоровье не может быть ниже 0
    }
    
    public float Speed {
        get { return speed; }
        set { speed = Mathf.Max(0, value); }
    }
    
    // Публичный метод
    public void TakeDamage(int damage) {
        Health -= damage;
    }
}

Преимущества:

• Защита данных от неправильного использования
• Возможность добавлять валидацию
• Изменение реализации без изменения интерфейса

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

Наследование — механизм создания новых классов на основе существующих.

// Базовый класс
public class Character {
    public string name;
    public int health = 100;
    
    public virtual void TakeDamage(int damage) {
        health -= damage;
        Debug.Log($"{name} получил урон {damage}");
    }
}

// Наследование
public class Warrior : Character {
    public int armor = 10;
    
    // Переопределение метода (Override)
    public override void TakeDamage(int damage) {
        int reducedDamage = Mathf.Max(1, damage - armor / 2);
        base.TakeDamage(reducedDamage); // Вызов метода базового класса
    }
}

public class Mage : Character {
    public int mana = 100;
    
    public override void TakeDamage(int damage) {
        if (mana >= 20) {
            mana -= 20; // Используем ману вместо здоровья
            Debug.Log("Щит из магии поглотил урон");
        } else {
            base.TakeDamage(damage);
        }
    }
}

Когда использовать:

• Когда есть отношение "является" (is-a)
• Warrior является Character
• НЕ используй наследование для кода переиспользования (для этого композиция)

3. Полиморфизм (Polymorphism)

Полиморфизм — способность объектов одного типа вести себя по-разному в зависимости от контекста.

// Работаем с базовым типом, но вызываются методы наследников
List<Character> characters = new List<Character>
{
    new Warrior { name = "Артур" },
    new Mage { name = "Мерлин" }
};

foreach (var character in characters) {
    character.TakeDamage(50); // Вызовется нужный метод для каждого типа
}

Преимущества:

• Расширяемость без изменения существующего кода
• Единообразный интерфейс для разных типов
• Легче добавлять новые типы персонажей

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

Абстракция — выделение важных деталей и скрытие сложности.

// Абстрактный класс — не может быть инстанцирован
public abstract class Enemy {
    public abstract void Attack(Player player);
    
    public virtual void Die() {
        Destroy(gameObject);
    }
}

// Конкретная реализация
public class Goblin : Enemy {
    public override void Attack(Player player) {
        player.TakeDamage(10);
        Debug.Log("Гоблин атакует!");
    }
}

public class Dragon : Enemy {
    public override void Attack(Player player) {
        player.TakeDamage(50);
        Debug.Log("Дракон дышит огнём!");
    }
}

Интерфейсы (Interface):

public interface IDamageable {
    void TakeDamage(int damage);
    int GetHealth();
}

public class Boss : Character, IDamageable {
    public int GetHealth() => health;
}

Сравнение принципов

Практические советы для Unity

• Предпочитай композицию наследованию: вместо наследования используй компоненты
• Используй интерфейсы для слабой связанности: вместо прямых ссылок на классы
• Не создавай глубокие иерархии: максимум 2-3 уровня наследования
• Разделяй ответственность: один класс — одна задача

Выводы

ООП позволяет писать масштабируемый, поддерживаемый и тестируемый код. В Unity эти принципы необходимы для управления сложностью игровых систем и архитектуры проекта.