oop - interfaccia - metodi astratti java




Qual è la differenza tra un'interfaccia e una classe astratta? (20)

Qual è esattamente la differenza tra un'interfaccia e una classe astratta?


interfacce

Un'interfaccia è un contratto : la persona che scrive l'interfaccia dice " hey, accetto le cose in questo modo ", e la persona che usa l'interfaccia dice " OK, la classe che scrivo sembra così ".

Un'interfaccia è una shell vuota . Ci sono solo le firme dei metodi, il che implica che i metodi non hanno un corpo. L'interfaccia non può fare nulla. È solo uno schema.

Ad esempio (pseudo codice):

// I say all motor vehicles should look like this:
interface MotorVehicle
{
    void run();

    int getFuel();
}

// My team mate complies and writes vehicle looking that way
class Car implements MotorVehicle
{

    int fuel;

    void run()
    {
        print("Wrroooooooom");
    }


    int getFuel()
    {
        return this.fuel;
    }
}

L'implementazione di un'interfaccia consuma pochissima CPU, perché non è una classe, solo un mucchio di nomi, e quindi non ci sono costose ricerche da fare. È fantastico quando è importante, come nei dispositivi embedded.

Lezioni astratte

Le classi astratte, a differenza delle interfacce, sono classi. Sono più costosi da usare, perché c'è una ricerca da fare quando si eredita da loro.

Le classi astratte assomigliano molto alle interfacce, ma hanno qualcosa in più: puoi definire un comportamento per loro. È più che altro una persona che dice "queste classi dovrebbero assomigliare a questo, e hanno questo in comune, quindi riempire gli spazi vuoti!".

Per esempio:

// I say all motor vehicles should look like this:
abstract class MotorVehicle
{

    int fuel;

    // They ALL have fuel, so lets implement this for everybody.
    int getFuel()
    {
         return this.fuel;
    }

    // That can be very different, force them to provide their
    // own implementation.
    abstract void run();
}

// My teammate complies and writes vehicle looking that way
class Car extends MotorVehicle
{
    void run()
    {
        print("Wrroooooooom");
    }
}

Implementazione

Mentre le classi e le interfacce astratte dovrebbero essere concetti diversi, le implementazioni rendono questa affermazione a volte non vera. A volte, non sono nemmeno ciò che pensi di essere.

In Java, questa regola è fortemente applicata, mentre in PHP, le interfacce sono classi astratte senza alcun metodo dichiarato.

In Python, le classi astratte sono più un trucco di programmazione che puoi ottenere dal modulo ABC e in realtà utilizzano metaclassi e quindi classi. E le interfacce sono più legate alla digitazione anatra in questa lingua ed è un misto tra convenzioni e metodi speciali che chiamano i descrittori (i metodi __method__).

Come al solito con la programmazione, c'è teoria, pratica e pratica in un'altra lingua :-)


Alcune importanti differenze:

Sotto forma di tabella:

Come affermato da Joe da javapapers :

1. La differenza principale è che i metodi di un'interfaccia Java sono implicitamente astratti e non possono avere implementazioni. Una classe astratta Java può avere metodi di istanza che implementano un comportamento predefinito.

2. Le variabili dichiarate in un'interfaccia Java sono per default definitive. Una classe astratta può contenere variabili non finali.

3. I membri di un'interfaccia Java sono pubblici per impostazione predefinita. Una classe astratta Java può avere i soliti sapori dei membri della classe come privati, protetti, ecc.

4. L'interfaccia Java deve essere implementata usando la parola chiave "implements"; Una classe astratta Java dovrebbe essere estesa usando la parola chiave "extends".

5.Un'interfaccia può estendere solo un'altra interfaccia Java, una classe astratta può estendere un'altra classe Java e implementare più interfacce Java.

6. Una classe Java può implementare più interfacce ma può estendere solo una classe astratta.

7. L'interfaccia è assolutamente astratta e non può essere istanziata; Anche una classe astratta Java non può essere istanziata, ma può essere invocata se esiste un main ().

