La classe astratta e l'interfaccia sono entrambe utilizzate per definire i contratti nella programmazione orientata agli oggetti, ma esistono alcune differenze fondamentali tra loro.

mvc nel quadro primaverile

Differenza tra classe astratta e interfaccia: -

Definizione: una classe astratta è una classe che non può essere istanziata e può contenere sia metodi astratti che non astratti. Un'interfaccia, invece, è un contratto che specifica un insieme di metodi che una classe deve implementare.

Implementazione del metodo: in una classe astratta, alcuni metodi possono essere implementati, mentre altri vengono lasciati astratti, nel senso che non hanno alcuna implementazione e devono essere sovrascritti da sottoclassi concrete. Al contrario, tutti i metodi in un'interfaccia sono astratti per impostazione predefinita e devono essere implementati da qualsiasi classe che implementa l'interfaccia.

Ereditarietà: una classe può ereditare da una sola classe astratta, ma può implementare più interfacce. Questo perché una classe astratta rappresenta un tipo di oggetto, mentre un'interfaccia rappresenta un insieme di comportamenti.

Modificatori di accesso: le classi astratte possono avere modificatori di accesso come public, protected e private per i loro metodi e proprietà, mentre le interfacce possono avere solo accesso pubblico.

Variabili: una classe astratta può avere variabili membro, mentre un'interfaccia no.

In sintesi, le classi astratte vengono utilizzate per fornire una classe base da cui ereditare le sottoclassi concrete, mentre le interfacce vengono utilizzate per definire un insieme di metodi che una classe deve implementare. Le classi astratte possono avere metodi implementati e astratti, mentre le interfacce possono avere solo metodi astratti. Le classi possono ereditare da una sola classe astratta, ma possono implementare più interfacce.

Come sappiamo, l'astrazione si riferisce al nascondere l'implementazione interna della funzionalità e al mostrare solo la funzionalità agli utenti. cioè mostrare solo le funzionalità richieste e nascondere come tali funzionalità vengono implementate dietro le quinte. Considerando che un'interfaccia è un altro modo per ottenere l'astrazione in Java. Entrambi classe astratta E interfaccia vengono utilizzati per l'astrazione, d'ora in poi Interface e Abstract Class saranno prerequisiti richiesti.

Classe astratta vs interfaccia

• Tipo di metodi: L'interfaccia può avere solo metodi astratti. Mentre una classe astratta può avere metodi astratti e metodi concreti. A partire da Java 8, può avere anche metodi predefiniti e statici. Da Java 9 può avere anche metodi concreti privati.

• Nota: i metodi concreti sono quei metodi che hanno la loro definizione completa ma possono anche essere sovrascritti nella classe ereditata. Tuttavia, se utilizziamo il metodo concreto come FINALE non può essere sovrascritto nella classe ereditata perché dichiarare un metodo come finale significa: la sua implementazione è completa .

• Variabili finali: Le variabili dichiarate in un'interfaccia Java sono finali per impostazione predefinita. Una classe astratta può contenere variabili non finali.
• Tipo di variabili: La classe astratta può avere variabili finali, non finali, statiche e non statiche. L'interfaccia ha solo variabili statiche e finali.
• Implementazione: La classe astratta può fornire l'implementazione dell'interfaccia. L'interfaccia non può fornire l'implementazione di una classe astratta.
• Ereditarietà vs astrazione: Un'interfaccia Java può essere implementata utilizzando la parola chiave implementa e una classe astratta può essere estesa utilizzando la parola chiave si estende .
• Molteplici implementazioni: Un'interfaccia può estendere una o più interfacce Java; una classe astratta può estendere un'altra classe Java e implementare più interfacce Java.
• Eredità multipla: L’ereditarietà multipla può essere parzialmente ottenuta mediante l’uso di interfacce, mentre lo stesso non può essere fatto mediante l’uso di classi astratte. Perché in Java, una classe può implementare più interfacce, ma una classe non può estendersi da più classi perché ciò non è possibile in Java poiché ciò porterebbe al problema del diamante.
• Accessibilità dei dati membri: I membri (variabili) di un'interfaccia Java sono definitivi per impostazione predefinita. Una classe astratta Java può avere membri di classe come privato, protetto, ecc.

Caratteristiche della classe astratta: -

