OOP2

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

.Процедурный подход к программированию

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

Что такое процедурное программирование?

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

Пример: Вычисление площади прямоугольника

Рассмотрим пример. Допустим, вы хотите рассчитать площадь прямоугольника. В процедурном подходе вы можете написать функцию, которая принимает два параметра: ширину и высоту. Вот как это будет выглядеть:

function calculateArea(width, height) {
    return width * height;
}
let area = calculateArea(5, 10);
console.log(area); // Вывод: 50

В этом примере функция calculateArea просто принимает два значения, умножает их и возвращает результат. Это просто и понятно, особенно для небольших программ.

Проблема с процедурным программированием

Однако, когда программы становятся более сложными и объемными, управление кодом становится настоящей проблемой. Вот несколько причин:

1. Усложнение структуры: Чем больше функций вы пишете, тем труднее отслеживать, как они взаимодействуют друг с другом. Как в большом ресторане с множеством блюд, становится сложно контролировать процессы на кухне.

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

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

Заключение

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

Основные понятия ООП

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

Что такое класс и объект?

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

Аналогия

Класс как чертеж дома

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

Объект как построенный дом

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

Пример: Класс Прямоугольник

Рассмотрим практический пример класса Прямоугольник:

class Rectangle {
    width: number;
    height: number;

    constructor(width: number, height: number) {
        this.width = width;
        this.height = height;
    }

    calculateArea(): number {
        return this.width * this.height;
    }
}
let rect = new Rectangle(5, 10);
console.log(rect.calculateArea()); // Вывод: 50

Объяснение примера

В данном примере Rectangle — это класс, который определяет два свойства: ширину (width) и высоту (height) прямоугольника. Конструктор класса принимает эти два параметра и устанавливает их для нового объекта, который мы создаем.

• Когда мы создаем объект rect, мы задаем ширину 5 и высоту 10.

• Метод calculateArea выполняет операцию умножения ширины на высоту, возвращая площадь прямоугольника.

• Таким образом, rect.calculateArea() возвращает значение 50.

Свойства и методы объекта

Свойства — это характеристики объекта. В нашем примере width и height являются свойствами объекта rect. Они определяют размеры прямоугольника.

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

Заключение

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

Три столпа ООП

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

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

Зачем нужна инкапсуляция?Инкапсуляция нужна для того, чтобы скрыть сложные детали реализации и обеспечить лишь необходимый интерфейс для взаимодействия с объектом. Такое сокрытие делает код более безопасным, уменьшает вероятность ошибок и упрощает изменение реализации без влияния на другие части программы.

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

Пример:Давайте рассмотрим простой пример на языке TypeScript:

class Person {
    private age: number;

    constructor(age: number) {
        this.age = age;
    }

    public getAge(): number {
        return this.age;
    }

    private secretThoughts(): void {
        console.log("Это приватный метод.");
    }
}

let person = new Person(27);
console.log(person.getAge()); // Вывод: 27
// person.secretThoughts(); // Ошибка: метод приватный

В этом примере у нас есть класс Person, который содержит одно приватное свойство age и два метода: getAge() и secretThoughts().

• Метод getAge() является публичным, и его можно вызывать из любой части программы. Он возвращает значение возраста пользователя.

• Метод secretThoughts() является приватным, поэтому он недоступен за пределами класса Person и нельзя его вызвать из внешнего кода. Если бы мы попытались вызвать person.secretThoughts(), это вызвало бы ошибку компиляции.

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

Наследование в ООП

Что такое наследование?

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

Зачем нужно наследование?

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

Пример с транспортными средствами

Представьте себе класс Транспортное средство. Он описывает общие характеристики всех транспортных средств, такие как количество колес и максимальная скорость:

class Vehicle {
    wheels: number;
    maxSpeed: number;

    constructor(wheels: number, maxSpeed: number) {
        this.wheels = wheels;
        this.maxSpeed = maxSpeed;
    }
}

