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

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

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

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

function createCounter() {
  let count = 0
 
  function increment() {
    count++
  }
 
  function decrement() {
    if (count > 0) {
      count--
    }
  }
 
  function getCount() {
    return count
  }
 
  return {
    increment,
    decrement,
    getCount,
  }
}
 
const counter = createCounter()
console.log(counter.getCount()) // 0
 
counter.increment()
counter.increment()
console.log(counter.getCount()) // 2
 
counter.decrement()
console.log(counter.getCount()) // 1

Достаточно просто реализуется посредством создания объектов и замыканий.

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

Пример наследования в веб-приложении на JavaScript можно реализовать с помощью прототипного наследования или с использованием классов и ключевых слов extends и super.

// Базовый класс
class Animal {
  constructor(name) {
    this.name = name
  }
 
  speak() {
    console.log(`${this.name} makes a sound.`)
  }
}
 
// Подкласс, наследующий от базового класса Animal
class Dog extends Animal {
  constructor(name, breed) {
    super(name) // Вызов конструктора базового класса
 
    this.breed = breed
  }
 
  speak() {
    console.log(`${this.name} barks.`)
  }
 
  fetch() {
    console.log(`${this.name} fetches the ball.`)
  }
}
 
// Создание экземпляра класса Dog
const dog = new Dog("Buddy", "Golden Retriever")
dog.speak() // "Buddy barks."
dog.fetch() // "Buddy fetches the ball."
console.log(dog.name) // "Buddy"
console.log(dog.breed) // "Golden Retriever"

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

Можно реализовать с помощью переопределения методов в подклассах, чтобы они имели различное поведение, но имели одинаковую сигнатуру. Вот пример:

// Базовый класс
class Animal {
  constructor(name) {
    this.name = name
  }
 
  speak() {
    console.log(`${this.name} makes a sound.`)
  }
}
 
// Подкласс, наследующий от базового класса Animal
class Dog extends Animal {
  constructor(name, breed) {
    super(name)
 
    this.breed = breed
  }
 
  speak() {
    console.log(`${this.name} barks.`)
  }
}
 
// Подкласс, наследующий от базового класса Animal
class Cat extends Animal {
  constructor(name, color) {
    super(name)
 
    this.color = color
  }
 
  speak() {
    console.log(`${this.name} meows.`)
  }
}
 
// Создание экземпляров классов
const dog = new Dog("Buddy", "Golden Retriever")
const cat = new Cat("Whiskers", "Gray")
 
dog.speak() // "Buddy barks."
cat.speak() // "Whiskers meows."

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

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

// Абстрактный класс, представляющий фигуру
class Shape {
  constructor() {
    if (new.target === Shape) {
      throw new Error("Cannot instantiate abstract class.")
    }
  }
 
  // Абстрактный метод, представляющий вычисление площади
  calculateArea() {
    throw new Error("Method not implemented.")
  }
}
 
// Класс, представляющий прямоугольник
class Rectangle extends Shape {
  constructor(width, height) {
    super()
    this.width = width
    this.height = height
  }
 
  calculateArea() {
    return this.width * this.height
  }
}
 
// Класс, представляющий круг
class Circle extends Shape {
  constructor(radius) {
    super()
    this.radius = radius
  }
 
  calculateArea() {
    return Math.PI * this.radius * this.radius
  }
}
 
// Создание экземпляров классов
const rectangle = new Rectangle(5, 10)
const circle = new Circle(7)
 
console.log(rectangle.calculateArea()) // 50
console.log(circle.calculateArea()) // ~153.94

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

Навигация

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

Упоминания со ссылкой