ობიექტზე ორიენტირებული პროგრამირება ეფუძნება ოთხ ძირითად პრინციპს — ინკაპსულაცია, მემკვიდრეობა, პოლიმორფიზმი და აბსტრაქცია. Java აგებულია ამ საფუძველზე, და მათი გაგება აუცილებელია Java პროგრამების დიზაინისთვის.
{
balance;
{
(amount > ) balance += amount;
}
{ balance; }
}
ინკაპსულაცია ფარავს შიგნით მდგომარეობას (private) და ასაჯაროებს კონტროლირებულ წვდომას (საჯაროო მეთოდები/getter/setter). ეს ინვარიანტებს იცავს — თქვენ არ შეგიძლიათ უარყოფითი ბალანსი პირდაპირ დააყენოთ — და საშუალებას გაძლევთ შიგნით ნაწილი შეცვალოთ დამწოდებელი გარეშე.
class Animal {
void eat() { System.out.println("eating"); }
}
class Dog extends Animal { // Dog IS-A Animal — inherits eat()
void bark() { System.out.println("woof"); }
}
მემკვიდრეობა საშუალებას აძლევს ქვეკლასს თავიდან გამოიყენოს და გაფართოოს სამეფო კლასის ქცევა, მოდელირებაა "is-a" ურთიერთობებისა და კოდის დუბლირებისგან თავის აშორება.
Animal a = new Dog(); // a Dog treated as an Animal
a.makeSound(); // calls Dog's overridden version at RUNTIME (dynamic dispatch)
// the same method behaves differently depending on the actual object:
List<Animal> animals = List.of(new Dog(), new Cat());
for (Animal animal : animals) animal.makeSound(); // each makes its own sound
პოლიმორფიზმი საშუალებას გაძლევთ სხვადსხვა ქვეკლასებს ჯამურად განიხილოთ საერთო ტიპის მეშვეობით, რეალური ობიექტის გადანიშნული მეთოდი რომელიც იძახება runtime-ზე — დინამიური, გაფართოვადი კოდის ხელმისაწვდომობა.
interface PaymentProcessor {
void pay(double amount); // WHAT it does, not HOW
}
class StripeProcessor implements PaymentProcessor {
public void pay(double amount) { /* complex implementation hidden */ }
}
// callers depend on the abstraction, not the concrete implementation
PaymentProcessor processor = new StripeProcessor();
აბსტრაქცია (ინტერფეისების/აბსტრაქტული კლასების მეშვეობით) ასაჯაროებს გამარტივებულ ხელშეკრულებას დახვეწილი განხორციელების დამალვის დროს — საშუალებას გაძლევთ განხორციელებების შეცვლა და დეკოპლინგის შემცირება.
ოთხი სვეტი ობიექტზე ორიენტირებული დიზაინისა და თავად Java-ს საფუძველია.
ინკაპსულაცია იცავს მონაცემთა სისტემურობას და ხელმისაწვდომლობას უსაფრთხო ცვლილებების; მემკვიდრეობა წაქმნის კოდის ხელახლა გამოყენებას; პოლიმორფიზმი უმცროვანი მოქნილობა და გაფართოვადობა (მრავალი ტიპის გამელნივე განხილვა, ქცევა runtime-ზე გადაჭრილი); აბსტრაქცია კლებს დეკოპლინგს და სირთულეს.
მათი გაგება არ არის მხოლოდ ტერმინოლოგია — ეს კითხვებში მოძღვნის თუ როგორ სტრუქტურირებული თქვენი კლასებს, რა არის API დიზაინი და როგორ აგებულია აღმავალი, გაფართოვადი სისტემა.
ისინი ასევე ერთ-ერთი ყველაზე ხშირი ინტერვიუს თემაა, რადგან ისინი ნაჩვენებია თუ ხომ დეველოპერი ფიქრობს სწორი OOP ტერმინოლოგიით, რაც აუცილებელია Java-ს კლასზე დაფუძნებულ ეკოსისტემაში ეფექტიანად მუშაობის თვალსაზრისით.
IT გასაუბრების კითხვების ბიბლიოთეკა დეტალური პასუხებით — Junior-დან Senior-მდე.
შემოწირულობა