Розділ[14]: Розуміння поліморфізму в Java: реальний погляд - javascript.org.ua

Дизайн від Freepik

Поліморфізм може звучати як складний термін, але насправді це простий і потужний концепт. Це одна з основ об'єктно-орієнтованого програмування (OOP). Термін "поліморфізм" походить від грецьких слів "poly" (багато) та "morph" (форми). Це означає, що об'єкти можуть набувати різних форм, роблячи наш код гнучким, багаторазовим та масштабованим. Давайте розглянемо, що це таке, на простому прикладі.

Що таке поліморфізм?

У Java поліморфізм дозволяє виконувати одну й ту ж дію по-різному, залежно від об'єкта, що її викликає. Звучить цікаво, правда? Це дуже практично і відбувається у двох основних формах:

Поліморфізм на етапі компіляції (Перевантаження методів - Method Overloading): Це коли ви визначаєте кілька методів із однаковою назвою, але з різними списками параметрів у межах одного класу.
Поліморфізм на етапі виконання (Перевизначення методів - Method Overriding): Це коли підклас надає власну специфічну реалізацію методу, вже визначеного у його батьківському класі. Тут фактичний метод, що викликається, визначається під час виконання програми.

Реальний сценарій: Система оплати

Давайте уявимо платформу електронної комерції, таку як Flipkart або Amazon. Клієнти можуть здійснювати оплату за допомогою різних методів — кредитних карток, дебетових карток або цифрових гаманців. Хоча загальна ідея "здійснення платежу" залишається тією ж, кожен метод має унікальний спосіб обробки транзакції. І тут на допомогу приходить поліморфізм!

1. Поліморфізм на етапі компіляції (Перевантаження методів)

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

class PaymentProcessor {  
 // Метод для обробки платежу за допомогою картки  
 void processPayment(String cardNumber, String expiryDate, double amount) {  
 System.out.println("Обробка платежу за карткою: " + cardNumber);  
 }  

 // Перевантажений метод для обробки платежу через гаманець  
 void processPayment(String walletId, double amount) {  
 System.out.println("Обробка платежу через цифровий гаманець: " + walletId);  
 }
}

Що тут відбувається? Обидва методи називаються processPayment, але їх списки параметрів різні. Потрібний метод вибирається на етапі компіляції залежно від переданих аргументів.

2. Поліморфізм на етапі виконання (Перевизначення методів)

Тепер додамо індивідуальність. Кожен метод оплати (наприклад, кредитна картка або гаманець) має свій унікальний спосіб обробки платежів. Використовуючи перевизначення методів, ми можемо налаштувати поведінку для кожного типу оплати.

// Базовий клас  
class Payment {  
 void processPayment(double amount) {  
 System.out.println("Обробка загального платежу на суму $" + amount);  
 }  
}  

// Підклас для платежів кредитною карткою  
class CreditCardPayment extends Payment {  
 @Override  
 void processPayment(double amount) {  
 System.out.println("Обробка платежу кредитною карткою на суму $" + amount);  
 }  
}  

// Підклас для платежів через гаманець  
class WalletPayment extends Payment {  
 @Override  
 void processPayment(double amount) {  
 System.out.println("Обробка платежу через гаманець на суму $" + amount + " з включеним кешбеком!");  
 }  
}

Що тут інакше?

Батьківський клас Payment визначає загальний метод processPayment.
Підкласи (CreditCardPayment і WalletPayment) перевизначають цей метод, щоб забезпечити власну унікальну поведінку.

Використання поліморфізму в дії

Ось як це працює в реальному коді:

public class ECommercePlatform {  
 public static void main(String[] args) {  
 Payment payment;  

 // Платіж кредитною карткою  
 payment = new CreditCardPayment();  
 payment.processPayment(100.0);  

 // Платіж через гаманець  
 payment = new WalletPayment();  
 payment.processPayment(50.0);  
 }  
}

Результат:

Обробка платежу кредитною карткою на суму $100.0  
Обробка платежу через гаманець на суму $50.0 з включеним кешбеком!

Чому поліморфізм вартий уваги