8. In confronto con le classi astratte java, le interfacce java sono lente in quanto richiede un'ulteriore indiretta.


Il modo più breve per riassumere è che interface è:

  1. Completamente astratto, a parte static metodi default e static ; mentre ha definizioni (firme + metodi) per metodi default e static , ha solo dichiarazioni (firme del metodo) per altri metodi.
  2. Soggetto a regole più lassiste delle classi (una classe può implementare più interface e interface può ereditare da più interface ). Tutte le variabili sono implicitamente costanti, se specificate come public static final o meno. Tutti i membri sono implicitamente public , se specificati come tali o meno.
  3. Generalmente utilizzato come garanzia che la classe di implementazione avrà le caratteristiche specificate e / o compatibile con qualsiasi altra classe che implementa la stessa interfaccia.

Nel frattempo, una classe abstract è:

  1. Ovunque da completamente astratto a completamente implementato, con la tendenza ad avere uno o più metodi abstract . Può contenere sia dichiarazioni che definizioni, con dichiarazioni contrassegnate come abstract .
  2. Una classe a tutti gli effetti, soggetta alle regole che governano le altre classi (può ereditare solo da una classe), a condizione che non possa essere istanziata (perché non si garantisce che sia completamente implementata). Può avere variabili membro non costanti. In grado di implementare il controllo di accesso utente, limitando i membri come protected, private, o un pacchetto privato (non specificato).
  3. Generalmente utilizzato per fornire la maggior parte dell'implementazione che può essere condivisa da più sottoclassi o per fornire la maggior parte dell'implementazione che il programmatore è in grado di fornire.

Oppure, se vogliamo far bollire il tutto a una sola frase: An interfaceè quello che la classe che implementa ha , ma di una abstractclasse è quello che la sottoclasse è .


Il punto principale è che:

  • L'astratto è orientato agli oggetti . Offre i dati di base che un 'oggetto' dovrebbe avere e / o funzioni che dovrebbe essere in grado di fare. Riguarda le caratteristiche di base dell'oggetto: cosa ha e cosa può fare. Quindi gli oggetti che ereditano dalla stessa classe astratta condividono le caratteristiche di base (generalizzazione).
  • L'interfaccia è orientata alla funzionalità . Definisce le funzionalità che un oggetto dovrebbe avere. Indipendentemente da quale oggetto sia, finché può fare queste funzionalità, che sono definite nell'interfaccia, va bene. Ignora tutto il resto. Un oggetto / classe può contenere diverse (gruppi di) funzionalità; quindi è possibile per una classe implementare più interfacce.

In realtà è piuttosto semplice.

Puoi pensare ad un'interfaccia come una classe alla quale è permesso solo avere metodi astratti e nient'altro.

Quindi un'interfaccia può solo "dichiarare" e non definire il comportamento che la classe deve avere.

Una classe astratta consente di dichiarare entrambi (utilizzando metodi astratti) e definire (utilizzando le implementazioni del metodo completo) il comportamento che si desidera che la classe abbia.

E una classe regolare ti consente solo di definire, non dichiarare, il comportamento / le azioni che vuoi che la classe abbia.

Un'ultima cosa,

In Java, è possibile implementare più interfacce, ma è possibile estenderne solo una (Classe astratta o Classe) ...

Ciò significa che l'ereditarietà del comportamento definito è limitata a consentire solo uno per classe ... cioè se si desidera una classe che incapsula il comportamento delle Classi A, B e C, si dovrebbe fare quanto segue: Classe A estende B, Classe C estende A .. è un po 'un modo per avere ereditarietà multiple ...

Interfacce d'altra parte, si potrebbe semplicemente fare: interfaccia C implementa A, B

Quindi, in effetti, Java supporta l'ereditarietà multipla solo in "comportamento dichiarato", cioè interfacce e solo ereditarietà con comportamento definito .. a meno che non si faccia il giro del modo in cui ho descritto ...

Spero che abbia senso.


