La classe abstracta i la interfície s'utilitzen per definir contractes en la programació orientada a objectes, però hi ha algunes diferències clau entre elles.

Diferència entre classe abstracta i interfície: -

fitxer java obert

Definició: una classe abstracta és una classe que no es pot instanciar i que pot contenir tant mètodes abstractes com no abstractes. Una interfície, en canvi, és un contracte que especifica un conjunt de mètodes que ha d'implementar una classe.

Implementació de mètodes: en una classe abstracta, alguns mètodes es poden implementar, mentre que d'altres queden abstractes, és a dir, no tenen implementació i s'han de substituir per subclasses concretes. En canvi, tots els mètodes d'una interfície són abstractes per defecte i han de ser implementats per qualsevol classe que implementi la interfície.

Herència: una classe només pot heretar d'una classe abstracta, però pot implementar múltiples interfícies. Això es deu al fet que una classe abstracta representa un tipus d'objecte, mentre que una interfície representa un conjunt de comportaments.

Modificadors d'accés: les classes abstractes poden tenir modificadors d'accés com ara públic, protegit i privat per als seus mètodes i propietats, mentre que les interfícies només poden tenir accés públic.

Variables: una classe abstracta pot tenir variables membres, mentre que una interfície no.

En resum, les classes abstractes s'utilitzen per proporcionar una classe base per a subclasses concretes per heretar, mentre que les interfícies s'utilitzen per definir un conjunt de mètodes que una classe ha d'implementar. Les classes abstractes poden tenir mètodes implementats i abstractes, mentre que les interfícies només poden tenir mètodes abstractes. Les classes només poden heretar d'una classe abstracta, però poden implementar múltiples interfícies.

Com sabem, l'abstracció es refereix a ocultar la implementació interna de la característica i només mostrar la funcionalitat als usuaris. és a dir, mostrant només les funcions necessàries i ocultant com s'implementen aquestes funcions darrere de l'escena. Mentre que, una interfície és una altra manera d'aconseguir l'abstracció a Java. Tots dos classe abstracta i interfície s'utilitzen per a l'abstracció, d'ara endavant la Interfície i la Classe abstracta són requisits previs obligatoris.

Classe abstracta vs interfície

• Tipus de mètodes: La interfície només pot tenir mètodes abstractes. Mentre que, una classe abstracta pot tenir mètodes abstractes i mètodes concrets. Des de Java 8, també pot tenir mètodes predeterminats i estàtics. Des de Java 9, també pot tenir mètodes concrets privats.

• Nota: els mètodes concrets són aquells mètodes que tenen la seva definició completa, però també es poden substituir a la classe heretada. Tanmateix, si fem el mètode concret com FINAL no es pot anul·lar a la classe heretada perquè declarar un mètode com a final significa: la seva implementació està completa .

• Variables finals: Les variables declarades en una interfície Java són definitives per defecte. Una classe abstracta pot contenir variables no finals.
• Tipus de variables: La classe abstracta pot tenir variables finals, no finals, estàtiques i no estàtiques. La interfície només té variables estàtiques i finals.
• Implementació: La classe abstracta pot proporcionar la implementació de la interfície. La interfície no pot proporcionar la implementació d'una classe abstracta.
• Herència vs Abstracció: Es pot implementar una interfície Java mitjançant la paraula clau implements i una classe abstracta es pot estendre mitjançant la paraula clau s'estén .
• Múltiples implementacions: Una interfície pot estendre una o més interfícies Java; una classe abstracta pot estendre una altra classe Java i implementar múltiples interfícies Java.
• Herència múltiple: L'herència múltiple es pot aconseguir parcialment mitjançant l'ús d'interfícies, mentre que no es pot fer el mateix amb l'ús de classes abstractes. Com que a Java, una classe pot implementar diverses interfícies, però una classe no pot estendre's de diverses altres classes perquè això no és possible a Java, ja que això conduiria al problema del diamant.
• Accessibilitat dels membres de dades: Els membres (variables) d'una interfície Java són finals per defecte. Una classe abstracta de Java pot tenir membres de classe com privats, protegits, etc.

Característiques de la classe abstracta: -

