Основные принципы ООП

Тема  — «От алгоритмов к объектам. Основные принципы ООП»

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

Объект — это то, что объединяет в себе и данные (поля), и поведение (методы)».

Объектно-Ориентированное Программирование (ООП) позволяет моделировать реальный мир в коде.

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

Класс — это чертеж, шаблон, описание того, какими должны быть созданные сущности. Он определяет какими свойствами (полями) и поведением (методами)  должны обладать сущности (обьекты).

Новый класс — это новый тип данных.

В Java есть 8 базовых типов данных (int, boolean и т.п.), а все остальные типы данных называются объектными и за единичными исключениями описываются в виде классов. String, Scanner — всё это классы.

Имя класса — всегда с большой буквы. Это важно. С большой буквы в Java пишутся только классы и интерфейсы.

Особенности класса:

-      Описывает устройство и поведение объектов: устройство — через набор характеристик (свойств), поведение — через набор доступных для объектов операций (методов).

-      Классы можно создавать на основе уже имеющихся, добавляя или переопределяя свойства и методы.

-      В одной программе могут существовать несколько классов, а объекты разных классов могут взаимодействовать между собой (через методы).

-      Сам по себе класс памяти не занимает, это просто "идея".

Преподаватель:  Конкретный Вася Петров — это объект (экземпляр) этого класса.

 Он создан по шаблону Студент и обладает конкретными свойствами и поведением. (имя = "Вася", возраст = 19. И он сможет выполнять действия: представиться, пойти учиться.)

Объект — это конкретный экземпляр класса, обладающий состоянием и поведением. Объекты хранят свои данные (поля) и умеют выполнять действия (методы).

Особенности объекта:

-      Каждый объект имеет некоторое состояние, оно определяется значением всех его свойств.

-      Для создания объекта в Java используется оператор  new , за которым следует вызов конструктора класса. 

-      После создания объекта доступ к его полям и методам осуществляется с помощью оператора точки (.)

Поля (или переменные класса) определяют состояние объекта, хранят данные, которые могут различаться для каждого экземпляра класса.

Как в Java создать шаблон студента? Для этого используется ключевое слово class. Давайте создадим наш первый класс».

// Это наш чертеж (класс)

public class Student {

    // Это данные (поля, свойства)

    String name;

    int age;

    String group;

    // Это поведение (метод)

    void introduceYourself() {

        System.out.println("Привет! Я " + name + ", мне " + age + " лет, я из группы " + group);

    }

}

Внутри класса Student заведено три поля. В полях хранятся данные. Поля заводятся как переменные, сначала указывается тип, потом имя.

 «Класс — это просто чертеж. Сам по себе он памяти не занимает.

