logo

TechCodeview

„Java“ abstrakčios klasės ir sąsajos skirtumas

Abstrakti klasė ir sąsaja yra naudojamos sutartims apibrėžti objektinio programavimo metu, tačiau tarp jų yra keletas pagrindinių skirtumų.

Skirtumas tarp abstrakčios klasės ir sąsajos: -

Apibrėžimas: abstrakčioji klasė yra klasė, kurios negalima kartoti ir kurioje gali būti tiek abstrakčių, tiek neabstrakčių metodų. Kita vertus, sąsaja yra sutartis, nurodanti metodų rinkinį, kurį klasė turi įgyvendinti.



Metodo įgyvendinimas: Abstrakčioje klasėje kai kurie metodai gali būti įgyvendinami, o kiti paliekami abstrakčiai, o tai reiškia, kad jie neturi įgyvendinimo ir turi būti pakeisti konkrečiais poklasiais. Priešingai, visi sąsajos metodai pagal numatytuosius nustatymus yra abstraktūs ir juos turi įgyvendinti bet kuri sąsają įgyvendinanti klasė.

Paveldėjimas: klasė gali paveldėti tik iš vienos abstrakčios klasės, tačiau ji gali įdiegti kelias sąsajas. Taip yra todėl, kad abstrakčioji klasė reiškia objekto tipą, o sąsaja – elgesio rinkinį.

Prieigos modifikatoriai: abstrakčios klasės gali turėti savo metodų ir savybių prieigos modifikatorius, pvz., viešą, apsaugotą ir privačią, o sąsajos gali turėti tik viešą prieigą.

Kintamieji: abstrakčioje klasėje gali būti narių kintamųjų, o sąsajoje – ne.

Apibendrinant galima pasakyti, kad abstrakčios klasės naudojamos tam, kad būtų pateikta bazinė klasė konkrečių poklasių paveldėjimui, o sąsajos naudojamos apibrėžti metodų rinkinį, kurį klasė turi įgyvendinti. Abstrakčios klasės gali turėti realizuotus ir abstrakčius metodus, o sąsajos gali turėti tik abstrakčius metodus. Klasės gali paveldėti tik iš vienos abstrakčios klasės, tačiau gali įdiegti kelias sąsajas.

Kaip žinome, abstrakcija reiškia vidinio funkcijos diegimo slėpimą ir tik funkcionalumo rodymą vartotojams. y., rodomos tik reikalingos funkcijos, ir slepiama, kaip tos funkcijos įgyvendinamos užkulisiuose. Tuo tarpu sąsaja yra dar vienas būdas pasiekti „Java“ abstrakciją. Abu abstrakti klasė ir sąsaja yra naudojami abstrakcijai, nuo šiol sąsaja ir abstrakčioji klasė yra būtinos sąlygos.

Abstrakti klasė prieš sąsają

Abstrakti klasė prieš sąsają

  • Metodų tipai: Sąsaja gali turėti tik abstrakčius metodus. Tuo tarpu abstrakčioji klasė gali turėti abstraktų metodą ir konkrečius metodus. Iš „Java 8“ jis taip pat gali turėti numatytuosius ir statinius metodus. Iš „Java 9“ ji taip pat gali turėti privačių konkrečių metodų.
  • Pastaba: konkretūs metodai yra tie metodai, kurie turi visą savo apibrėžimą, tačiau jie taip pat gali būti nepaisyti paveldimoje klasėje. Tačiau jei konkretų metodą padarysime kaip FINALAS jo negalima nepaisyti paveldintoje klasėje, nes metodo paskelbimas galutine priemone - jos įgyvendinimas baigtas .
  • Galutiniai kintamieji: Kintamieji, deklaruoti „Java“ sąsajoje, pagal numatytuosius nustatymus yra galutiniai. Abstrakčioje klasėje gali būti negalutinių kintamųjų.
  • Kintamųjų tipai: Abstrakčioji klasė gali turėti galutinius, negalutinius, statinius ir nestatinius kintamuosius. Sąsaja turi tik statinius ir galutinius kintamuosius.
  • Įgyvendinimas: Abstrakti klasė gali suteikti sąsajos įgyvendinimą. Sąsaja negali įgyvendinti abstrakčios klasės.
  • Paveldėjimas prieš abstrakciją: Java sąsaja gali būti įdiegta naudojant raktinį žodį padargai o abstrakčią klasę galima išplėsti naudojant raktinį žodį tęsiasi .
  • Keli diegimai: Sąsaja gali išplėsti vieną ar daugiau Java sąsajų; abstrakčioji klasė gali išplėsti kitą Java klasę ir įdiegti kelias Java sąsajas.
  • Daugkartinis paveldėjimas: Daugkartinis paveldėjimas gali būti iš dalies pasiekiamas naudojant sąsajas, o to paties negalima padaryti naudojant abstrakčias klases. Kadangi „Java“ programoje viena klasė gali įdiegti kelias sąsajas, tačiau viena klasė negali išsiplėsti iš kelių kitų klasių, nes „Java“ tai tiesiog neįmanoma, nes tai sukeltų deimantų problemą.
  • Duomenų narių prieinamumas: Pagal numatytuosius nustatymus „Java“ sąsajos nariai (kintamieji) yra galutiniai. „Java“ abstrakčioje klasėje gali būti klasės narių, tokių kaip privatus, apsaugotas ir kt.