Interfaccia: gira (gira a sinistra, gira a destra.)

Classe astratta: ruota.

Classe: il volante, deriva dalla ruota, espone il giro dell'interfaccia

Uno è per categorizzare il comportamento che può essere offerto attraverso una vasta gamma di cose, l'altro è per modellare un'ontologia delle cose.


L'unica differenza è che si può partecipare a eredità multiple e altre no.

La definizione di un'interfaccia è cambiata nel tempo. Pensi che un'interfaccia abbia solo dichiarazioni di metodo e siano solo contratti? Per quanto riguarda le variabili finali statiche e le definizioni predefinite dopo Java 8?

Le interfacce sono state introdotte in Java a causa del problema dei diamanti con ereditarietà multipla e questo è ciò che effettivamente intendono fare.

Le interfacce sono i costrutti creati per superare il problema dell'ereditarietà multipla e possono avere metodi astratti, definizioni predefinite e variabili finali statiche.

Vedi Perché Java consente le variabili finali statiche nelle interfacce quando sono intese solo come contratti? .


Lavoriamo ancora su questa domanda:

La prima cosa da dirti è che 1/1 e 1 * 1 hanno lo stesso risultato, ma ciò non significa che la moltiplicazione e la divisione siano uguali. Ovviamente, mantengono un buon rapporto, ma badate entrambi sono diversi.

Sottolineerò le principali differenze e il resto è già stato spiegato:

Le classi astratte sono utili per modellare una gerarchia di classi. A prima vista, qualsiasi requisito è parzialmente chiaro su cosa esattamente deve essere costruito, ma sappiamo cosa costruire. E così le tue classi astratte sono le tue classi base.

Le interfacce sono utili per consentire ad altre gerarchie o classi di sapere che cosa sono capace di fare. E quando dici che sono capace di qualcosa, devi avere quella capacità. Le interfacce lo contrassegneranno come obbligatorio per una classe per implementare le stesse funzionalità.


Non è davvero la risposta alla domanda originale, ma una volta che hai la risposta alla differenza tra loro, entrerai nel dilemma di quando-per-utilizzare: quando utilizzare le interfacce o le classi astratte? Quando usare entrambi?

Ho una conoscenza limitata di OOP, ma vedere le interfacce come un equivalente di un aggettivo in grammatica ha funzionato per me fino ad ora (correggimi se questo metodo è falso!). Ad esempio, i nomi delle interfacce sono come attributi o capacità che puoi dare a una classe, e una classe può avere molti di essi: ISerializable, ICountable, IList, ICacheable, IHappy, ...


