Interfaccia astratta Java

Considera un esempio (che compila in java)

public abstract interface Interface {
    public void interfacing();
    public abstract boolean interfacing(boolean really);
}

Perché è necessario che un'interfaccia sia "dichiarata" astratta? Esistono altre regole che si applicano con un'interfaccia astratta?

Infine: se abstractè obsoleto, perché è incluso in Java? Esiste una storia per l'interfaccia astratta?

Perché è necessario che un'interfaccia sia "dichiarata" astratta?

Non è.

public abstract interface Interface {
       \___.__/
           |
           '----> Neither this...

    public void interfacing();
    public abstract boolean interfacing(boolean really);
           \___.__/
               |
               '----> nor this, are necessary.
}

Le interfacce e i loro metodi sono implicitamente abstracte l'aggiunta di quel modificatore non fa differenza.

Esistono altre regole che si applicano con un'interfaccia astratta?

No, si applicano le stesse regole. Il metodo deve essere implementato da qualsiasi classe di implementazione (concreta).

Se l'abstract è obsoleto, perché è incluso in Java? Esiste una storia per l'interfaccia astratta?

Domanda interessante. Ho scavato la prima edizione di JLS e anche lì dice "Questo modificatore è obsoleto e non dovrebbe essere usato nei nuovi programmi Java" .

Va bene, scavando ancora di più ... Dopo aver colpito numerosi collegamenti interrotti, sono riuscito a trovare una copia della specifica Oak 0.2 originale (o "manuale"). Devo dire che è piuttosto interessante leggere, e solo 38 pagine in totale! :-)

Nella sezione 5, Interfacce, fornisce il seguente esempio:

public interface Storing {
    void freezeDry(Stream s) = 0;
    void reconstitute(Stream s) = 0;
}

E a margine dice

In futuro, la parte "= 0" dei metodi di dichiarazione nelle interfacce potrebbe scomparire.

Supponendo che sia =0stato sostituito dalla abstractparola chiave, sospetto che abstractad un certo punto fosse obbligatorio per i metodi di interfaccia!

Articolo correlato: Java: interfacce astratte e metodi di interfaccia astratti

Non è necessario, è facoltativo, proprio come publicsui metodi di interfaccia.

Vedi il JLS su questo:

http://java.sun.com/docs/books/jls/second_edition/html/interfaces.doc.html

9.1.1.1 Interfacce astratte Ogni interfaccia è implicitamente astratta. Questo modificatore è obsoleto e non deve essere utilizzato in nuovi programmi.

E

9.4 Dichiarazioni sui metodi astratti

[...]

Per compatibilità con le versioni precedenti della piattaforma Java, è consentito ma scoraggiato, per motivi di stile, specificare in modo ridondante il modificatore astratto per i metodi dichiarati nelle interfacce.

È consentito, ma fortemente scoraggiato come una questione di stile, specificare in modo ridondante il modificatore pubblico per i metodi di interfaccia.

Non è necessario dichiarare l'interfaccia astratta.

Proprio come dichiarare pubblici tutti quei metodi (che sono già se l'interfaccia è pubblica) o astratti (che sono già in un'interfaccia) è ridondante.

Nessuno ti sta fermando, però.

Altre cose che puoi dichiarare esplicitamente, ma non è necessario:

• chiama super () sulla prima riga di un costruttore
• extends Object
• implementare interfacce ereditate

Esistono altre regole che si applicano con un'interfaccia astratta?

Un'interfaccia è già "astratta". L'applicazione di tale parola chiave non fa assolutamente alcuna differenza.

Essere consapevoli del fatto che in primavera ha un significato non accademico. L'interfaccia astratta è un avvertimento per lo sviluppatore di non usarla per @Autowired. Spero che primavera / eclissi@Autowired guarderà questo attributo e avvertirà / fallirà sugli usi di tale.

