Что такое ООП?

Что такое ООП (Объектно-ориентированное программирование)

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

Основные концепции

Класс и объект

Класс — это чертеж, описывающий структуру объекта. Объект — это конкретный экземпляр класса.

// Класс - шаблон
class Dog {
    var name: String = ""
    var age: Int = 0
    
    fun bark() {
        println("$name says: Woof!")
    }
}

// Объекты - экземпляры класса
val dog1 = Dog()
dog1.name = "Rex"
dog1.bark()  // Rex says: Woof!

val dog2 = Dog()
dog2.name = "Buddy"
dog2.bark()  // Buddy says: Woof!

Четыре столпа ООП

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

Объединение данных и методов в одном классе, с контролем доступа через модификаторы (public, private, protected).

class BankAccount {
    private var balance: Double = 0.0  // приватное поле
    
    fun deposit(amount: Double) {
        if (amount > 0) {
            balance += amount  // контролируемый доступ
        }
    }
    
    fun getBalance(): Double = balance  // геттер
}

val account = BankAccount()
account.deposit(100.0)
println(account.getBalance())  // 100.0
// account.balance  // ошибка! приватное

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

Создание новых классов на основе существующих, перенимая их свойства и методы.

// Базовый класс (суперкласс)
open class Animal {
    open fun makeSound() {
        println("Some sound")
    }
}

// Производный класс (подкласс)
class Dog : Animal() {
    override fun makeSound() {
        println("Woof!")
    }
}

class Cat : Animal() {
    override fun makeSound() {
        println("Meow!")
    }
}

val dog: Animal = Dog()
val cat: Animal = Cat()

dog.makeSound()  // Woof!
cat.makeSound()  // Meow!

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

• Повторное использование кода
• Логическая иерархия
• Упрощение поддержки

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

Одно имя, много форм. Способность объектов разных типов выполнять одно и то же действие по-разному.

abstract class Shape {
    abstract fun area(): Double
}

class Circle(val radius: Double) : Shape() {
    override fun area() = 3.14 * radius * radius
}

class Rectangle(val width: Double, val height: Double) : Shape() {
    override fun area() = width * height
}

fun printArea(shape: Shape) {
    println("Area: ${shape.area()}")  // полиморфизм!
}

printArea(Circle(5.0))        // Area: 78.5
printArea(Rectangle(4.0, 6.0))  // Area: 24.0

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

Скрытие сложных деталей и предоставление только необходимого интерфейса.

// Абстрактный класс
abstract class Vehicle {
    abstract fun start()
    abstract fun stop()
    
    // Конкретный метод
    fun displayInfo() {
        println("This is a vehicle")
    }
}

class Car : Vehicle() {
    override fun start() {
        println("Car engine started")
    }
    
    override fun stop() {
        println("Car engine stopped")
    }
}

val car: Vehicle = Car()
car.start()        // Car engine started
car.displayInfo()  // This is a vehicle

SOLID принципы

ООП часто применяется вместе с SOLID:

• Single Responsibility: один класс - одна ответственность
• Open/Closed: открыт для расширения, закрыт для модификации
• Liskov Substitution: подклассы должны быть заменяемы на базовый класс
• Interface Segregation: много специфичных интерфейсов вместо одного большого
• Dependency Inversion: зависимости на абстракции, не на реализации

Практический пример: система управления сотрудниками

// Абстракция
abstract class Employee {
    abstract val salary: Double
    abstract fun work()
    
    fun getInfo() {
        println("Employee with salary: $salary")
    }
}

// Наследование
class Developer : Employee() {
    override val salary = 100000.0
    
    override fun work() {
        println("Writing code")
    }
}

class Manager : Employee() {
    override val salary = 120000.0
    
    override fun work() {
        println("Managing team")
    }
}

// Полиморфизм
fun employeeWork(employee: Employee) {
    employee.work()
    employee.getInfo()
}

val dev: Employee = Developer()
val mgr: Employee = Manager()

employeeWork(dev)  // Writing code, Employee with salary: 100000.0
employeeWork(mgr)  // Managing team, Employee with salary: 120000.0

ООП в Android

// Базовый Activity
open class BaseActivity : AppCompatActivity() {
    open fun setupUI() {}
    
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setupUI()
    }
}

// Конкретная Activity
class MainActivity : BaseActivity() {
    override fun setupUI() {
        setContentView(R.layout.activity_main)
        // инициализация UI
    }
}

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

• Модульность: код разбит на логические части
• Переиспользование: наследование и композиция
• Поддержка: легче найти и исправить ошибки
• Масштабируемость: легче добавлять новые функции
• Понятность: естественное отражение реального мира

Недостатки ООП

• Сложность: может быть избыточным для простых задач
• Performance: небольшие издержки на абстракции
• Кривая обучения: требует понимания концепций

Итого

ООП — это мощная парадигма, которая делает код:

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

В Android разработке ООП является стандартом и критически важна для написания качественного, масштабируемого кода.