Lo stesso metodo in Interfaccia e class astratta

Sono arrivato alla situazione:

public interface Intr { public void m1(); } public abstract class Abs { public void m1() { System.out.println("Abs.m1()"); } // public abstract void m1(); } public class A extends Abs implements Intr { @Override public void m1() { // which method am I overriding, well it is Abs.m1() but why? // if method implemented is Abs.m1(), then why I am not getting error for Intr.m1() not implemented. } } 

Stai soddisfacendo entrambe le condizioni contemporaneamente; vale a dire. l’unica implementazione soddisfa allo stesso tempo i requisiti astratti della class e i requisiti dell’interfaccia.

Come nota, a meno che tu non stia utilizzando Intr in un’altra catena ereditaria, non ne hai bisogno. Inoltre, potrebbe avere senso spostare le implements Intr fino alla definizione astratta della class.

Puoi solo eseguire l’override dei metodi definiti in un’altra class.

I metodi dichiarati in un’interfaccia sono semplicemente implementati. Questa distinzione esiste in Java per affrontare il problema dell’ereditarietà multipla. Una class può estendere solo una class genitore, quindi tutte le chiamate a super verranno risolte senza ambiguità. Le classi tuttavia possono implementare diverse interfacce, che possono dichiarare tutti lo stesso metodo. È meglio pensare alle interfacce come a un elenco di “must have”: per qualificarsi come Comparable tuo cluss deve avere un metodo compareTo() ma non importa da dove proviene o quali altre interfacce richiedono lo stesso metodo.

Quindi tecnicamente hai scavalcato Abs.m1() e implementa Intr.m1() in un colpo solo.

Nota che anche questo andrebbe bene:

 public class B extends Abs implements Intr { //m1() is inherited from Abs, so there's no need to override it to satisfy the interface } 

@Override ti garantisce di sovrascrivere il metodo senza alcuna differenza Interfaccia o superclass astratta. Quindi nessun errore con override.

Dall’altro lato, il metodo di interfaccia è implementato anche in super-class, il che è sufficiente per il contratto di interfaccia.

Qui sia l’interfaccia che la class astratta hanno lo stesso metodo.

Hai un nome di class è ciao ed ha estrapolato la class astratta e l’interfaccia di implementazione è vero e hai sovrascritto il metodo meth1 su hello class e la sua compilazione è corretta e non gli viene dato alcun errore ma lei non è ansible identificare quale metodo di class è sovrascritto come class astratta o interfaccia.

Questo è il polimorfismo di runtime che non puoi creare object di class astratta e interfaccia ma puoi creare una variabile di riferimento. Qui la soluzione è che non è ansible identificare che in fase di compilazione il suo override effettivo in fase di esecuzione.

 interface hi { public void meth1(); } abstract class Hullo { public abstract void meth1(); } public class Hello extends Hullo implements hi { public void meth1(){ System.out.println("hello"); } hi h= new Hello(); h.meth1();//its means interface method is override. and its decide when we call method. hullo hu= new Hello(); hu.meth1();//its means abstract class method is override. }