ძირითადი განსხვავება – მემკვიდრეობა და ინტერფეისი ჯავაში
Java არის პროგრამირების ენა, რომელიც შემუშავებულია Sun Microsystems-ის მიერ. Java შეიძლება გამოყენებულ იქნას სხვადასხვა აპლიკაციების შესაქმნელად. ეს არის მრავალ პარადიგმური ენა, რომელიც მხარს უჭერს ობიექტზე ორიენტირებულ, სტრუქტურირებულ და ა.შ. Java-ს მთავარი უპირატესობა ის არის, რომ იგი მხარს უჭერს ობიექტზე ორიენტირებულ პროგრამირებას (OOP). პროგრამისტს შეუძლია შექმნას კლასები და ობიექტები. OOP-ში ოთხი საყრდენია. ეს არის მემკვიდრეობა, პოლიმორფიზმი, აბსტრაქცია და ინკაფსულაცია. მემკვიდრეობა და ინტერფეისები დაკავშირებულია OOP-თან. მემკვიდრეობასა და ინტერფეისს შორის მთავარი განსხვავება ისაა, რომ მემკვიდრეობა არის ახალი კლასების გამოყვანა არსებული კლასებიდან და ინტერფეისი არის აბსტრაქტული კლასების და მრავალჯერადი მემკვიდრეობის განხორციელება.
რა არის მემკვიდრეობა ჯავაში?
მემკვიდრეობამ შეიძლება მიაღწიოს კოდის ხელახლა გამოყენებადობას. მემკვიდრეობა ხელს უწყობს არსებული კლასის ატრიბუტებისა და მეთოდების ხელახლა გამოყენებას. ძველი კლასის გამოყენებით ახალი კლასის გამოყვანის მექანიზმს ეწოდება მემკვიდრეობა. ძველი კლასი ცნობილია როგორც მშობელი კლასი ან სუპერ კლასი. მიღებულ კლასს ეწოდება ბავშვის კლასი ან ქვეკლასი.
ჯავას მემკვიდრეობის სინტაქსი ასეთია.
class subclass_name აფართოებს სუპერკლასის_სახელს {
ცვლადი დეკლარაცია;
მეთოდის დეკლარაცია;
}
მემკვიდრეობის კონცეფცია შეიძლება აიხსნას შემდეგი მაგალითის გამოყენებით. დავუშვათ, რომ არსებობს კლასი სახელწოდებით A შემდეგნაირად.
საჯარო კლასი A{
public void sum(){
System.out.println("ჯამ");
}
}
თუ გვსურს დავამატოთ ახალი მეთოდი არსებული კლასის შეცვლის გარეშე, შეგვიძლია ამის გაკეთება შემდეგნაირად.
საჯარო კლასი B{
public void sub(){
System.out.println("ქვე");
}
}
პროგრამატორს შეუძლია გამოიყენოს მემკვიდრეობა კლასის A sum().
საჯარო B კლასი აფართოებს A კლასს{
public void sub(){
System.out.println("ქვე");
}
}
მთავარ ფუნქციაში შესაძლებელია შევქმნათ B-ის ობიექტი და გამოძახოთ sub(), რომელიც ეკუთვნის B კლასს და sum(), რომელიც ეკუთვნის A კლასს მემკვიდრეობის გამოყენებით.
საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები){
B obj=ახალი B();
obj.sub();
obj.sum();
}
არსებობს სხვადასხვა სახის მემკვიდრეობა. ეს არის ერთჯერადი მემკვიდრეობა, მრავალჯერადი მემკვიდრეობა, მრავალ დონის მემკვიდრეობა და იერარქიული მემკვიდრეობა. ერთჯერადი მემკვიდრეობით, არის ერთი საბაზისო კლასი და ერთი წარმოებული კლასი.მრავალ დონის მემკვიდრეობაში, არსებობს სამი კლასი, კერძოდ, საბაზისო კლასი, შუალედური კლასი და მიღებული კლასი. შუალედური კლასი მემკვიდრეობით იღებს საბაზისო კლასს, ხოლო მიღებული კლასი იღებს მემკვიდრეობას შუალედური კლასისგან. იერარქიულ მემკვიდრეობაში არის ერთი საბაზისო კლასი და მრავალი წარმოებული კლასი. არსებობს სპეციალური ტიპი, რომელიც ცნობილია როგორც ჰიბრიდული მემკვიდრეობა. ეს არის ორი ან მეტი ტიპის მემკვიდრეობის კომბინაცია.
სურათი 01: მემკვიდრეობა
მრავალჯერადი მემკვიდრეობის დროს არის მრავალი საბაზისო კლასი და ერთი მიღებული კლასი. დავუშვათ, რომ კლასი A და B არის საბაზისო კლასები. კლასი C არის მიღებული კლასი. თუ A და B კლასებს აქვთ ერთი და იგივე მეთოდი და პროგრამისტი გამოიძახებს ამ მეთოდს მიღებული კლასიდან, ეს გამოიწვევს გაურკვევლობის პრობლემას. ორი კლასის მემკვიდრეობამ შეიძლება გამოიწვიოს კომპილაციის დროის შეცდომა.ამიტომ, მრავალჯერადი მემკვიდრეობა არ არის მხარდაჭერილი Java-ში. ამ პრობლემის დასაძლევად შეიძლება გამოყენებულ იქნას ინტერფეისი.
რა არის ინტერფეისი ჯავაში?
აბსტრაქცია არის განხორციელების დეტალების დამალვის და მომხმარებლისთვის მხოლოდ ფუნქციების ჩვენების პროცესი. აბსტრაქციის მიღწევა შესაძლებელია აბსტრაქტული კლასების ან ინტერფეისების გამოყენებით. აბსტრაქტული მეთოდი არის მეთოდი განხორციელების გარეშე. კლასი, რომელსაც აქვს მინიმუმ ერთი აბსტრაქტული მეთოდი, არის აბსტრაქტული კლასი. აბსტრაქტული კლასის მაგალითი ასეთია.
აბსტრაქტული კლასი A{
აბსტრაქტული void sum();
}
ვუშვათ, რომ არსებობს ორი აბსტრაქტული კლასი, როგორც A და B. A და B აბსტრაქტული მეთოდების განსახორციელებლად, იქმნება ახალი კლასი C. შემდეგ კლასი C უნდა გაფართოვდეს როგორც A, ასევე B., მაგრამ მრავალჯერადი მემკვიდრეობა არ არის მხარდაჭერილი Java-ში. ამიტომ, უნდა გამოიყენოთ ინტერფეისები. ინტერფეისები შეიძლება გამოვიყენოთ მეთოდების გამოცხადებისთვის, მაგრამ მეთოდების განსაზღვრა შეუძლებელია. შეუძლებელია ობიექტის შექმნა ინტერფეისების გამოყენებით. C კლასმა უნდა განახორციელოს ყველა მეთოდი A და B ინტერფეისში.
ინტერფეისი A{
void sum();
}
ინტერფეისი B{
void sub();
}
კლასი C ახორციელებს A, B{
public void sum(){
System.out.println("Summation");
}
public void sub(){
System.out.println("გამოკლება");
}
}
ახლა, მთავარ პროგრამაში შესაძლებელია C-ის ობიექტის შექმნა და ორივე მეთოდის გამოძახება.
public static void main (სტრიქონი args) {
C obj=ახალი C();
obj.sum();
obj.sub();
}
ასე რომ, ინტერფეისების გამოყენება შესაძლებელია მრავალჯერადი მემკვიდრეობის დასანერგად.
ინტერფეისების კიდევ ერთი გამოყენება არის ის, რომ ის უზრუნველყოფს უსაფრთხოებას. იხილეთ ქვემოთ მოცემული კოდი.
ინტერფეისი A {
ბათილი ჯამი ();
}
კლასი B ახორციელებს A {
საჯარო ბათილი ჯამი () {
System.out.println("Summation");
}
საჯარო ბათილობის გამრავლება () {
System.out.println(„გამრავლება“);
}
}
B-ის ობიექტის შექმნისას შესაძლებელია ორივე მეთოდის გამოძახება ჯამი () და გამრავლება (). თუ პროგრამისტს სურს შეზღუდოს გამრავლების () ფუნქციის გამოყენებით, ეს შესაძლებელია შემდეგნაირად.
საჯარო სტატიკური სიცარიელე მთავარი (სტრიქონი არგები){
A obj=new B();
obj.sum();
}
A obj=ახალი B(); შექმნის ობიექტს. ის არის A ტიპის და მეხსიერება გამოყოფილია როგორც B. შესაძლებელია sum()-ის გამოძახება, მაგრამ გამრავლების() შესრულება შეუძლებელია. ეს შეზღუდვა კეთდება ინტერფეისების გამოყენებით.
რა მსგავსებაა მემკვიდრეობასა და ინტერფეისს შორის Java-ში?
- ორივე კონცეფცია დაკავშირებულია ობიექტზე ორიენტირებულ პროგრამირებასთან
- ორივე წარმოადგენს IS-A ურთიერთობას.
რა განსხვავებაა მემკვიდრეობასა და ინტერფეისს შორის Java-ში?
მემკვიდრეობა vs ინტერფეისი ჯავაში |
|
| მემკვიდრეობა არის OOP კონცეფცია არსებული კლასებიდან ახალი კლასების გამოსაყვანად. | ინტერფეისი არის მექანიზმი OOP-ში აბსტრაქციისა და მრავალჯერადი მემკვიდრეობის განსახორციელებლად. |
| გამოყენება | |
| მემკვიდრეობა უზრუნველყოფს კოდის ხელახლა გამოყენებას. | ინტერფეისები უზრუნველყოფს აბსტრაქციას და მრავალჯერად მემკვიდრეობას. |
რეზიუმე – მემკვიდრეობა vs ინტერფეისი ჯავაში
Java არის მრავალ პარადიგმული პროგრამირების ენა, რომელიც მხარს უჭერს ობიექტზე ორიენტირებულ პროგრამირებას.მემკვიდრეობა და ინტერფეისები დაკავშირებულია ობიექტზე ორიენტირებულ პროგრამირებასთან. განსხვავება მემკვიდრეობასა და ინტერფეისს შორის არის ის, რომ მემკვიდრეობა არის ახალი კლასების გამოყვანა არსებული კლასებიდან და ინტერფეისები არის აბსტრაქტული კლასების და მრავალჯერადი მემკვიდრეობის განხორციელება.
ჩამოტვირთეთ მემკვიდრეობის PDF ვერსია Java-ში ინტერფეისის წინააღმდეგ
შეგიძლიათ ჩამოტვირთოთ ამ სტატიის PDF ვერსია და გამოიყენოთ იგი ოფლაინ მიზნებისთვის ციტირების შენიშვნის მიხედვით. გთხოვთ ჩამოტვირთოთ PDF ვერსია აქ სხვაობა მემკვიდრეობასა და ინტერფეისს შორის Java-ში