Non voglio evidenziare le differenze, che sono già state dette in molte risposte (riguardo i modificatori finali statici pubblici per le variabili nell'interfaccia e il supporto per metodi privati ​​protetti in classi astratte)

In termini semplici, vorrei dire:

interfaccia: per implementare un contratto con più oggetti non correlati

classe astratta: per implementare lo stesso comportamento o un comportamento diverso tra più oggetti correlati

Dalla documentation Oracle

Prendi in considerazione l'utilizzo di classi astratte se:

  1. Vuoi condividere il codice tra diverse classi strettamente correlate.
  2. Ti aspetti che le classi che estendono la tua classe astratta abbiano molti metodi o campi comuni o richiedano modificatori di accesso diversi da quelli pubblici (come protetti e privati).
  3. Si desidera dichiarare campi non statici o non finali.

Prendi in considerazione l'utilizzo di interfacce se:

  1. Ti aspetti che le classi non correlate implementino la tua interfaccia. Ad esempio, molti oggetti non collegati possono implementare un'interfaccia Serializable .
  2. Si desidera specificare il comportamento di un particolare tipo di dati, ma non si preoccupa di chi implementa il suo comportamento.
  3. Vuoi sfruttare l'ereditarietà multipla del tipo.

la classe astratta stabilisce "è un" rapporto con classi concrete. l'interfaccia fornisce "ha una" capacità per le classi.

Se stai cercando Java come linguaggio di programmazione, ecco alcuni altri aggiornamenti:

Java 8 ha ridotto il divario tra l' interface e le classi abstract in una certa misura fornendo una funzione di metodo default . Un'interfaccia non ha un'implementazione per un metodo non è più valida ora.

Fare riferimento a questa page documentazione per ulteriori dettagli.

Dai un'occhiata a questa domanda SE per esempi di codice per capire meglio.

Come dovrei aver spiegato la differenza tra un'interfaccia e una classe astratta?


Quando si desidera fornire un comportamento polimorfico in una gerarchia di ereditarietà, utilizzare le classi astratte.

Quando si desidera un comportamento polimorfico per classi completamente indipendenti, utilizzare un'interfaccia.


Se hai metodi comuni che possono essere usati da più classi, vai per le classi astratte. Altrimenti se si desidera che le classi seguano un progetto preciso per le interfacce.

Gli esempi seguenti lo dimostrano.

Classe astratta in Java:

abstract class animals
{
    // They all love to eat. So let's implement them for everybody
    void eat()
    {
        System.out.println("Eating...");
    }
    // The make different sounds. They will provide their own implementation.
    abstract void sound();
}

class dog extends animals
{
    void sound()
    {
        System.out.println("Woof Woof");
    }
}

class cat extends animals
{
    void sound()
    {
        System.out.println("Meoww");
    }
}

Di seguito è una implementazione di interfaccia in Java:

interface Shape
{
    void display();
    double area();
}

class Rectangle implements Shape 
{
    int length, width;
    Rectangle(int length, int width)
    {
        this.length = length;
        this.width = width;
    }
    @Override
    public void display() 
    {
        System.out.println("****\n* *\n* *\n****"); 
    }
    @Override
    public double area() 
    {
        return (double)(length*width);
    }
} 

class Circle implements Shape 
{
    double pi = 3.14;
    int radius;
    Circle(int radius)
    {
        this.radius = radius;
    }
    @Override
    public void display() 
    {
        System.out.println("O"); // :P
    }
    @Override
    public double area() 
    { 
        return (double)((pi*radius*radius)/2);
    }
}

Alcuni punti chiave importanti in poche parole:

  1. Le variabili dichiarate nell'interfaccia Java sono per default definitive. Le classi astratte possono avere variabili non definitive.

  2. Le variabili dichiarate nell'interfaccia Java sono di default statiche. Le classi astratte possono avere variabili non statiche.

  3. I membri di un'interfaccia Java sono pubblici per impostazione predefinita. Una classe astratta Java può avere i soliti sapori dei membri della classe come privati, protetti, ecc.


Un'interfaccia contiene solo la definizione / firma della funzionalità, e se abbiamo alcune funzionalità comuni e firme comuni, allora dobbiamo usare una classe astratta. Usando una classe astratta, possiamo fornire sia il comportamento che la funzionalità nello stesso tempo. Un altro sviluppatore che eredita una classe astratta può utilizzare facilmente questa funzionalità, in quanto è necessario solo riempire gli spazi vuoti.

Preso da:

http://www.dotnetbull.com/2011/11/difference-between-abstract-class-and.html

http://www.dotnetbull.com/2011/11/what-is-abstract-class-in-c-net.html http://www.dotnetbull.com/2011/11/what-is-interface-in-c-net.html


Una spiegazione può essere trovata qui: http://www.developer.com/lang/php/article.php/3604111/PHP-5-OOP-Interfaces-Abstract-Classes-and-the-Adapter-Pattern.htm

Una classe astratta è una classe che è solo parzialmente implementata dal programmatore. Può contenere uno o più metodi astratti. Un metodo astratto è semplicemente una definizione di funzione che serve a dire al programmatore che il metodo deve essere implementato in una classe figlia.

Un'interfaccia è simile a una classe astratta; infatti le interfacce occupano lo stesso spazio dei nomi delle classi e delle classi astratte. Per questo motivo, non è possibile definire un'interfaccia con lo stesso nome di una classe. Un'interfaccia è una classe completamente astratta; nessuno dei suoi metodi è implementato e invece di una sottoclasse di classe da esso, si dice che implementa quell'interfaccia.

Comunque trovo questa spiegazione delle interfacce un po 'confusa. Una definizione più comune è: un'interfaccia definisce un contratto che le classi di implementazione devono soddisfare. Una definizione di interfaccia consiste in firme di membri pubblici, senza alcun codice di implementazione.


Differenze tra classe astratta e interfaccia per conto dell'implementazione reale.

Interfaccia : è una parola chiave e viene utilizzata per definire il modello o la stampa blu di un oggetto e impone a tutte le sottoclassi di seguire lo stesso prototipo, mentre per quanto riguarda l'implementazione, tutte le sottoclassi sono libere di implementare la funzionalità come è un requisito.

Alcuni altri casi d'uso in cui dovremmo usare l'interfaccia.

Comunicazione tra due oggetti esterni (integrazione di terze parti nella nostra applicazione) tramite Interfaccia qui L'interfaccia funziona come Contratto.

Abstract Class: Abstract, è una parola chiave e quando usiamo questa parola chiave prima di qualsiasi classe, diventa una classe astratta. Viene usata principalmente quando è necessario definire il modello e alcune funzionalità predefinite di un oggetto che è seguito da tutte le sottoclassi e in questo modo rimuove il codice ridondante e un altro caso di utilizzo in cui possiamo usare la classe astratta , come non vogliamo che nessun'altra classe possa istanziare direttamente un oggetto della classe, solo le classi derivate possono usare la funzionalità.

Esempio di classe astratta:

 public abstract class DesireCar
  {

 //It is an abstract method that defines the prototype.
     public abstract void Color();

  // It is a default implementation of a Wheel method as all the desire cars have the same no. of wheels.   
 // and hence no need to define this in all the sub classes in this way it saves the code duplicasy     

  public void Wheel() {          

               Console.WriteLine("Car has four wheel");
                }
           }


    **Here is the sub classes:**

     public class DesireCar1 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red color Desire car");
            }
        }

        public class DesireCar2 : DesireCar
        {
            public override void Color()
            {
                Console.WriteLine("This is a red white Desire car");
            }
        }

