1. Спадкування: Потужність повторного використання коду
Спадкування дозволяє одному класу успадковувати властивості та поведінку від іншого, що сприяє повторному використанню коду та зменшує надмірність.
Чому це важливо?
На інтерв'ю з Java вам часто запитають, як спадкування допомагає з повторним використанням коду та структурою. Це дозволяє писати більш зручний для обслуговування та модульний код.
Простий приклад: Уявімо базовий клас Vehicle, а потім підкласи Car та Truck, які успадковують від нього.
class Vehicle {
String make;
String model;
public Vehicle(String make, String model) {
this.make = make;
this.model = model;
}
public void displayInfo() {
System.out.println(make + " " + model);
}
}
class Car extends Vehicle {
String carType;
public Car(String make, String model, String carType) {
super(make, model);
this.carType = carType;
}
}
class Truck extends Vehicle {
int payload;
public Truck(String make, String model, int payload) {
super(make, model);
this.payload = payload;
}
}
public class Main {
public static void main(String[] args) {
Car car = new Car("Toyota", "Corolla", "Sedan");
Truck truck = new Truck("Ford", "F-150", 1500);
car.displayInfo(); // Виведення: Toyota Corolla
truck.displayInfo(); // Виведення: Ford F-150
}
}
Тут класи Car і Truck успадковують від класу Vehicle і використовують метод displayInfo().
2. Поліморфізм: Один інтерфейс, кілька поведінок
Поліморфізм дозволяє викликати один і той самий метод на об'єктах різних типів, при цьому поведінка буде відрізнятися залежно від типу об'єкта.
Чому це важливо?
Поліморфізм робить системи більш гнучкими. На інтерв'ю вас можуть запитати, як він дозволяє писати універсальний код, який працює з багатьма типами, не знаючи точний тип об'єкта.
Простий приклад: Уявімо, що у вас є різні типи тварин, кожна з яких видає свій звук.
class Animal {
public void makeSound() {
// За умовчанням
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Gav");
}
}
class Cat extends Animal {
@Override
public void makeSound() {
System.out.println("Miau");
}
}
public class Main {
public static void main(String[] args) {
Animal dog = new Dog();
Animal cat = new Cat();
dog.makeSound(); // Виведення: Gav
cat.makeSound(); // Виведення: Miau
}
}
Класи Dog і Cat перевизначають метод makeSound(), але коли ви викликаєте цей метод через посилання на об'єкт типу Animal, він веде себе по-різному, залежно від того, чи вказує воно на Dog чи на Cat.
3. Інкапсуляція: Захист ваших даних
Інкапсуляція полягає в тому, щоб згрупувати дані (змінні) і методи, які працюють з даними, в одному об'єкті (класі), при цьому обмежити прямий доступ до деяких компонентів об'єкта.
Це забезпечує, що дані можна змінювати лише контрольованим способом.
Чому це важливо?
На інтерв'ю інкапсуляція часто пояснюється з точки зору підтримки цілісності даних і контролю доступу до стану об'єкта, що робить ваш код менш схильним до помилок і більш безпечним.
Простий приклад: Уявімо, що ви хочете створити клас BankAccount, де баланс рахунку не можна отримати безпосередньо.
class BankAccount {
private double balance; // Приватна змінна
public BankAccount(double balance) {
this.balance = balance;
}
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
}
}
public double getBalance() {
return balance;
}
}
public class Main {
public static void main(String[] args) {
BankAccount account = new BankAccount(500);
account.deposit(200);
account.withdraw(100);
System.out.println("Current balance: " + account.getBalance()); // Виведення: Current balance: 600.0
}
}
Тут, balance інкапсульовано (він є приватним) і може бути змінений лише через методи deposit і withdraw, що гарантує безпечний доступ до балансу.
4. Абстракція: Спрощення складних систем
Абстракція полягає у приховуванні складних деталей реалізації та показі лише суттєвих функцій. Це допомагає зосередитись на тому, що об'єкт робить, а не як саме він це робить.
Чому це важливо?
На інтерв'ю абстракція підкреслюється, оскільки вона дозволяє розробникам управляти складністю. Використовуючи абстрактні класи або інтерфейси, системи можна спростити і зробити їх модульними.
Простий приклад: Уявімо, що у вас є абстрактний клас Car з абстрактними методами start() і stop(). Потім, у вас є різні типи автомобілів, які реалізують ці методи.
abstract class Car {
public abstract void start();
public abstract void stop();
}
class ElectricCar extends Car {
@Override
public void start() {
System.out.println("Electric car is starting with a button push.");
}
@Override
public void stop() {
System.out.println("Electric car is stopping.");
}
}
class GasCar extends Car {
@Override
public void start() {
System.out.println("Gas car is starting with a key turn.");
}
@Override
public void stop() {
System.out.println("Gas car is stopping.");
}
}
public class Main {
public static void main(String[] args) {
Car electricCar = new ElectricCar();
Car gasCar = new GasCar();
electricCar.start(); // Виведення: Electric car is starting with a button push.
gasCar.start(); // Виведення: Gas car is starting with a key turn.
}
}
Тут клас Car абстрагує концепцію запуску і зупинки автомобіля, залишаючи деталі реалізації для підкласів ElectricCar і GasCar. Користувач не повинен знати, як саме автомобіль запускається, йому достатньо викликати метод start().
Підсумок
Якщо цей матеріал був корисний, не забудьте поставити лайк і підписатися для отримання більше корисних постів, кращих практик кодування та інших технічних тем, які допоможуть вам підвищити свої навички програмування. У наступній статті ми докладно розглянемо типи поліморфізму на найпростіший спосіб — це також одне з найпоширеніших питань на інтерв'ю. Тому обов'язково підписуйтесь на оновлення!
Будь ласка, перейдіть за цим посиланням https://medium.com/towardsdev/method-overloading-vs-overriding-in-oop-a-complete-guide-for-interviews-2025-566f1ec14cd5 для розуміння концепцій перевантаження та перевизначення методів.
Перекладено з: How to Answer the Top OOP Interview Questions on Inheritance, Polymorphism, Encapsulation & Abstraction (2025 Guide)