Perché una classe astratta che implementa un'interfaccia può perdere la dichiarazione / implementazione di uno dei metodi dell'interfaccia?

Una cosa curiosa accade in Java quando si utilizza una classe astratta per implementare un'interfaccia: alcuni dei metodi dell'interfaccia possono mancare completamente (cioè non è presente né una dichiarazione astratta né un'implementazione effettiva), ma il compilatore non si lamenta.

Ad esempio, data l'interfaccia:

public interface IAnything {
  void m1();
  void m2();
  void m3();
}

la seguente classe astratta viene allegramente compilata senza un avviso o un errore:

public abstract class AbstractThing implements IAnything {
  public void m1() {}
  public void m3() {}
}

Puoi spiegare perché?

Questo perché se una classe è astratta, per definizione ti viene richiesto di creare sottoclassi di essa per istanziarla. Le sottoclassi saranno richieste (dal compilatore) per implementare tutti i metodi di interfaccia che la classe astratta ha omesso.

Seguendo il codice di esempio, prova a creare una sottoclasse di AbstractThingsenza implementare il m2metodo e guarda quali errori ti dà il compilatore. Ti costringerà a implementare questo metodo.

Perfettamente bene.
Non puoi istanziare classi astratte ... ma le classi astratte possono essere usate per ospitare implementazioni comuni per m1 () e m3 ().
Quindi, se l' implementazione di m2 () è diversa per ciascuna implementazione, ma m1 e m3 non lo sono. È possibile creare diverse implementazioni concrete di IAnything solo con la diversa implementazione m2 e derivare da AbstractThing, onorando il principio DRY. Convalidare se l'interfaccia è completamente implementata per una classe astratta è inutile.

Aggiornamento : è interessante notare che C # lo impone come errore di compilazione. Sei costretto a copiare le firme del metodo e anteporre loro 'abstract public' nella classe base astratta in questo scenario .. (qualcosa di nuovo ogni giorno :)

Va bene. Per capire quanto sopra, devi prima capire la natura delle classi astratte. Sono simili alle interfacce da questo punto di vista. Questo è ciò che Oracle dice al riguardo qui .

Le classi astratte sono simili alle interfacce. Non è possibile istanziarli e possono contenere una combinazione di metodi dichiarati con o senza un'implementazione.

Quindi devi pensare a cosa succede quando un'interfaccia estende un'altra interfaccia. Per esempio ...

//Filename: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}

//Filename: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}

... come puoi vedere, anche questo si compila perfettamente. Semplicemente perché, proprio come una classe astratta, NON è possibile istanziare un'interfaccia. Quindi, non è necessario menzionare esplicitamente i metodi dal suo "genitore". Tuttavia, TUTTE le firme del metodo genitore FANNO implicitamente parte dell'interfaccia che si estende o implementa la classe astratta. Quindi, una volta che una classe appropriata (una che può essere istanziata) estende quanto sopra, sarà richiesto di garantire che ogni singolo metodo astratto sia implementato.

Spero che questo aiuti ... e Allahu 'alam!

Interfaccia indica una classe che non ha implementazione del proprio metodo, ma solo con dichiarazione.
D'altra parte, la classe astratta è una classe che può avere l'implementazione di un metodo insieme a un metodo con solo dichiarazione, nessuna implementazione.
Quando implementiamo un'interfaccia per una classe astratta, significa che la classe astratta ha ereditato tutti i metodi dell'interfaccia. Poiché, non è importante implementare tutto il metodo nella classe astratta, tuttavia si tratta di una classe astratta (anche per ereditarietà), quindi la classe astratta può lasciare parte del metodo nell'interfaccia senza implementazione qui. Ma, quando questa classe astratta verrà ereditata da una classe concreta, dovranno implementare tutti quei metodi non implementati presenti nella classe astratta.

Data l'interfaccia:

public interface IAnything {
  int i;
  void m1();
  void m2();
  void m3();
}

Questo è il modo in cui Java lo vede effettivamente:

public interface IAnything {
  public static final int i;
  public abstract void m1();
  public abstract void m2();
  public abstract void m3();
}

Quindi puoi lasciare alcuni (o tutti) questi abstractmetodi non implementati, proprio come faresti nel caso di abstractclassi che estendono un'altra abstractclasse.

Quando si implementan interface, la regola che tutti i interfacemetodi devono essere implementati nel derivato class, si applica solo classall'implementazione concreta (cioè, che non è di per abstractsé).

Se hai davvero intenzione di crearne uno abstract class, allora non esiste una regola che ti dica che devi utilizzare implementtutti i interfacemetodi (nota che in tal caso è obbligatorio dichiarare il derivato classcome abstract)

Quando una classe astratta implementa un'interfaccia

Nella sezione sulle interfacce, è stato notato che una classe che implementa un'interfaccia deve implementare tutti i metodi dell'interfaccia. È possibile, tuttavia, definire una classe che non implementa tutti i metodi dell'interfaccia, a condizione che la classe sia dichiarata astratta. Per esempio,

abstract class X implements Y {   
    // implements all but one method of Y
}

class XX extends X {   
    // implements the remaining method in Y 
} 

In questo caso, la classe X deve essere astratta perché non implementa completamente Y, ma la classe XX, infatti, implementa Y.

Riferimento: http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html

Le classi astratte non sono necessarie per implementare i metodi. Quindi, anche se implementa un'interfaccia, i metodi astratti dell'interfaccia possono rimanere astratti. Se provi a implementare un'interfaccia in una classe concreta (cioè non astratta) e non implementi i metodi astratti, il compilatore ti dirà: o implementa i metodi astratti o dichiara la classe come astratta.