Перевизначення методів і поліморфізм · fullstack.org.ua

Середній16 хв· Fullstack Team

Перевизначення методів і поліморфізм

Перевизначатимете методи та використовуватимете поліморфізм для єдиного інтерфейсу різних типів об’єктів.

Перевизначення методів

Перевизначення методу — це створення в дочірньому класі методу з таким самим ім’ям, як у батьківському класі, але з іншою реалізацією.

Дочірній клас успадковує метод, якщо не оголошує власну версію. Якщо ж метод оголошено в дочірньому класі, JavaScript використовує саме його.

javascript

class User {
  constructor(name) {
    this.name = name;
  }

  getRole() {
    return "Користувач";
  }

  describe() {
    return `${this.name}: ${this.getRole()}`;
  }
}

class Admin extends User {
  getRole() {
    return "Адміністратор";
  }
}

class Moderator extends User {
  getRole() {
    return "Модератор";
  }
}

const user = new User("Олена");
const admin = new Admin("Андрій");
const moderator = new Moderator("Марія");

console.log(user.describe());      // Олена: Користувач
console.log(admin.describe());     // Андрій: Адміністратор
console.log(moderator.describe()); // Марія: Модератор

javascript

class Employee {
  constructor(name) {
    this.name = name;
  }

  introduce() {
    return `Мене звати ${this.name}.`;
  }
}

class Developer extends Employee {
  constructor(name, language) {
    super(name);
    this.language = language;
  }

  introduce() {
    const parentMessage = super.introduce();

    return `${parentMessage} Я розробник і пишу мовою ${this.language}.`;
  }
}

const developer = new Developer("Ірина", "JavaScript");

console.log(developer.introduce());
// Мене звати Ірина. Я розробник і пишу мовою JavaScript.

javascript

class CardPayment {
  constructor(cardNumber) {
    this.cardNumber = cardNumber;
  }

  pay(amount) {
    const lastFourDigits = this.cardNumber.slice(-4);

    return `Оплачено ${amount} грн карткою ****${lastFourDigits}`;
  }
}

class CashPayment {
  pay(amount) {
    return `Оплачено ${amount} грн готівкою`;
  }
}

class PayPalPayment {
  constructor(email) {
    this.email = email;
  }

  pay(amount) {
    return `Оплачено ${amount} грн через PayPal (${this.email})`;
  }
}

function processPayment(paymentMethod, amount) {
  console.log(paymentMethod.pay(amount));
}

const payments = [
  new CardPayment("4111111111111111"),
  new CashPayment(),
  new PayPalPayment("customer@example.com")
];

for (const payment of payments) {
  processPayment(payment, 1000);
}

javascript

class Notification {
  constructor(message) {
    this.message = message;
  }

  send() {
    throw new Error("Метод send() має бути перевизначений");
  }
}

class EmailNotification extends Notification {
  constructor(email, message) {
    super(message);
    this.email = email;
  }

  send() {
    return `Email надіслано на ${this.email}: ${this.message}`;
  }
}

class SmsNotification extends Notification {
  constructor(phone, message) {
    super(message);
    this.phone = phone;
  }

  send() {
    return `SMS надіслано на ${this.phone}: ${this.message}`;
  }
}

class PushNotification extends Notification {
  constructor(deviceId, message) {
    super(message);
    this.deviceId = deviceId;
  }

  send() {
    return `Push-сповіщення надіслано на пристрій ${this.deviceId}: ${this.message}`;
  }
}

function sendNotifications(notifications) {
  for (const notification of notifications) {
    console.log(notification.send());
  }
}

const notifications = [
  new EmailNotification(
    "user@example.com",
    "Ваше замовлення прийнято"
  ),
  new SmsNotification(
    "+380501234567",
    "Кур’єр уже прямує до вас"
  ),
  new PushNotification(
    "device-123",
    "Замовлення доставлено"
  )
];

sendNotifications(notifications);

javascript

class Shape {
  getArea() {
    throw new Error("Метод getArea() не реалізовано");
  }
}

class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
  }

  getArea() {
    return this.width * this.height;
  }
}

const rectangle = new Rectangle(4, 5);

console.log(rectangle.getArea()); // 20

javascript

const square = {
  getArea() {
    return 5 * 5;
  }
};

const circle = {
  getArea() {
    return Math.PI * 3 ** 2;
  }
};

function printArea(shape) {
  console.log(`Площа: ${shape.getArea()}`);
}

printArea(square);
printArea(circle);

javascript

class Animal {
  speak() {
    return "Тварина видає звук";
  }
}

class Dog extends Animal {
  speak() {
    return "Гав-гав";
  }
}

const dog = new Dog();

console.log(dog.speak()); // Гав-гав

javascript

class Animal {
  speak() {
    return "Тварина видає звук";
  }
}

class Dog extends Animal {}

const dog = new Dog();

console.log(dog.speak()); // Тварина видає звук

javascript

function sendNotification(type, data) {
  if (type === "email") {
    // Логіка email
  } else if (type === "sms") {
    // Логіка SMS
  } else if (type === "push") {
    // Логіка push
  }
}

javascript

function calculateArea(shape) {
  if (shape instanceof Rectangle) {
    return shape.width * shape.height;
  }

  if (shape instanceof Circle) {
    return Math.PI * shape.radius ** 2;
  }

  throw new Error("Невідома фігура");
}

javascript

function processPayment(payment) {
  if (typeof payment.pay !== "function") {
    throw new TypeError("Об’єкт не підтримує метод pay()");
  }

  return payment.pay(100);
}

javascript

class Counter {
  constructor() {
    this.value = 0;
  }

  increment() {
    this.value += 1;
  }
}

const counter = new Counter();
const increment = counter.increment;

// increment(); // this буде undefined у strict mode

Перевизначення методів і поліморфізм