Теперь предположим, что мы хотим создать класс Автомобиль, который наследует свойства и методы от класса Транспортное средство. Автомобиль будет иметь дополнительные характеристики, такие как тип топлива и количество дверей:

class Car extends Vehicle {
    fuelType: string;
    doors: number;

    constructor(wheels: number, maxSpeed: number, fuelType: string, doors: number) {
        super(wheels, maxSpeed);
        this.fuelType = fuelType;
        this.doors = doors;
    }
}

Итак, новый класс Car использует свойства, определенные в классе Vehicle, и в то же время добавляет свои собственные. Это упрощает процесс создания автомобильных объектов, поскольку мы не дублируем код, который уже был написан в классе Vehicle.

Пример из жизни

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

Пример с животными

Рассмотрим следующий пример, где класс Animal служит суперкласом для класса Dog:

class Animal {
    name: string;

    constructor(name: string) {
        this.name = name;
    }

    makeSound(): void {
        console.log("Животное издает звук.");
    }
}

class Dog extends Animal {
    constructor(name: string) {
        super(name);
    }

    makeSound(): void {
        console.log("Гав-гав!");
    }
}

В этом примере, класс Dog наследует свойства и методы класса Animal. Метод makeSound переопределяется в классе Dog, чтобы возвращать "Гав-гав!", в то время как Animal может просто возвращать общую фразу о звуках животных. Это демонстрирует, как подкласс может расширять и изменять поведение, унаследованное от суперкласса.

Заключение

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

Полиморфизм в ООП

Что такое полиморфизм?

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

Пример из жизни

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

Примеры в коде

В программировании полиморфизм реализуется через базовые классы и их наследников. Рассмотрим следующий код:

// Базовый класс Shape
class Shape {
    double area() {
        return 0;
    }
}

// Класс Circle, наследующий от Shape
class Circle extends Shape {
    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    @Override
    double area() {
        return Math.PI * this.radius * this.radius;
    }
}

// Класс Square, наследующий от Shape
class Square extends Shape {
    double side;

    Square(double side) {
        this.side = side;
    }

    @Override
    double area() {
        return this.side * this.side;
    }
}

// Главный класс для запуска программы
public class Main {
    public static void main(String[] args) {
        Shape[] shapes = { new Circle(5), new Square(5) };

        for (Shape shape : shapes) {
            System.out.println(shape.area());
        }
    }
}

Объяснение кода

1. Класс Shape - это базовый класс, который определяет метод area(), возвращающий 0. Это метод "по умолчанию" для всех форм.

2. Класс Circle наследует от класса Shape и переопределяет метод area(), чтобы вычислять площадь круга по формуле ( \pi \cdot radius^2 ).

3. Класс Square, аналогичным образом, переопределяет метод area(), чтобы вычислять площадь квадрата.

4. Массив shapes - это массив объектов типа Shape, содержащий экземпляры Circle и Square. Когда мы вызываем shape.area(), для каждого объекта вызывается его собственная реализация метода, что и демонстрирует полиморфизм.

Результаты выполнения

В результате выполнения программы мы получаем:

• Для круга с радиусом 5: 78.53981633974483 (площадь круга)

• Для квадрата со стороной 5: 25 (площадь квадрата)

Таким образом, полиморфизм позволяет нам обрабатывать различные формы (Circle и Square) через общий интерфейс (Shape), упрощая взаимодействие с ними и увеличивая гибкость кода. Это особенно полезно в крупных системах, где может быть много различных объектов, и их поведение зависит от их типа.

Композиция и агрегация

Композиция

Использование объекта одного класса в другом в качестве переменной (свойства)

Что это такое? Композиция — это отношение «часть-целое», где отдельные части становятся неотъемлемой частью целого и не могут существовать без него. Это значит, что если целое исчезает, части также перестают существовать или теряют свой смысл.

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

Пример на коде:Давайте рассмотрим следующий код:

class Engine {
    void start() {
        System.out.println("Двигатель запущен.");
    }
}

class Car {
    Engine engine; // иниц. объект engine класса Engine

