Clasa abstractă și interfața sunt ambele folosite pentru a defini contractele în programarea orientată pe obiecte, dar există câteva diferențe cheie între ele.

Diferența dintre clasa abstractă și interfață: -

Definiție: O clasă abstractă este o clasă care nu poate fi instanțiată și poate conține atât metode abstracte, cât și non-abstracte. O interfață, pe de altă parte, este un contract care specifică un set de metode pe care o clasă trebuie să le implementeze.

Implementarea metodei: Într-o clasă abstractă, unele metode pot fi implementate, în timp ce altele sunt lăsate abstracte, ceea ce înseamnă că nu au implementare și trebuie înlocuite de subclase concrete. În schimb, toate metodele dintr-o interfață sunt implicit abstracte și trebuie implementate de orice clasă care implementează interfața.

convertește int în java dublu

Moștenire: O clasă poate moșteni de la o singură clasă abstractă, dar poate implementa mai multe interfețe. Acest lucru se datorează faptului că o clasă abstractă reprezintă un tip de obiect, în timp ce o interfață reprezintă un set de comportamente.

Modificatori de acces: clasele abstracte pot avea modificatori de acces, cum ar fi public, protejat și privat pentru metodele și proprietățile lor, în timp ce interfețele pot avea doar acces public.

ankita dave

Variabile: o clasă abstractă poate avea variabile membre, în timp ce o interfață nu.

În rezumat, clasele abstracte sunt folosite pentru a oferi o clasă de bază pentru subclasele concrete de care să moștenească, în timp ce interfețele sunt folosite pentru a defini un set de metode pe care o clasă trebuie să le implementeze. Clasele abstracte pot avea metode abstracte și implementate, în timp ce interfețele pot avea doar metode abstracte. Clasele pot moșteni dintr-o singură clasă abstractă, dar pot implementa mai multe interfețe.

După cum știm, abstracția se referă la ascunderea implementării interne a caracteristicii și la afișarea doar a funcționalității utilizatorilor. adică afișarea numai a caracteristicilor necesare și ascunderea modului în care aceste caracteristici sunt implementate în spatele scenei. Întrucât, o interfață este o altă modalitate de a realiza abstractizarea în java. Ambii clasa abstractă și interfață sunt utilizate pentru abstracție, de acum înainte Interfața și Clasa abstractă sunt cerințe preliminare necesare.

Clasă abstractă vs interfață

• Tip de metode: Interfața poate avea doar metode abstracte. Întrucât, o clasă abstractă poate avea o metodă abstractă și metode concrete. Din Java 8, poate avea și metode implicite și statice. Din Java 9, poate avea și metode private concrete.

• Notă: Metodele concrete sunt acele metode care au definiția lor completă, dar pot fi, de asemenea, suprascrise în clasa moștenită. Totuşi, dacă facem metoda concretă ca FINAL nu poate fi suprascris în clasa moștenită, deoarece declararea unei metode ca mijloc final - implementarea sa este completă .

• Variabile finale: Variabilele declarate într-o interfață Java sunt implicit finale. O clasă abstractă poate conține variabile non-finale.
• Tip de variabile: Clasa abstractă poate avea variabile finale, nefinale, statice și nestatice. Interfața are doar variabile statice și finale.
• Implementare: Clasa abstractă poate oferi implementarea interfeței. Interfața nu poate oferi implementarea unei clase abstracte.
• Moștenire vs abstracție: O interfață Java poate fi implementată folosind cuvântul cheie unelte iar o clasă abstractă poate fi extinsă folosind cuvântul cheie se extinde .
• Implementări multiple: O interfață poate extinde una sau mai multe interfețe Java; o clasă abstractă poate extinde o altă clasă Java și poate implementa mai multe interfețe Java.
• Moștenire multiplă: Moștenirea multiplă poate fi realizată parțial prin utilizarea interfețelor, în timp ce același lucru nu se poate face prin utilizarea claselor abstracte. Deoarece în Java, o clasă poate implementa mai multe interfețe, dar o clasă nu se poate extinde de la mai multe alte clase, deoarece acest lucru nu este posibil în Java, deoarece ar duce la problema diamantului.
• Accesibilitatea membrilor datelor: Membrii (variabilele) unei interfețe Java sunt definitive în mod implicit. O clasă abstractă Java poate avea membri de clasă precum private, protected etc.

Caracteristicile clasei abstracte: -