Как же теперь использовать новый тип данных? Создадим класс для запуска наших экспериментов. (часть кода public static void main(String[] args) {)

Чтобы создать реального студента, нам нужно создать объект или экземпляр этого класса в main. Делается это с помощью ключевого слова new». Для начала введем несколько переменных для хранения студентов:

public class Main {

    public static void main(String[] args) {

     // Создаем объекты по чертежу Student

      Student student1 = new Student();

        student1.name = "Иван Петров";

        student1.age = 19;

        student1.group = "ИС-11";

        Student student2 = new Student();

        student2.name = "Анна Смирнова";

        student2.age = 20;

        student2.group = "ИС-12";

        // Вызываем поведение объектов

        student1.introduceYourself();

        student2.introduceYourself();

    }

}

В этом коде операция new Student() создает нового студента, в памяти выделяется область для хранения имени и двух чисел — года рождения и года обучения.

Конструкция Student student1 вводит новую переменную, указывая, что в ней будут храниться студенты. 

Здесь Student() — это вызов конструктора по умолчанию (неявного), который Java добавляет автоматически, если мы не написали свой конструктор.

Конструктор нужен для создания объекта и начальной установки его полей.

Если мы не создаем свой конструктор, Java добавляет конструктор по умолчанию без параметров. Но мы можем создать свой конструктор, чтобы сразу задавать имя, возраст и группу при создании студента».

? Вопрос: Виды конструкторов Java

Для того, чтобы  пользоваться полями, т.е. записывать в них значения и читать их, нужно написать объект.имя_поля. Мы не можем писать только имя поля, например, name, потому что будет неясно, чье это имя. У нас же два студента. Поэтому явно пишем в начале, у какого объекта нам требуется поле.

(При запуске когда видим,, как два разных объекта выводят разные данные, используя один и тот же метод).

Класс Student описывает, как устроена информация о студентах. А сами студенты должны создаваться отдельно оператором new.

Конкретные воплощения класса называются объектами. В нашем примере создано ровно два объекта. В Java оператор new это основной метод создания объекта. Чтобы появился объект, нужно прямо или косвенно вызвать этот оператор.

Абстракция —  выделение главных характеристики объекта и отбросили второстепенное (для нашей программы не важно, какой у студента цвет глаз)". Мы создали упрощенную модель реального студента, которой достаточно для решения нашей задачи".

4.2. Принцип Инкапсуляции (защиты данных)

 «У нашего класса есть проблема.

student1.age = -150; // Это же ерунда!

student1.name = null; // Тоже плохо

 «Программа не защищена. Любой может испортить данные нашего объекта.

Как в жизни: мы не можем просто так взять и изменить возраст в паспорте человека. Нужно идти в паспортный стол  писать заявление, проходить проверку. В программировании эту защиту обеспечивает принцип Инкапсуляции.

Инкапсуляция (иногда называемая сокрытием информации) — ключевая концепция работы с объектами в ООП.

Формально инкапсуляция — это просто объединение данных и поведения в одну единицу кода (пакет/модуль/класс и т.д.) и сокрытие деталей реализации, внутреннего состояния объекта (в нашем случае реализации полей и методов) от пользователей объекта (доступа извне).

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

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

Как работает: Взаимодействие программы с данными объекта происходит только через его публичные методы этого обьета. Эти методы могут содержать логику проверки (валидации), чтобы в поля не попали некорректные значения.

В Java существует четыре модификатора доступа — ключевые слова, которые регулируют видимость и доступность классов, методов и полей.

 Они помогают реализовать принцип объектно-ориентированного программирования — инкапсуляцию, позволяя контролировать, какие части кода могут взаимодействовать между собой

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

? Вопрос. Где и как еще применяются модификаторы доступа

Public - Предоставляет неограниченный доступ к классу, методу, переменной или конструктору из любого другого класса в том же пакете или в разных пакетах. Некоторые особенности: 

·         Если это переменная, любой класс из любого пакета может её прочитать и изменить.

·         Если это метод, любой класс может его вызвать.

·         Если это конструктор, любой класс может его использовать для создания объекта.

Protected - Разрешает доступ к классу, методу или переменной в пределах того же пакета или подклассов (в любом пакете). Некоторые особенности: 

·         Методы или члены данных, объявленные с модификатором protected, доступны внутри того же пакета или в подклассах в разных пакетах.

·         Этот модификатор, как правило, используется для внутренних методов, которые должны вызываться или переопределяться подклассами.

·         Также можно использовать его, чтобы разрешить подклассам прямой доступ к внутренним атрибутам суперкласса.

Default - Применяется по умолчанию, когда модификатор доступа не указан явно. Доступ к членам класса возможен только внутри того же пакета. То есть классы, находящиеся в одном пакете, могут свободно обращаться к полям, методам и конструкторам с доступом по умолчанию, а классы из других пакетов — нет. 

Модификатор default подходит для вспомогательных классов, которые должны быть доступны только внутри определённого пакета, но не должны попадать во внешний API. 

Важно: не все модификаторы можно использовать вместе — например, public, protected и private — взаимоисключающие. 

Private

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

Модификатор private обеспечивает наивысший уровень инкапсуляции и является наиболее ограничивающим модификатором доступа. 

 Цель: Инкапсуляция защищает целостность данных. Объект сам отвечает за то, чтобы его состояние было корректным.  Мы гарантируем, что баланс не может стать отрицательным, потому что все операции проходят через наши проверки

 «В Java мы ставим перед полями ключевое слово private. Это значит, что доступ к ним есть только внутри самого класса Student». Снаружи, из main, мы к ним обратиться больше не сможем».

public class Student {

    private String name; // Теперь доступ ограничен

    private int age;

    private String group;

    // ... метод introduceYourself ...

}

«Как же теперь задать имя? Нам нужны специальные публичные методы для доступа — "паспортный стол".

Они называются get- методы (геттеры (получить)) и set- методы  (сеттеры (установить)). В сеттере мы можем добавить проверку!»

Методы, которые нужны, только чтобы узнать какую-то информацию об объекте, традиционно начинаются на get- (получить). Для узнавания возраста в этом случае метод нужно назвать getAge(). Напишем внутри класса student/

get- метод возвращает значения, не требуя аргументов.

Когда мы сделали поле Age приватным и добавили для него get- метод, мы добились того, что любой сторонний код может узнать возраст человека, но не может его изменить. Часто это ровно то, что нужно, но иногда мы все-таки считаем, что надо позволить изменять у человека имя

. В этом случае нужен set- метод. Он принимает новый возрас человека и не возвращает значений:

public class Student {

    private String name;

    private int age;

    private String group;

    // Геттер для возраста

    public int getAge() {

        return age;

    }

    // Сеттер для возраста С ЗАЩИТОЙ!

    public void setAge(int age) {

        if (age > 0 && age < 100) { // Проверка!

            this.age = age; // this.age - поле объекта, age - параметр метода

        } else {

            System.out.println("Ошибка! Возраст должен быть от 1 до 99");

        }

    }

    public void introduceYourself() {

        System.out.println("Привет! Я " + name + ", мне " + age + " лет");

    }

}

Попробуйте установить возраст -150. Программа выдаст ошибку и не даст испортить данные. Это и есть инкапсуляция — сокрытие внутренней реализации и защита данных».

4.3. Принцип Наследования

 «В университете есть не только студенты, но и преподаватели. Давайте создадим класс Teacher. У них тоже есть имя и возраст, но вместо группы — кафедра, и представляются они иначе».

java

public class Teacher {

    private String name;

    private int age;

    private String department;

    public void introduceYourself() {

        System.out.println("Здравствуйте. Я преподаватель " + name + " с кафедры " + department);

    }

    // ... геттеры и сеттеры ...

}

Создадим общий класс Person (Человек). Вынесем туда всё общее. А студент и преподаватель будут его наследниками».

java

// Родительский класс

public class Person {

    private String name;

    private int age;

    public String getName() { return name; }

    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }

    public void setAge(int age) { if(age>0) this.age = age; }

    public void introduceYourself() {

        System.out.println("Я человек.");

    }

}