Abstrakčios klasės ypatybės: -

Abstrakčioji klasė yra specialus objektinio programavimo klasės tipas, kurio negalima tiesiogiai sukurti. Vietoj to, jis naudojamas kaip kitų klasių planas arba šablonas. Abstrakti klasė:

  1. Negalima kartoti : Abstrakčių klasių negalima tiesiogiai sukurti, o tai reiškia, kad negalite kurti abstrakčios klasės objektų.
  2. Yra bent viena gryna virtuali funkcija : abstrakčiose klasėse turi būti bent viena gryna virtuali funkcija, o tai reiškia, kad funkcija neįdiegta ir turi būti įgyvendinta bet kokiomis išvestinėmis klasėmis.
  3. Gali būti ir abstrakčių, ir neabstrakčių metodų : Abstrakčios klasės gali turėti ir abstrakčius, ir neabstrakčius metodus. Neabstraktūs metodai yra visiškai įgyvendinti ir gali būti iškviesti tiesiogiai.
  4. Gali turėti konstruktorius ir destruktorius : Abstrakčios klasės gali turėti konstruktorius ir naikintuvus, kaip ir bet kuri kita klasė.
  5. Gali turėti narių kintamuosius : Abstrakčios klasės gali turėti narių kintamuosius, kurie yra kintamieji, priklausantys klasės objektui.
  6. Galima naudoti kaip bazinę klasę : Abstrakčios klasės gali būti naudojamos kaip bazinė klasė kitoms klasėms, o tai reiškia, kad jas gali paveldėti kitos klasės.

Apskritai, abstrakčios klasės yra naudojamos apibrėžti bendrą sąsają arba elgesį, kurį gali bendrinti kelios susijusios klasės, tačiau kiekvienoje išvestinėje klasėje turi būti konkrečių diegimų.

1 pavyzdys: (abstrakčiai klasei)

Java 
abstract class sunstar {    abstract void printInfo(); } class employee extends sunstar {  void printInfo()  {  String name = 'avinash';  int age = 21;  float salary = 222.2F;  System.out.println(name);  System.out.println(age);  System.out.println(salary);  } } class base {  public static void main(String args[])  {  sunstar s = new employee();  s.printInfo();  } }>
Išvestis 
avinash 21 222.2>

2 pavyzdys: (abstrakčiai klasei)

Java 
// Java Program to Illustrate Concept of // Abstract Class // Importing required classes import java.io.*; // Class 1 // Helper abstract class abstract class Shape {  // Declare fields  String objectName = ' ';  // Constructor of this class  Shape(String name) { this.objectName = name; }  // Method  // Non-abstract methods  // Having as default implementation  public void moveTo(int x, int y)  {  System.out.println(this.objectName + ' '  + 'has been moved to'  + ' x = ' + x + ' and y = ' + y);  }  // Method 2  // Abstract methods which will be  // implemented by its subclass(es)  abstract public double area();  abstract public void draw(); } // Class 2 // Helper class extending Class 1 class Rectangle extends Shape {  // Attributes of rectangle  int length, width;  // Constructor  Rectangle(int length, int width, String name)  {  // Super keyword refers to current instance itself  super(name);  // this keyword refers to current instance itself  this.length = length;  this.width = width;  }  // Method 1  // To draw rectangle  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  // Method 2  // To compute rectangle area  @Override public double area()  {  // Length * Breadth  return (double)(length * width);  } } // Class 3 // Helper class extending Class 1 class Circle extends Shape {  // Attributes of a Circle  double pi = 3.14;  int radius;  // Constructor  Circle(int radius, String name)  {  // Super keyword refers to parent class  super(name);  // This keyword refers to current instance itself  this.radius = radius;  }  // Method 1  // To draw circle  @Override public void draw()  {  // Print statement  System.out.println('Circle has been drawn ');  }  // Method 2  // To compute circle area  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 4 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape class reference.  Shape rect = new Rectangle(2, 3, 'Rectangle');  System.out.println('Area of rectangle: '  + rect.area());  rect.moveTo(1, 2);  System.out.println(' ');  // Creating the Objects of circle class  Shape circle = new Circle(2, 'Circle');  System.out.println('Area of circle: '  + circle.area());  circle.moveTo(2, 4);  } }>
Išvestis 
Area of rectangle: 6.0 Rectangle has been moved to x = 1 and y = 2 Area of circle: 12.56 Circle has been moved to x = 2 and y = 4>

Ką daryti, jei neturime bendro kodo tarp stačiakampio ir apskritimo, tada eikite į sąsają.

Sąsaja:

Sąsajos ypatybės:

Sąsaja:

  1. Apibrėžia metodų ir savybių rinkinį: Sąsaja apibrėžia metodų ir savybių rinkinį, kurį turi įgyvendinti bet kuri sąsają įgyvendinanti klasė ar struktūra.
  2. Pateikiamas bendras protokolas: Sąsajos suteikia bendrą protokolą, leidžiantį skirtingiems programinės įrangos komponentams bendrauti tarpusavyje.
  3. Palaiko polimorfizmą: Polimorfizmui pasiekti galima naudoti sąsają, o tai reiškia, kad skirtingų klasių objektai gali būti traktuojami taip, lyg jie priklausytų tam pačiam tipui, jei tik jie įgyvendina tą pačią sąsają.
  4. Leidžia atskirti rūpesčius: Sąsajos leidžia atskirti problemas, o tai reiškia, kad skirtingos programinės įrangos sistemos dalys gali būti kuriamos nepriklausomai viena nuo kitos, jei tik jos atitinka sąsajos specifikacijas.
  5. Pagerina kodo pakartotinį naudojimą: Sąsajos pagerina kodo pakartotinį naudojimą, leisdamos skirtingiems programinės įrangos komponentams pakartotinai naudoti tą pačią kodo bazę, jei tik jie įgyvendina tą pačią sąsają.
  6. Įgyvendina dizaino modelius: Sąsajos gali būti naudojamos projektavimo modeliams įgyvendinti, pvz., Adapterio šablonui, reikalaujant, kad tam tikrus metodus ar savybes įgyvendintų įgyvendinimo klasės.
  7. Palengvina testavimą: Sąsajos palengvina testavimą, nes leidžia programinės įrangos komponentus testuoti nepriklausomai vienas nuo kito, naudojant netikrus objektus, kurie įgyvendina sąsają.

1 pavyzdys: sąsajai

Java 
// Java Program to Illustrate Concept of Interface // Importing I/O classes import java.io.*; // Interface interface Shape {  // Abstract method  void draw();  double area(); } // Class 1 // Helper class class Rectangle implements Shape {  int length, width;  // constructor  Rectangle(int length, int width)  {  this.length = length;  this.width = width;  }  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  @Override public double area()  {  return (double)(length * width);  } } // Class 2 // Helper class class Circle implements Shape {  double pi = 3.14;  int radius;  // constructor  Circle(int radius) { this.radius = radius; }  @Override public void draw()  {  System.out.println('Circle has been drawn ');  }  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 3 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape interface reference.  Shape rect = new Rectangle(2, 3);  System.out.println('Area of rectangle: '  + rect.area());  // Creating the Objects of circle class  Shape circle = new Circle(2);  System.out.println('Area of circle: '  + circle.area());  } }>
Išvestis 
Area of rectangle: 6.0 Area of circle: 12.56>

2 pavyzdys: sąsajai

Java 
// Java Program to Illustrate Concept of Interface // Importing I/O classes import java.io.*; // Interface interface Shape {  // Abstract method  void draw();  double area(); } // Class 1 // Helper class class Rectangle implements Shape {  int length, width;  // constructor  Rectangle(int length, int width)  {  this.length = length;  this.width = width;  }  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  @Override public double area()  {  return (double)(length * width);  } } // Class 2 // Helper class class Circle implements Shape {  double pi = 3.14;  int radius;  // constructor  Circle(int radius) { this.radius = radius; }  @Override public void draw()  {  System.out.println('Circle has been drawn ');  }  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 3 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape interface reference.  Shape rect = new Rectangle(2, 3);  System.out.println('Area of rectangle: '  + rect.area());  // Creating the Objects of circle class  Shape circle = new Circle(2);  System.out.println('Area of circle: '  + circle.area());  } }>
Išvestis 
Area of rectangle: 6.0 Area of circle: 12.56>

Kada ką naudoti?

Apsvarstykite galimybę naudoti abstrakčias klases, jei kuris nors iš šių teiginių tinka jūsų situacijai:

  • „Java“ programoje yra keletas susijusių klasių, kurioms reikia bendrinti kai kurias kodo eilutes, tada šias kodo eilutes galite įdėti į abstrakčią klasę, o ši abstrakčioji klasė turėtų būti išplėsta visomis šiomis susijusiomis klasėmis.
  • Galite apibrėžti nestatinį arba negalutinį lauką (-us) abstrakčioje klasėje, kad naudodami metodą galėtumėte pasiekti ir modifikuoti objekto, kuriam jie priklauso, būseną.
  • Galite tikėtis, kad klasėse, kurios išplečia abstrakčią klasę, yra daug bendrų metodų ar laukų arba reikės prieigos modifikatorių, ne viešųjų (pvz., apsaugotų ir privačių).

Apsvarstykite galimybę naudoti sąsajas, jei kuris nors iš šių teiginių tinka jūsų situacijai:

  • Tai visiška abstrakcija, visus sąsajoje deklaruotus metodus turi įgyvendinti klasė (-ės), kuri (-os) įgyvendina šią sąsają.
  • Klasė gali įdiegti daugiau nei vieną sąsają. Tai vadinama daugialypiu paveldėjimu.
  • Norite nurodyti konkretaus duomenų tipo elgseną, bet nesirūpinate, kas įgyvendins jo elgesį.