Un esempio reale: il proxy @Service in @Transnational in un @Repository deve utilizzare gli stessi metodi di base, tuttavia dovrebbero utilizzare interfacce diverse che estendono questa interfaccia astratta a causa di @Autowired. (Chiamo questa interfaccia XXXSpec)

Ogni interfaccia è implicitamente astratta.
Questo modificatore è obsoleto e non deve essere utilizzato in nuovi programmi.

[Le specifiche del linguaggio Java - 9.1.1.1 abstractInterfacce]

Si noti inoltre che i metodi dei membri dell'interfaccia sono implicitamente public abstract.
[Le specifiche del linguaggio Java - 9.2 Interface Interface]

Perché questi modificatori sono impliciti? Non c'è nessun altro modificatore (nemmeno il modificatore ' nessun modificatore ') che sarebbe utile qui, quindi non è necessario digitarlo esplicitamente.

Non è necessario È una stranezza della lingua.

Non è necessario, poiché le interfacce sono astratte per impostazione predefinita in quanto tutti i metodi in un'interfaccia sono astratti.

Un'interfaccia astratta non è così ridondante come tutti sembrano dire, almeno in teoria.

Un'interfaccia può essere estesa, proprio come una classe. Se si progetta una gerarchia di interfaccia per la propria applicazione, è possibile che si disponga di un'interfaccia "Base", si estendono altre interfacce da ma non si desidera come oggetto in sé.

Esempio:

public abstract interface MyBaseInterface {
    public String getName();
}

public interface MyBoat extends MyBaseInterface {
    public String getMastSize();
}

public interface MyDog extends MyBaseInterface {
    public long tinsOfFoodPerDay();
}

Non si desidera che una classe implementi MyBaseInterface, solo gli altri due, MMyDog e MyBoat, ma entrambe le interfacce condividono l'interfaccia MyBaseInterface, quindi hanno una proprietà 'name'.

So che è un po 'accademico, ma ho pensato che alcuni potrebbero trovarlo interessante. :-)

In questo caso è davvero solo un 'indicatore' per segnalare agli implementatori dell'interfaccia che non è stato progettato per essere implementato da solo. Dovrei sottolineare che un compilatore (almeno il sun / ora 1.6 con cui l'ho provato) compila una classe che implementa un'interfaccia astratta.

Bene, "Abstract Interface" è un costrutto lessicale: http://en.wikipedia.org/wiki/Lexical_analysis .

È richiesto dal compilatore, puoi anche scrivere interface.

Beh, non entrare troppo nel costrutto lessicale del linguaggio in quanto potrebbero averlo messo lì per risolvere alcune ambiguità di compilazione che vengono definite casi speciali durante il processo di compilazione o per una certa compatibilità con le versioni precedenti, prova a concentrarti sul costrutto Lexical di base.

L'essenza di `interfaccia è catturare alcuni concetti astratti (idea / pensiero / pensiero di ordine superiore ecc.) La cui implementazione può variare ... cioè, ci può essere implementazione multipla.

Un'interfaccia è un tipo di dati astratto puro che rappresenta le caratteristiche dell'oggetto che sta acquisendo o rappresentando.

Le caratteristiche possono essere rappresentate dallo spazio o dal tempo. Quando sono rappresentati dallo spazio (memoria) significa che la tua classe concreta implementerà un campo e un metodo / metodi che opereranno su quel campo o nel tempo, il che significa che il compito di implementare la funzione è puramente computazionale (richiede più orologi CPU per l'elaborazione) in modo da avere un compromesso tra spazio e tempo per l'implementazione delle funzionalità.

Se la tua classe concreta non implementa tutte le funzionalità, diventa di nuovo astratta perché hai un'implementazione del tuo pensiero o idea o astrattezza ma non è completa, la specifichi per abstractclasse.

Una classe concreta sarà una classe / serie di classi che cattureranno completamente l'astrattezza che stai cercando di catturare la classe XYZ.

Quindi il modello è

Interface--->Abstract class/Abstract classes(depends)-->Concrete class