// Класс-наследник

public class Student extends Person { // Ключевое слово extends

    private String group;

    public String getGroup() { return group; }

    public void setGroup(String group) { this.group = group; }

    // Переопределение метода (Полиморфизм - забегаем вперед)

    @Override

    public void introduceYourself() {

        System.out.println("Привет! Я студент " + getName() + " из группы " + group);

    }

}

// Класс-наследник

public class Teacher extends Person {

    private String department;

    public String getDepartment() { return department; }

    public void setDepartment(String department) { this.department = department; }

    @Override

    public void introduceYourself() {

        System.out.println("Здравствуйте. Я преподаватель " + getName() + " с кафедры " + department);

    }

}

в Student и Teacher нет полей name и age, но мы можем использовать getName() и setAge(), потому что они унаследовали их от Person. Это и есть Наследование.

 Отношение "IS-A" (студент является человеком). Мы переиспользуем код и выстраиваем иерархию Это и есть Наследование».

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

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

В Java наследование реализуется с помощью ключевого слова extends.

Особенности наследования в Java:

·         Поддерживается только одиночное наследование классов (в отличие от C++)

·         Все классы в Java неявно наследуются от класса Object

·         Подклассы получают доступ ко всем public и protected членам суперкласса

·         Конструкторы не наследуются, но могут вызываться с помощью super()

·         Можно переопределять методы суперкласса с помощью аннотации @Override

Преимущества наследования:

- Повторное использование кода — общая функциональность определяется один раз в суперклассе

- Организация иерархии классов — отражает естественные отношения "является" (is-a)

-Расширяемость — возможность добавлять новые подклассы без изменения существующего кода

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

4.4. Принцип Полиморфизма

Мы создали иерархию. Создадим в main список людей, где будут и студенты, и преподаватели».

java

public class Main {

    public static void main(String[] args) {

        // Создаем объекты

        Student ivan = new Student();

        ivan.setName("Иван");

        ivan.setGroup("ИС-11");

        Teacher elena = new Teacher();

        elena.setName("Елена Петровна");

        elena.setDepartment("Информатики");

        // Помещаем их в массив типа Person (родительский класс)

        Person[] people = {ivan, elena};

        // Проходим по массиву и просим каждого представиться

        for (Person p : people) {

            p.introduceYourself(); // Какой метод вызовется?

        }

    }

}

(Запускаем код).

Результат:

text

Привет! Я студент Иван из группы ИС-11

Здравствуйте. Я преподаватель Елена Петровна с кафедры Информатики

Мы объявили массив как Person[], но Java вызвала правильные методы — для студента свой, для преподавателя свой.

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

Если завтра мы добавим класс Aspirant, код в цикле for останется без изменений, а работать будет правильно!».

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

 Термин происходит от греческих слов "поли" (много) и "морф" (форма), что буквально означает "многоформенность". В Java различают два типа полиморфизма: статический и динамический

«Кстати, это только одна сторона полиморфизма — динамический (полиморфизм подтипов). Есть еще статический полиморфизм — это перегрузка методов (overloading). Когда в одном классе есть несколько методов с одинаковым именем, но разными параметрами. Компилятор сам решает, какой вызвать, глядя на аргументы».

Задание

1.      Реализовать на Java небольшую иерархию классов по одной из тем (или придумать свою):

Вариант А: Транспорт. Базовый класс Vehicle (скорость, грузоподъемность, метод move()). Классы-наследники: Car, Bicycle, Truck. В каждом классе переопределить метод move() (например, для велосипеда "Я кручу педали", для машины "Я еду на бензине"). Обязательно использовать инкапсуляцию (поля private).

Вариант Б: Геометрические фигуры. Базовый класс Shape (метод calculateArea()). Классы-наследники: Circle, Rectangle. Реализовать метод расчета площади для каждой фигуры.

2.      (Для продвинутых) В методе main создать массив из объектов разных типов и в цикле вызвать для каждого общий метод, чтобы увидеть полиморфизм в действии.

Примеры:  https://pro-prof.com/forums/topic/java-oop