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

Ciò che voglio dire è:

interface B {...}

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

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

Ho cercato su Google e ho trovato questo :

implementsdenota la definizione di 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 come "interfaccia"?

Nei dettagli,

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

implementssignifica implementazione, quando interfacesi intende dichiarare solo per fornire interfacenon implementazione.

Un 100% abstract classè funzionalmente equivalente a un interfacema può anche avere un'implementazione se lo desideri (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.

implementssignifica che verrà definito un comportamento per i abstractmetodi (eccetto ovviamente per le classi astratte), tu definisci l'implementazione.

extends significa che un comportamento viene ereditato.

Con le interfacce è possibile dire che un'interfaccia dovrebbe avere lo stesso comportamento di un'altra, non c'è nemmeno un'implementazione effettiva. Ecco perché ha più senso per un'interfaccia a extendsun'altra interfaccia invece di implementarla.

In una nota a margine, ricorda che anche se una abstractclasse può definire abstractmetodi (il modo sano di fare un'interfaccia), è ancora una classe e deve ancora essere ereditata (estesa) e non implementata.

Concettualmente ci sono le due classi e interfacce "domini". All'interno di questi domini ti estendi sempre, solo una classe implementa un'interfaccia, che è una specie di "attraversamento del confine". Quindi fondamentalmente "extends" per le interfacce rispecchia il comportamento delle classi. Almeno penso che questa sia la logica dietro. Sembra che non tutti siano d'accordo con questo tipo di logica (anch'io la trovo un po 'artificiosa), e in effetti non c'è alcuna ragione tecnica per avere due parole chiave diverse.

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

Questa è semplicemente una questione di convenzione. Gli autori del linguaggio Java hanno deciso che "si estende" è il modo migliore per descrivere questa relazione, quindi è quello che usiamo tutti.

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

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

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

Implements denota 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 tieni a mente una cosa un'interfaccia può solo estendere un'altra interfaccia e se vuoi 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 è come sarebbe:

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

    }

    public boolean isGoldenRetriever{
    // method definition here
    }
}

e se una classe astratta ha una funzione astratta definita e dichiarata e vuoi definire quelle funzioni o puoi dire implementa quelle funzioni, allora supponi di estendere quella classe perché la classe astratta può solo essere estesa. ecco un esempio di seguito.

public abstract class MyAbstractClass {

    public abstract void abstractMethod();
}

Ecco una sottoclasse di esempio di MyAbstractClass:

public class MySubClass extends MyAbstractClass {

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

L'interfaccia è come un'astrazione che non fornisce alcuna funzionalità. Quindi non "implementa" ma estende le altre astrazioni o interfacce.

Interface è 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 implementarla.