1.
Гнучкість: Ви можете додавати нові методи оплати (наприклад, UPI), не порушуючи або змінюючи існуючий код.
2. Повторне використання: Методи батьківського класу можуть бути повторно використані, зменшуючи дублювання.
3. Масштабованість: Ваш код може легко адаптуватися до нових вимог шляхом перевизначення методів.

Давайте розглянемо помилки під час перевантаження методів і можливі рішення.

Проблема

Припустимо, ви створюєте систему CardPayment, подібну до наведеної вище, для обробки платежів. Ви починаєте з методу для обробки платежу однією карткою, наприклад:

public String processPayment(String cardNumber) {  
 return "Обробка платежу для картки: " + cardNumber;  
}

Тепер ви думаєте: “А що, якщо я хочу додати ще один метод для обробки платежу однією карткою, але повертати суму платежу як int, а не String?”

public int processPayment(String digitalCardNumber) {  
 return 100; // Фіксована сума платежу  
}

Але ось вибухає 🚨 Java видає помилку компіляції.

Чому?

Java не дозволяє перевантаження, яке базується виключно на типі повернення значення та різних назвах змінних. Сигнатура методу (processPayment(String)) однакова для обох методів, тому компілятор плутається, навіть якщо їхні типи повернення і назви параметрів різні (String проти int і cardNumber проти digitalCardNumber).

Рішення

Щоб правильно перевантажити метод, потрібно змінити параметри, а не лише тип повернення. Ось як це виправити:

class CardPayment {  
 // Метод 1: Обробка платежу однією карткою  
 public String processPayment(String cardNumber) {  
 return "Обробка платежу для картки: " + cardNumber;  
 }  

 // Метод 2: Обробка платежу карткою та сумою  
 public String processPayment(String cardNumber, double amount) {  
 return "Обробка платежу на суму $" + amount + " для картки: " + cardNumber;  
 }  

 // Метод 3: Обробка платежу декількома картками  
 public String processPayment(String[] cardNumbers) {  
 return "Обробка платежу для " + cardNumbers.length + " карток.";  
 }  
}

Використання

Ось як можна викликати ці перевантажені методи:

public class Main {  
 public static void main(String[] args) {  
 CardPayment paymentProcessor = new CardPayment();  

 // Платіж однією карткою  
 System.out.println(paymentProcessor.processPayment("1234-5678-9012-3456"));  
 // Платіж однією карткою із зазначенням суми  
 System.out.println(paymentProcessor.processPayment("1234-5678-9012-3456", 150.75));  
 // Платіж декількома картками  
 String[] cards = { "1234-5678-9012-3456", "9876-5432-1098-7654" };  
 System.out.println(paymentProcessor.processPayment(cards));  
 }  
}

Результат

Обробка платежу для картки: 1234-5678-9012-3456  
Обробка платежу на суму $150.75 для картки: 1234-5678-9012-3456  
Обробка платежу для 2 карток.

Основні висновки

1: Правило: Перевантаження вимагає різних параметрів, а не лише різних типів повернення.

Наприклад, ось так не спрацює:

public String processPayment(String cardNumber);   
public int processPayment(String cardNumber);

2: Правильне перевантаження: Змінюйте кількість або тип параметрів. Наприклад:

Додайте другий параметр (String cardNumber, double amount).
Використовуйте інший тип (String[] cardNumbers).

3: Уникайте неоднозначності:

Якщо перевантажуєте з подібними типами параметрів (наприклад, String і Object), переконайтеся, що виклики є однозначними, щоб уникнути плутанини.

Поліморфізм робить ваш код чистішим і розумнішим! У нашій системі оплати він допоміг легко обробляти різні типи платежів. Великі додатки, як-от сервіси для виклику таксі або банківські системи, використовують цей концепт для ефективного управління безліччю дій. Оволодівши цим принципом, ви зможете писати код, який не лише чистий, але й готовий до зростання та адаптації. Є питання чи хочете більше прикладів? Продовжимо обговорення!

Знайдіть і завантажте код тут

Веселого кодування!

Перекладено з: Chapter[14]: Understanding Polymorphism in Java: A Real-World Perspective