Esempio di interfaccia:

  public interface IShape
        {
          // Defines the prototype(template) 
            void Draw();
        }


  // All the sub classes follow the same template but implementation can be different.

    public class Circle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Circle");
        }
    }

    public class Rectangle : IShape
    {
        public void Draw()
        {
            Console.WriteLine("This is a Rectangle");
        }
    }

In un'interfaccia tutti i metodi devono essere solo definizioni, non deve essere implementato uno solo.

Ma in una classe astratta deve esserci un metodo astratto con una sola definizione, ma altri metodi possono essere anche nella classe astratta con l'implementazione ...


Per fornire una risposta semplice ma chiara, è utile impostare il contesto: si utilizzano entrambi quando non si desidera fornire implementazioni complete.

La principale differenza quindi è che un'interfaccia non ha alcuna implementazione (solo i metodi senza un corpo) mentre le classi astratte possono avere membri e metodi con un corpo, cioè possono essere parzialmente implementati.


Ho letto una spiegazione semplice ma efficace di Abstract class e Interface su php.net

Quale è il seguente.

Un'interfaccia è come un protocollo. Non indica il comportamento dell'oggetto; indica come il tuo codice dice all'oggetto di agire. Un'interfaccia sarebbe come la lingua inglese: la definizione di un'interfaccia definisce come il tuo codice comunica con qualsiasi oggetto che implementa tale interfaccia.

Un'interfaccia è sempre un accordo o una promessa. Quando una classe dice "Io implemento l'interfaccia Y", sta dicendo "Prometto di avere gli stessi metodi pubblici che ha qualsiasi oggetto con l'interfaccia Y".