O clasă abstractă este un tip special de clasă în programarea orientată pe obiecte care nu poate fi instanțiată direct. În schimb, servește ca model sau șablon pentru alte clase din care să fie derivate. O clasă abstractă:

1. Nu poate fi instanțiat : Clasele abstracte nu pot fi instanțiate direct, ceea ce înseamnă că nu puteți crea obiecte dintr-o clasă abstractă.
2. Conține cel puțin o funcție virtuală pură : Clasele abstracte trebuie să conțină cel puțin o funcție virtuală pură, ceea ce înseamnă că funcția nu are implementare și trebuie implementată de orice clase derivate.
3. Poate conține atât metode abstracte, cât și non-abstracte : Clasele abstracte pot avea atât metode abstracte, cât și non-abstracte. Metodele non-abstracte au o implementare completă și pot fi apelate direct.
4. Poate avea constructori și destructori : Clasele abstracte pot avea constructori și destructori ca orice altă clasă.
5. Poate avea variabile membre : Clasele abstracte pot avea variabile membre, care sunt variabile care aparțin unui obiect al clasei.
6. Poate fi folosit ca o clasă de bază : Clasele abstracte pot fi folosite ca o clasă de bază pentru alte clase, ceea ce înseamnă că pot fi moștenite de alte clase.

În general, clasele abstracte sunt folosite pentru a defini o interfață comună sau un comportament care poate fi partajat de mai multe clase înrudite, dar cu implementări specifice în fiecare clasă derivată.

tutorial react js

Exemplul 1: (Pentru clasa de abstract)

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>

Exemplul 2: (Pentru clasa de abstract)

// 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>

Ce se întâmplă dacă nu avem niciun cod comun între dreptunghi și cerc, atunci mergem cu interfața.

Interfata:

Caracteristici ale interfeței:

O interfață:

convenția de denumire a java

1. Definește un set de metode și proprietăți: O interfață definește un set de metode și proprietăți care trebuie implementate de orice clasă sau structură care implementează interfața.
2. Oferă un protocol comun: Interfețele oferă un protocol comun care permite diferitelor componente software să comunice între ele.
3. Suporta polimorfismul: O interfață poate fi folosită pentru a realiza polimorfismul, ceea ce înseamnă că obiectele din clase diferite pot fi tratate ca și cum ar aparține aceluiași tip, atâta timp cât implementează aceeași interfață.
4. Permite separarea preocupărilor: Interfețele permit separarea preocupărilor, ceea ce înseamnă că diferite părți ale unui sistem software pot fi dezvoltate independent unele de altele, atâta timp cât respectă specificațiile interfeței.
5. Îmbunătățește reutilizarea codului: Interfețele îmbunătățesc reutilizarea codului, permițând diferitelor componente software să refolosească aceeași bază de cod, atâta timp cât implementează aceeași interfață.
6. Implementează modelele de design: Interfețele pot fi utilizate pentru a impune modele de proiectare, cum ar fi modelul Adaptor, solicitând ca anumite metode sau proprietăți să fie implementate de către clasele de implementare.
7. Facilitează testarea: Interfețele facilitează testarea permițând componentelor software să fie testate independent unele de altele, folosind obiecte simulate care implementează interfața.

Exemplul 1: Pentru interfață

// 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>

Exemplul 2: Pentru interfață

// 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>

Când să folosești ce?

Luați în considerare utilizarea unor clase abstracte dacă oricare dintre aceste afirmații se aplică situației dvs.:

• În aplicația Java, există câteva clase înrudite care trebuie să partajeze câteva linii de cod, apoi puteți pune aceste linii de cod în cadrul clasei abstracte, iar această clasă abstractă ar trebui extinsă de toate aceste clase înrudite.
• Puteți defini câmpurile non-statice sau non-finale din clasa abstractă, astfel încât printr-o metodă să puteți accesa și modifica starea obiectului căruia îi aparțin.
• Vă puteți aștepta ca clasele care extind o clasă abstractă să aibă multe metode sau câmpuri comune sau să necesite modificatori de acces alții decât public (cum ar fi protejat și privat).

Luați în considerare utilizarea interfețelor dacă oricare dintre aceste afirmații se aplică situației dvs.:

• Este o abstractizare totală, toate metodele declarate într-o interfață trebuie implementate de către clasa(ele) care implementează această interfață.
• O clasă poate implementa mai mult de o interfață. Se numește moșteniri multiple.
• Doriți să specificați comportamentul unui anumit tip de date, dar nu vă preocupați cine implementează comportamentul acestuia.