Una classe abstracta és un tipus especial de classe en la programació orientada a objectes que no es pot instanciar directament. En lloc d'això, serveix com a model o plantilla per a altres classes de les quals es derivin. Una classe abstracta:

1. No es pot instanciar : Les classes abstractes no es poden instanciar directament, el que significa que no podeu crear objectes d'una classe abstracta.
2. Conté almenys una funció virtual pura : Les classes abstractes han de contenir almenys una funció virtual pura, el que significa que la funció no té cap implementació i ha de ser implementada per qualsevol classe derivada.
3. Pot contenir tant mètodes abstractes com no abstractes : Les classes abstractes poden tenir mètodes tant abstractes com no abstractes. Els mètodes no abstractes tenen una implementació completa i es poden cridar directament.
4. Pot tenir constructors i destructors : Les classes abstractes poden tenir constructors i destructors com qualsevol altra classe.
5. Pot tenir variables membres : Les classes abstractes poden tenir variables membres, que són variables que pertanyen a un objecte de la classe.
6. Es pot utilitzar com a classe base : Les classes abstractes es poden utilitzar com a classe base per a altres classes, el que significa que poden ser heretades per altres classes.

En general, les classes abstractes s'utilitzen per definir una interfície o un comportament comú que poden ser compartits per diverses classes relacionades, però amb implementacions específiques a cada classe derivada.

Exemple 1: (per a la classe abstracta)

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>

Exemple 2: (per a la classe abstracta)

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

Què passa si no tenim cap codi comú entre rectangle i cercle, aneu amb la interfície.

Interfície:

Característiques de la interfície:

què és l'exportació a linux

Una interfície:

1. Defineix un conjunt de mètodes i propietats: Una interfície defineix un conjunt de mètodes i propietats que ha de ser implementat per qualsevol classe o estructura que implementi la interfície.
2. Proporciona un protocol comú: Les interfícies proporcionen un protocol comú que permet que diferents components de programari es comuniquin entre ells.
3. Admet polimorfisme: Es pot utilitzar una interfície per aconseguir polimorfisme, la qual cosa significa que els objectes de diferents classes es poden tractar com si pertanyessin al mateix tipus, sempre que implementin la mateixa interfície.
4. Permet la separació de preocupacions: Les interfícies permeten separar les preocupacions, la qual cosa significa que les diferents parts d'un sistema de programari es poden desenvolupar independentment les unes de les altres, sempre que s'adhereixin a les especificacions de la interfície.
5. Millora la reutilització del codi: Les interfícies milloren la reutilització del codi permetent que diferents components de programari reutilitzin la mateixa base de codi, sempre que implementin la mateixa interfície.
6. Impulsa els patrons de disseny: Les interfícies es poden utilitzar per aplicar patrons de disseny, com ara el patró de l'adaptador, exigint que determinats mètodes o propietats siguin implementats per les classes d'implementació.
7. Facilita la prova: Les interfícies faciliten les proves ja que permeten provar components de programari independentment els uns dels altres, utilitzant objectes simulats que implementen la interfície.

Exemple 1: per a la interfície

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

Exemple 2: per a la interfície

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

Quan utilitzar què?

Considereu l'ús de classes abstractes si alguna d'aquestes afirmacions s'aplica a la vostra situació:

• A l'aplicació Java, hi ha algunes classes relacionades que necessiten compartir algunes línies de codi, llavors podeu posar aquestes línies de codi dins de la classe abstracta i aquesta classe abstracta s'hauria d'ampliar amb totes aquestes classes relacionades.
• Podeu definir els camps no estàtics o no finals a la classe abstracta de manera que mitjançant un mètode pugueu accedir i modificar l'estat de l'objecte al qual pertanyen.
• Podeu esperar que les classes que estenguin una classe abstracta tinguin molts mètodes o camps comuns, o que requereixin modificadors d'accés diferents de públics (com ara protegits i privats).

Penseu en utilitzar interfícies si alguna d'aquestes afirmacions s'aplica a la vostra situació:

• És una abstracció total, tots els mètodes declarats dins d'una interfície han de ser implementats per la(s) classe(s) que implementa aquesta interfície.
• Una classe pot implementar més d'una interfície. S'anomena herències múltiples.
• Voleu especificar el comportament d'un tipus de dades concret, però no us preocupa qui implementa el seu comportament.