Una classe astratta è un tipo speciale di classe nella programmazione orientata agli oggetti di cui non è possibile istanziare direttamente. Serve invece come modello o modello da cui derivare altre classi. Una classe astratta:

1. Non può essere istanziato : le classi astratte non possono essere istanziate direttamente, il che significa che non è possibile creare oggetti di una classe astratta.
2. Contiene almeno una funzione virtuale pura : Le classi astratte devono contenere almeno una funzione virtuale pura, il che significa che la funzione non ha alcuna implementazione e deve essere implementata da eventuali classi derivate.
3. Può contenere metodi astratti e non astratti : Le classi astratte possono avere metodi sia astratti che non astratti. I metodi non astratti hanno un'implementazione completa e possono essere chiamati direttamente.
4. Può avere costruttori e distruttori : Le classi astratte possono avere costruttori e distruttori come qualsiasi altra classe.
5. Può avere variabili membro : Le classi astratte possono avere variabili membro, ovvero variabili che appartengono a un oggetto della classe.
6. Può essere utilizzato come classe base : Le classi astratte possono essere utilizzate come classe base per altre classi, il che significa che possono essere ereditate da altre classi.

Nel complesso, le classi astratte vengono utilizzate per definire un'interfaccia o un comportamento comune che può essere condiviso da più classi correlate, ma con implementazioni specifiche in ciascuna classe derivata.

Esempio 1: (Per la classe astratta)

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>

Esempio 2: (per la classe astratta)

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

E se non avessimo alcun codice comune tra rettangolo e cerchio, allora andiamo con l'interfaccia.

Interfaccia:

Caratteristiche dell'interfaccia:

Un'interfaccia:

1. Definisce un insieme di metodi e proprietà: Un'interfaccia definisce un insieme di metodi e proprietà che devono essere implementati da qualsiasi classe o struttura che implementa l'interfaccia.
2. Fornisce un protocollo comune: Le interfacce forniscono un protocollo comune che consente a diversi componenti software di comunicare tra loro.
3. Supporta il polimorfismo: Un'interfaccia può essere utilizzata per ottenere il polimorfismo, il che significa che oggetti di classi diverse possono essere trattati come se appartenessero allo stesso tipo, purché implementino la stessa interfaccia.
4. Consente la separazione delle preoccupazioni: Le interfacce consentono la separazione degli interessi, il che significa che parti diverse di un sistema software possono essere sviluppate indipendentemente l'una dall'altra, purché aderiscano alle specifiche dell'interfaccia.
5. Migliora la riusabilità del codice: Le interfacce migliorano la riusabilità del codice consentendo a diversi componenti software di riutilizzare la stessa base di codice, purché implementino la stessa interfaccia.
6. Applica modelli di progettazione: Le interfacce possono essere utilizzate per applicare modelli di progettazione, ad esempio il modello Adapter, richiedendo che determinati metodi o proprietà siano implementati dalle classi di implementazione.
7. Facilita i test: Le interfacce facilitano il test consentendo ai componenti software di essere testati indipendentemente l'uno dall'altro, utilizzando oggetti fittizi che implementano l'interfaccia.

Esempio 1: per l'interfaccia

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

Esempio 2: per l'interfaccia

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

Quando usare cosa?

Considera l'utilizzo di classi astratte se una qualsiasi di queste affermazioni si applica alla tua situazione:

• Nell'applicazione Java, ci sono alcune classi correlate che devono condividere alcune righe di codice, quindi puoi inserire queste righe di codice all'interno della classe astratta e questa classe astratta dovrebbe essere estesa da tutte queste classi correlate.
• È possibile definire i campi non statici o non finali nella classe astratta in modo che tramite un metodo sia possibile accedere e modificare lo stato dell'oggetto a cui appartengono.
• Puoi aspettarti che le classi che estendono una classe astratta abbiano molti metodi o campi comuni o richiedano modificatori di accesso diversi da public (come protected e private).

Prendi in considerazione l'utilizzo delle interfacce se una qualsiasi di queste affermazioni si applica alla tua situazione:

• È un'astrazione totale, tutti i metodi dichiarati all'interno di un'interfaccia devono essere implementati dalle classi che implementano questa interfaccia.
• Una classe può implementare più di un'interfaccia. Si chiama eredità multipla.
• Desideri specificare il comportamento di un particolare tipo di dati ma non sei preoccupato di chi ne implementa il comportamento.