Abstraktná trieda a rozhranie sa používajú na definovanie zmlúv v objektovo orientovanom programovaní, existujú však medzi nimi niektoré kľúčové rozdiely.

Rozdiel medzi abstraktnou triedou a rozhraním: -

Definícia: Abstraktná trieda je trieda, ktorá nemôže byť vytvorená a môže obsahovať abstraktné aj neabstraktné metódy. Rozhranie je na druhej strane zmluva, ktorá špecifikuje súbor metód, ktoré musí trieda implementovať.

Implementácia metódy: V abstraktnej triede môžu byť niektoré metódy implementované, zatiaľ čo iné sú ponechané abstraktné, čo znamená, že nemajú žiadnu implementáciu a musia byť potlačené konkrétnymi podtriedami. Na rozdiel od toho sú všetky metódy v rozhraní štandardne abstraktné a musia byť implementované akoukoľvek triedou, ktorá implementuje rozhranie.

zadanie reťazca v jazyku Java

Dedičnosť: Trieda môže dediť iba z jednej abstraktnej triedy, ale môže implementovať viacero rozhraní. Je to preto, že abstraktná trieda predstavuje typ objektu, zatiaľ čo rozhranie predstavuje súbor správania.

Modifikátory prístupu: Abstraktné triedy môžu mať pre svoje metódy a vlastnosti modifikátory prístupu, ako napríklad verejný, chránený a súkromný, zatiaľ čo rozhrania môžu mať iba verejný prístup.

vypnite režim vývojára

Premenné: Abstraktná trieda môže mať členské premenné, zatiaľ čo rozhranie nie.

Stručne povedané, abstraktné triedy sa používajú na poskytnutie základnej triedy pre konkrétne podtriedy na dedenie, zatiaľ čo rozhrania sa používajú na definovanie množiny metód, ktoré musí trieda implementovať. Abstraktné triedy môžu mať implementované a abstraktné metódy, zatiaľ čo rozhrania môžu mať iba abstraktné metódy. Triedy môžu dediť iba z jednej abstraktnej triedy, ale môžu implementovať viacero rozhraní.

Ako vieme, abstrakcia sa týka skrytia internej implementácie funkcie a iba zobrazenia funkcie používateľom. t. j. zobrazenie iba požadovaných funkcií a skrytie spôsobu implementácie týchto funkcií v zákulisí. Zatiaľ čo rozhranie je ďalším spôsobom, ako dosiahnuť abstrakciu v jazyku Java. Obaja abstraktná trieda a rozhranie sa používajú na abstrakciu, odteraz Interface a Abstract Class sú vyžadované predpoklady.

Abstraktná trieda vs rozhranie

• Typ metód: Rozhranie môže mať iba abstraktné metódy. Zatiaľ čo abstraktná trieda môže mať abstraktnú metódu a konkrétne metódy. Od Java 8 môže mať aj predvolené a statické metódy. Od Java 9 môže mať aj súkromné ​​konkrétne metódy.

• Poznámka: Konkrétne metódy sú tie metódy, ktoré majú svoju úplnú definíciu, ale môžu byť tiež prepísané v zdedenej triede. Ak však urobíme konkrétnu metódu ako FINÁLNY nemožno ju prepísať v zdedenej triede, pretože deklarovanie metódy ako konečného prostriedku – jeho realizácia je dokončená .

• Konečné premenné: Premenné deklarované v rozhraní Java sú štandardne konečné. Abstraktná trieda môže obsahovať nefinálne premenné.
• Typ premenných: Abstraktná trieda môže mať konečné, nefinálne, statické a nestatické premenné. Rozhranie má iba statické a konečné premenné.
• Implementácia: Abstraktná trieda môže poskytnúť implementáciu rozhrania. Rozhranie nemôže poskytnúť implementáciu abstraktnej triedy.
• Dedičnosť vs abstrakcia: Rozhranie Java je možné implementovať pomocou kľúčového slova náradia a abstraktná trieda môže byť rozšírená pomocou kľúčového slova predlžuje .
• Viaceré implementácie: Rozhranie môže rozšíriť jedno alebo viac rozhraní Java; abstraktná trieda môže rozšíriť ďalšiu triedu Java a implementovať viacero rozhraní Java.
• Viacnásobné dedičstvo: Viacnásobné dedičstvo možno čiastočne dosiahnuť použitím rozhraní, zatiaľ čo to isté nemožno dosiahnuť použitím abstraktných tried. Pretože v Jave môže jedna trieda implementovať viacero rozhraní, ale jedna trieda sa nemôže rozšíriť z viacerých iných tried, pretože to v jave jednoducho nie je možné, pretože by to viedlo k diamantovému problému.
• Prístupnosť dátových členov: Členovia (premenné) rozhrania Java sú štandardne konečné. Abstraktná trieda Java môže mať členov triedy ako súkromné, chránené atď.

Vlastnosti abstraktnej triedy: -

Abstraktná trieda je špeciálny typ triedy v objektovo orientovanom programovaní, ktorý nemožno priamo vytvoriť. Namiesto toho slúži ako plán alebo šablóna pre iné triedy, z ktorých sa majú odvodiť. Abstraktná trieda:

1. Nie je možné vytvoriť inštanciu : Abstraktné triedy nemožno vytvárať priamo, čo znamená, že nemôžete vytvárať objekty abstraktnej triedy.
2. Obsahuje aspoň jednu čisto virtuálnu funkciu : Abstraktné triedy musia obsahovať aspoň jednu čisto virtuálnu funkciu, čo znamená, že funkcia nemá žiadnu implementáciu a musí byť implementovaná akýmikoľvek odvodenými triedami.
3. Môže obsahovať abstraktné aj neabstraktné metódy : Abstraktné triedy môžu mať abstraktné aj neabstraktné metódy. Neabstraktné metódy majú úplnú implementáciu a možno ich volať priamo.
4. Môže mať konštruktory a deštruktory : Abstraktné triedy môžu mať konštruktory a deštruktory ako každá iná trieda.
5. Môže mať členské premenné : Abstraktné triedy môžu mať členské premenné, čo sú premenné, ktoré patria objektu triedy.
6. Môže byť použitý ako základná trieda : Abstraktné triedy možno použiť ako základnú triedu pre iné triedy, čo znamená, že ich môžu dediť iné triedy.

Celkovo sa abstraktné triedy používajú na definovanie spoločného rozhrania alebo správania, ktoré môžu zdieľať viaceré súvisiace triedy, ale so špecifickými implementáciami v každej odvodenej triede.

kedy vyšiel windows 7

Príklad 1: (Pre abstraktnú triedu)

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();  } }>

avinash 21 222.2>

Príklad 2: (Pre abstraktnú triedu)

// 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);  } }>

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>

Čo ak nemáme žiadny spoločný kód medzi obdĺžnikom a kruhom, potom prejdite na rozhranie.

Rozhranie:

Vlastnosti rozhrania:

Rozhranie:

1. Definuje súbor metód a vlastností: Rozhranie definuje množinu metód a vlastností, ktoré musia byť implementované akoukoľvek triedou alebo štruktúrou, ktorá implementuje rozhranie.
2. Poskytuje spoločný protokol: Rozhrania poskytujú spoločný protokol, ktorý umožňuje rôznym softvérovým komponentom navzájom komunikovať.
3. Podporuje polymorfizmus: Na dosiahnutie polymorfizmu možno použiť rozhranie, čo znamená, že s objektmi rôznych tried možno zaobchádzať tak, ako keby patrili do rovnakého typu, pokiaľ implementujú rovnaké rozhranie.
4. Umožňuje oddelenie obáv: Rozhrania umožňujú oddelenie záujmov, čo znamená, že rôzne časti softvérového systému môžu byť vyvíjané nezávisle od seba, pokiaľ spĺňajú špecifikácie rozhrania.
5. Zlepšuje opätovnú použiteľnosť kódu: Rozhrania zlepšujú opätovnú použiteľnosť kódu tým, že umožňujú rôznym softvérovým komponentom opätovne používať rovnakú základňu kódu, pokiaľ implementujú rovnaké rozhranie.
6. Presadzuje dizajnové vzory: Rozhrania možno použiť na vynútenie návrhových vzorov, ako je napríklad vzor adaptéra, tým, že sa vyžaduje, aby implementačné triedy implementovali určité metódy alebo vlastnosti.
7. Uľahčuje testovanie: Rozhrania uľahčujú testovanie tým, že umožňujú testovať softvérové ​​komponenty nezávisle od seba pomocou falošných objektov, ktoré implementujú rozhranie.

Príklad 1: Pre rozhranie

// 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());  } }>

Area of rectangle: 6.0 Area of circle: 12.56>

Príklad 2: Pre rozhranie

// 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());  } }>

Area of rectangle: 6.0 Area of circle: 12.56>

Kedy použiť čo?

gb vs mb

Zvážte použitie abstraktných tried, ak sa na vašu situáciu vzťahuje niektorý z týchto výrokov:

• V aplikácii Java sú niektoré súvisiace triedy, ktoré potrebujú zdieľať niektoré riadky kódu, potom môžete tieto riadky kódu vložiť do abstraktnej triedy a táto abstraktná trieda by sa mala rozšíriť o všetky tieto súvisiace triedy.
• V abstraktnej triede môžete definovať nestatické alebo nefinálne polia, takže pomocou metódy môžete pristupovať a upravovať stav objektu, ku ktorému patria.
• Môžete očakávať, že triedy, ktoré rozširujú abstraktnú triedu, majú veľa spoločných metód alebo polí, alebo vyžadujú modifikátory prístupu iné ako verejné (ako napríklad protected a private).

Zvážte použitie rozhraní, ak sa na vašu situáciu vzťahuje niektoré z týchto vyhlásení:

• Je to úplná abstrakcia, všetky metódy deklarované v rámci rozhrania musia byť implementované triedou (triedami), ktorá implementuje toto rozhranie.
• Trieda môže implementovať viac ako jedno rozhranie. Hovorí sa tomu viacnásobné dedičstvo.
• Chcete určiť správanie konkrétneho typu údajov, ale nezaujíma vás, kto implementuje jeho správanie.