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

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

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

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

Инкапсуляция — это механизм скрытия внутреннего состояния объекта и предоставления контролируемого доступа к нему через public методы. Это обеспечивает целостность данных и позволяет менять внутреннюю реализацию без изменения интерфейса.

class User {
  private email: string;
  private password: string;

  constructor(email: string, password: string) {
    if (!this.isValidEmail(email)) {
      throw new Error("Invalid email");
    }
    this.email = email;
    this.password = this.hashPassword(password);
  }

  public getEmail(): string {
    return this.email;
  }

  public setPassword(newPassword: string): void {
    this.password = this.hashPassword(newPassword);
  }

  private isValidEmail(email: string): boolean {
    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
  }

  private hashPassword(password: string): string {
    return password;
  }
}

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

Наследование позволяет создавать иерархию классов, где дочерний класс наследует свойства и методы родителя. Это способствует переиспользованию кода и установлению отношения "является" (is-a).

class Animal {
  protected name: string;

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

  public move(): void {
    console.log(`${this.name} is moving`);
  }
}

class Dog extends Animal {
  public bark(): void {
    console.log(`${this.name} says: Woof!");
  }

  public move(): void {
    console.log(`${this.name} is running`);
  }
}

3. Полиморфизм

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

interface Shape {
  calculateArea(): number;
}

class Circle implements Shape {
  constructor(private radius: number) {}

  calculateArea(): number {
    return Math.PI * this.radius ** 2;
  }
}

class Rectangle implements Shape {
  constructor(private width: number, private height: number) {}

  calculateArea(): number {
    return this.width * this.height;
  }
}

function printArea(shape: Shape): void {
  console.log(`Area: ${shape.calculateArea()}`);
}

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

Абстракция скрывает сложность и выделяет только существенные характеристики. Используется для создания договора, который должны соблюдать реализации.

abstract class DatabaseConnection {
  protected connectionString: string;

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

  abstract connect(): Promise<void>;
  abstract query(sql: string): Promise<any>;
  abstract disconnect(): Promise<void>;

  protected logQuery(sql: string): void {
    console.log(`Executing: ${sql}`);
  }
}

class PostgresConnection extends DatabaseConnection {
  async connect(): Promise<void> {
    console.log("Connecting to PostgreSQL...");
  }

  async query(sql: string): Promise<any> {
    this.logQuery(sql);
    return { data: [] };
  }

  async disconnect(): Promise<void> {
    console.log("Disconnected from PostgreSQL");
  }
}

Практическое применение в Node.js

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