D'altra parte, una classe astratta è come una classe parzialmente costruita. È molto simile a un documento con spazi vuoti da compilare. Potrebbe essere l'inglese, ma non è così importante come il fatto che parte del documento sia già stata scritta.

Una classe astratta è il fondamento di un altro oggetto. Quando una classe dice "Estendo la classe astratta Y", sta dicendo "Uso alcuni metodi o proprietà già definiti in questa altra classe chiamata Y".

Quindi, considera il seguente PHP:

<?php
class X implements Y { } // this is saying that "X" agrees to speak language "Y" with your code.

class X extends Y { } // this is saying that "X" is going to complete the partial class "Y".
?>

Avresti la tua classe implementare una particolare interfaccia se stavi distribuendo una classe per essere utilizzata da altre persone. L'interfaccia è un accordo per avere un insieme specifico di metodi pubblici per la tua classe.

La tua classe dovrebbe estendere una classe astratta se tu (o qualcun altro) hai scritto una classe che aveva già alcuni metodi scritti che vuoi usare nella tua nuova classe.

Questi concetti, sebbene facili da confondere, sono specificamente diversi e distinti. A tutti gli effetti, se sei l'unico utente di una delle tue classi, non è necessario implementare interfacce.


Puoi trovare una chiara differenza tra interfaccia e classe astratta.

Interfaccia

  • L'interfaccia contiene solo metodi astratti.
  • Costringere gli utenti a implementare tutti i metodi quando implementa l'interfaccia.
  • Contiene solo variabili finali e statiche.
  • Dichiarare usando la parola chiave dell'interfaccia.
  • Tutti i metodi di un'interfaccia devono essere definiti come pubblici.
  • Un'interfaccia può estendersi o una classe può implementare più interfacce.

Classe astratta

  • La classe astratta contiene metodi astratti e non astratti.

  • Non impone agli utenti di implementare tutti i metodi quando hanno ereditato la classe astratta.

  • Contiene tutti i tipi di variabili tra cui primitive e non primitive

  • Dichiarare usando una parola chiave astratta.

  • Metodi e membri di una classe astratta possono essere definiti con qualsiasi visibilità.

  • Una classe figlia può estendere solo una singola classe (astratta o concreta).


Una classe astratta è una classe il cui oggetto non può essere creato o una classe che non può essere istanziata. Un metodo astratto rende astratta una classe. Una classe astratta deve essere ereditata per scavalcare i metodi dichiarati nella classe astratta. Nessuna restrizione sugli specificatori di accesso. Una classe astratta può avere metodi di costruzione e altri metodi concreti (metodi non abstarct) ma l'interfaccia non può avere.

Un'interfaccia è un modello / modello di metodi (ad esempio, viene fornita una casa su un foglio (casa dell'interfaccia) e diversi architetti utilizzeranno le loro idee per costruirlo (le classi di architetti che implementano l'interfaccia di casa). metodi astratti, metodi predefiniti, metodi statici, variabili finali e classi nidificate.Tutti i membri saranno definitivi o pubblici, gli identificatori di accesso privati ​​e protetti non sono consentiti.Non è consentita la creazione di oggetti. interfaccia di implementazione e anche per sovrascrivere il metodo astratto dichiarato nell'interfaccia.Un'interfaccia è un buon esempio di accoppiamento libero (polimorfismo dinamico / associazione dinamica) Un'interfaccia implementa polimorfismo e astrazione. Indica cosa fare, ma come fare è definito dal classe di attuazione. Per esempio.è un'azienda automobilistica e vuole che alcune caratteristiche siano uguali per tutta l'auto che produce, per cui l'azienda realizzerebbe un veicolo di interfaccia che avrà quelle caratteristiche e diverse classi di auto (come Maruti Suzkhi, Maruti 800) sostituirà quelle caratteristiche (funzioni).

Perché interfacciare quando abbiamo già una classe astratta? Java supporta solo l'ereditarietà multilivello e gerarchica, ma con l'aiuto dell'interfaccia possiamo implementare l'ereditarietà multipla.





abstract-class