Perché un'interfaccia non può implementare un'altra interfaccia?

Question

Voglio dire:

interface B {...} 

interface A extends B {...} // allowed 

interface A implements B {...} // not allowed 

I googled e ho trovato this:

implements indicato definente un'implementazione per i metodi di un'interfaccia. Tuttavia le interfacce non hanno implementazione, quindi non è possibile.

Tuttavia, l'interfaccia è una classe astratta al 100% e una classe astratta può implementare interfacce (classe astratta al 100%) senza implementarne i metodi. Qual è il problema quando si definisce "interfaccia"?

In dettaglio,

interface A { 
    void methodA(); 
} 

abstract class B implements A {} // we may not implement methodA() but allowed 

class C extends B { 
    void methodA(){} 
} 

interface B implements A {} // not allowed. 
//however, interface B = %100 abstract class B 

Answer 1

implements mezzi di attuazione, quando interface è destinato a dichiarare solo per fornire interface non per l'attuazione.

A 100% abstract class è funzionalmente equivalente a un interface ma può anche avere applicazione se lo si desidera (in questo caso non rimarrà al 100% abstract), quindi dal punto di vista della JVM sono cose diverse.

Anche la variabile membro in una classe astratta al 100% può avere qualsiasi qualificatore di accesso, dove in un'interfaccia sono implicitamente public static final.

Answer 2

implements significa che verrà definito un comportamento per i metodi abstract (tranne ovviamente per le classi astratte), si definisce l'implementazione.

extends significa che un comportamento è ereditato.

Con le interfacce è possibile affermare che un'interfaccia deve avere lo stesso comportamento di un'altra, non esiste nemmeno un'implementazione effettiva. Ecco perché ha più senso un'interfaccia su extends un'altra interfaccia invece di implementarla.

---

Su un lato nota, ricorda che, anche se una classe abstract può definire abstract metodi (il modo sano un'interfaccia fa), è ancora una classee deve ancora essere ereditato (estesa) e non implementato.

Answer 3

Concettualmente ci sono le due classi e le interfacce "domini". All'interno di questi domini si sta sempre estendendo, solo una classe implementa un'interfaccia, che è una specie di "attraversamento del confine". Quindi sostanzialmente "estende" per le interfacce rispecchia il comportamento per le classi. Almeno penso che questa sia la logica dietro. Sembra che non tutti siano d'accordo con questo tipo di logica (lo trovo un po 'artificioso), e in effetti non vi è alcun motivo tecnico per avere due parole chiave diverse.

Answer 4

L'interfaccia è la classe che contiene un metodo astratto che non può creare alcun oggetto. Poiché Interface non può creare l'oggetto e non è una classe pura, non vale la pena di implementarlo.

Answer 5

Tuttavia, interfaccia è al 100% classe astratta e classe astratta può attrezzi interfaccia (100% classe astratta) senza attuare le metodi. Qual è il problema quando si definisce "interfaccia"?

Questa è semplicemente una questione di convenzione. Gli scrittori del linguaggio java hanno deciso che "extends" è il modo migliore per descrivere questa relazione, quindi è quello che usiamo tutti.

In generale, anche se un'interfaccia è "una classe astratta al 100%", non le pensiamo in questo modo. Di solito consideriamo le interfacce come una promessa per implementare determinati metodi chiave piuttosto che una classe da cui derivare. E quindi tendiamo a usare un linguaggio diverso per le interfacce piuttosto che per le classi.

Come altri dichiarano, ci sono buone ragioni per scegliere "estende" su "attrezzi".

Answer 6

Spero che questo ti aiuti un po 'quello che ho imparato in oops (core java) durante il mio college.

Implementa la definizione di un'implementazione per i metodi di un'interfaccia. Tuttavia le interfacce non hanno implementazione, quindi non è possibile. Un'interfaccia può tuttavia estendere un'altra interfaccia, il che significa che può aggiungere più metodi ed ereditare il suo tipo.

Ecco un esempio di seguito, questa è la mia comprensione e ciò che ho imparato in oops.

interface ParentInterface{ 
     void myMethod(); 
} 

interface SubInterface extends ParentInterface{ 
     void anotherMethod(); 
} 

e mantenere una cosa in mente una sola interfaccia può estendere solo un'altra interfaccia e se si vuole definire la sua funzione su qualche classe allora solo un'interfaccia implementata ad esempio sotto

public interface Dog 
{ 
    public boolean Barks(); 

    public boolean isGoldenRetriever(); 
} 

Ora, se una classe dovesse implementare questa interfaccia, questo è ciò che sarebbe simile:

public class SomeClass implements Dog 
{ 
    public boolean Barks{ 
    // method definition here 

    } 

    public boolean isGoldenRetriever{ 
    // method definition here 
    } 
} 

e se una classe astratta ha una certa funzione astratta definire e dichiarare e si desidera definire coloro f Unzione o si può dire implementare quelle funzioni quindi si suppone di estendere quella classe perché la classe astratta può essere estesa solo. ecco un esempio qui sotto.

public abstract class MyAbstractClass { 

    public abstract void abstractMethod(); 
} 

Ecco un esempio sottoclasse di MyAbstractClass:

public class MySubClass extends MyAbstractClass { 

    public void abstractMethod() { 
     System.out.println("My method implementation"); 
    } 
}