Простыми словами: Инкапсуляция в ООП

Мы с вами уже разобрали наследование и абстракцию. Пришло время третьей парадигмы. Инкапсуляция — это концепция ООП, которая скрывает внутренние детали объекта и предоставляет доступ только к нужным методам и свойствам. Это как капсула с лекарством: вы знаете, как её использовать, но не видите, что внутри.

Абстракция и инкапсуляция часто работают вместе. Абстракция скрывает сложные детали, выделяя только ключевые аспекты, а инкапсуляция обеспечивает безопасность этих деталей, предоставляя контролируемый доступ. Эти концепции делают ваш код более безопасным, структурированным и лёгким для поддержки.

Давайте рассмотрим несколько примеров:

В Python инкапсуляции часто достигают с помощью именования методов и атрибутов с одним или двумя подчёркиваниями.

class Кот:
    def __init__(self, имя):
        self.__имя = имя  # Скрытый атрибут

    def получить_имя(self):
        return self.__имя  # Метод для получения скрытого атрибута

    def мяукать(self):
        print(f"{self.__имя} говорит: Мяу!")
        
кот = Кот("Мурзик")
print(кот.получить_имя())  # Output: Мурзик
кот.мяукать()  # Output: Мурзик говорит: Мяу!

# Попытка доступа к скрытому атрибуту напрямую
# print(кот.__имя)  # Это вызовет ошибку

В этом примере атрибут __имя скрыт от внешнего доступа, и доступ к нему можно получить только через метод получить_имя.

Давайте рассмотрим пример из Java. Здесь инкапсуляция достигается с помощью модификаторов доступа (private, protected, public) и методов getter/setter.

public class Кот {
    private String имя;  // Скрытый атрибут

    public Кот(String имя) {
        this.имя = имя;
    }

    public String getИмя() {  // Метод для получения скрытого атрибута
        return имя;
    }

    public void мяукать() {
        System.out.println(имя + " говорит: Мяу!");
    }

    public static void main(String[] args) {
        Кот кот = new Кот("Мурзик");
        System.out.println(кот.getИмя());  // Output: Мурзик
        кот.мяукать();  // Output: Мурзик говорит: Мяу!

        // Попытка доступа к скрытому атрибуту напрямую
        // System.out.println(кот.имя);  // Это вызовет ошибку
    }
}

В этом примере атрибут имя объявлен как private и доступен только через метод getИмя.

Где применяется?

Инкапсуляция помогает скрыть детали внутренней структуры объекта, например, банковского счёта.

class БанкСчет:
    def __init__(self, баланс=0):
        self.__баланс = баланс  # Скрытый атрибут

    def пополнить(self, сумма):
        if сумма > 0:
            self.__баланс += сумма

    def вывести(self, сумма):
        if сумма > 0 и self.__баланс >= сумма:
            self.__баланс -= сумма

    def получить_баланс(self):
        return self.__баланс

счет = БанкСчет()
счет.пополнить(100)
счет.вывести(30)
print(счет.получить_баланс())  # Output: 70

Также позволяет управлять доступом к критическим операциям.

class Пользователь:
    def __init__(self, имя, пароль):
        self.__имя = имя
        self.__пароль = пароль  # Скрытый атрибут

    def проверить_пароль(self, ввод):
        return self.__пароль == ввод

пользователь = Пользователь("Иван", "12345")
print(пользователь.проверить_пароль("12345"))  # Output: True
print(пользователь.проверить_пароль("54321"))  # Output: False

Теперь вы знакомы с тремя составляющими ООП. Нам осталось разобраться в полиморфизме.

Если формат заходит — поставьте ❤️, я буду знать, что пишу не зря. А замечания можете написать в комментарии👇

#простымисловами #ооп #инкапсуляция