    Car() {
        this.engine = new Engine(); // обязательно к любму свойству 
    }

    void startCar() {
        engine.start();
        System.out.println("Автомобиль поехал.");
    }
}

public class Main {
    public static void main(String[] args) {
        Car car = new Car();
        car.startCar(); // Вывод: Двигатель запущен.
        // Автомобиль поехал.
    }
}

В этом примере мы создаем класс Engine, который представляет двигатель, и класс Car, который содержит двигатель как часть своего компонента. Метод startCar() запускает двигатель и выводит сообщение о том, что автомобиль поехал. Без Car объект Engine утрачивает свою функцию. Это хорошо иллюстрирует концепцию композиции.

Агрегация

Работа с объектом который уже создан

Что это такое? Агрегация — это более свободное отношение «часть-целое», где части могут существовать независимо от целого. Это означает, что даже если целое исчезнет, его части могут продолжать существовать и выполнять свои функции.

Аналогия:Представьте себе класс в школе. Этот класс состоит из студентов. Студенты могут существовать самостоятельно, вне зависимости от того, в каком классе они находятся. Если класс распустится, студенты по-прежнему будут частью другого класса или могут даже не ходить в школу вовсе.

Пример на коде:Рассмотрим следующий код:

import java.util.List;
import java.util.ArrayList;

// Класс Student
class Student {
    String name;

    // Конструктор
    Student(String name) {
        this.name = name;
    }
}

// Класс Classroom
class Classroom {
    List<Student> students;

    // Конструктор
    Classroom(List<Student> students) {
        this.students = students;
    }

    // Метод для вывода списка студентов
    void listStudents() {
        for (Student student : students) {
            System.out.println(student.name);
        }
    }
}

// Главный класс для запуска программы
public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("Аня");
        Student student2 = new Student("Борис");

        ArrayList<Student> studentList = new ArrayList<>();
        studentList.add(student1);
        studentList.add(student2);

        Classroom classroom = new Classroom(studentList);
        classroom.listStudents();
        // Вывод:
        // Аня
        // Борис
    }
}

В этом примере класс Student представляет студентов, которые могут существовать независимо от класса Classroom. Даже если класс исчезнет, сами студенты останутся и могут быть частью другого класса. Агрегация позволяет более гибко управлять связанными объектами в коде.

Абстрактные классы и интерфейсы

Что такое абстрактные классы?

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

Пример абстрактного класса

Рассмотрим абстрактный класс Animal, который служит базой для других классов:

abstract class Animal {
    abstract void makeSound(); // Абстрактный метод

    void move() { // Конкретный метод
        System.out.println("Животное движется.");
    }
}

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

b. Метод move() имеет реализацию и может быть использован всеми подтипами класса Animal.

Наследование абстрактного класса

Теперь давайте создадим конкретный класс, например, Cat, который будет наследовать Animal:

class Cat extends Animal {
    makeSound(): void {
        console.log("Мяу!");
    }
}

Когда мы создаем экземпляр Cat, мы можем использовать как абстрактный метод makeSound() (который будет содержать реализацию), так и конкретный метод move():

let cat = new Cat();
cat.makeSound(); // Вывод: Мяу!
cat.move();   // Вывод: Животное движется.

Аналогия

Представьте себе лес, где обитают разные животные. У вас есть общий класс для всех животных — Animal. Каждый вид животного (например, кошки, собаки и т.д.) берет на себя характеристики общего класса, но также добавляет свои уникальные особенности. Например, каждый вид может издавать свои звуки. Классы Cat, Dog, и другие – это специальные виды, которые используют общий «генетический» код от Animal, но у каждого есть свои уникальные способности, например, как они лают или мяукают.

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

Интерфейсы в ООП

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

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

Пример:Рассмотрим интерфейс Printable:

interface Printable {
    print(): void;
}

Этот интерфейс определяет метод print, который должен быть реализован любым классом, принимающим на себя обязательства по этому интерфейсу. Давайте посмотрим, как это выглядит в классах:

class Document implements Printable {
    print(): void {
        console.log("Печать документа.");
    }
}

class Photo implements Printable {
    print(): void {
        console.log("Печать фотографии.");
    }
}

В данном случае классы Document и Photo реализуют интерфейс Printable, определяя, как именно они будут печатать свои содержимые. Теперь, когда мы создаем массив этих объектов и вызываем метод print, система знает, что нужно делать:

Printable[] items = { new Document(), new Photo() }; 
for (Printable item : items) { 
		item.print(); } 
// Вывод: // Печать документа. // Печать фотографии

Такой подход позволяет легко добавлять новые классы, которые могут следовать тому же контракту, избегая дублирования кода. Если вы добавите, например, класс Report, который также печатает, он просто должен будет реализовать метод print, и система будет с ним работать так же эффективно.

Внедрение зависимостей

Что такое Dependency Injection?Dependency Injection (внедрение зависимостей) — это метод, с помощью которого класс получает свои зависимости извне, а не создает их внутри. Этот процесс позволяет уменьшить количество жестких зависимостей между компонентами, делая их более гибкими и тестируемыми.

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

Пример:Рассмотрим интерфейс Database:

interface Database {
    query(sql: string): void;
}

Здесь мы определяем контракт, в котором любой реализованный класс должен предусмотреть метод query. Затем создадим класс MySQLDatabase, который реализует этот интерфейс:

class MySQLDatabase implements Database {
    query(sql: string): void {
        console.log(`Выполнение запроса в MySQL: ${sql}`);
    }
}

Теперь у нас есть основной класс приложения, который принимает объект Database в своем конструкторе:

class Application {
    private database: Database;

    constructor(database: Database) {
        this.database = database;
    }

    getData(): void {
        this.database.query("SELECT * FROM users");
    }
}

Это позволяет передать в Application любой класс, реализующий интерфейс Database. Таким образом, мы можем использовать MySQLDatabase или любую другую реализацию без необходимости модификации самого класса Application:

let db = new MySQLDatabase();
let app = new Application(db);
app.getData();
// Вывод: Выполнение запроса в MySQL: SELECT * FROM users

Такой подход делает код более гибким и удобным для тестирования.

Паттерн Singleton

Что это такое?Паттерн Singleton — это принцип проектирования, который гарантирует, что класс будет иметь только один экземпляр (объект), и предоставляет глобальную точку доступа к этому экземпляру. Это важно, когда вам необходимо координировать действия через систему, где один определённый объект должен оставаться уникальным. Например, в системах управления ресурсами, где один контроллер управляет доступом к данным.

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

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

Пример реализации:Рассмотрим следующий пример класса Singleton на языке TypeScript:

class Singleton {
    private static instance: Singleton;  // Статическая переменная для хранения единственного экземпляра

    private constructor() {  // Приватный конструктор, чтобы предотвратить создание объектов извне
    }

    static getInstance(): Singleton {  // Метод для доступа к единственному экземпляру
        if (!Singleton.instance) {  // Проверка, существует ли уже экземпляр
            Singleton.instance = new Singleton();  // Если нет, создаем новый
        }
        return Singleton.instance;  // Возвращаем единственный экземпляр
    }

    public someMethod(): void {  // Пример метода внутри класса
        console.log("Метод одиночки.");
    }
}

Использование:Теперь мы можем получить единственный экземпляр этого класса:

let singleton1 = Singleton.getInstance();  // Первый вызов
let singleton2 = Singleton.getInstance();  // Второй вызов

console.log(singleton1 === singleton2); // Проверка: выводит true, так как оба экземпляра ссылаются на один и тот же объект.

singleton1.someMethod(); // Вывод: Метод одиночки.

Заключение:Таким образом, при вызове Singleton.getInstance() вы всегда получаете один и тот же экземпляр. Это позволяет избежать дублирования ресурсов и поддерживать контроль над состоянием приложения. Singleton помогает сделать управление объектами более упорядоченным и эффективным, особенно в больших системах, где важно поддерживать консистентность и уникальность элементов.