Perché non campi astratti?

Perché le classi Java non possono avere campi astratti come possono avere metodi astratti?

Ad esempio: ho due classi che estendono la stessa classe base astratta. Queste due classi hanno ciascuna un metodo identico ad eccezione di una costante String, che sembra essere un messaggio di errore, al loro interno. Se i campi potessero essere astratti, potrei rendere astratta questa costante e inserire il metodo nella classe base. Invece, devo creare un metodo astratto, chiamato getErrMsg()in questo caso, che restituisca la String, sovrascriva questo metodo nelle due classi derivate e quindi posso richiamare il metodo (che ora chiama il metodo astratto).

Perché non potevo semplicemente rendere astratto il campo per cominciare? Java potrebbe essere stato progettato per consentire questo?

Puoi fare ciò che hai descritto avendo un campo finale nella tua classe astratta che è inizializzato nel suo costruttore (codice non testato):

abstract class Base {

    final String errMsg;

    Base(String msg) {
        errMsg = msg;
    }

    abstract String doSomething();
}

class Sub extends Base {

    Sub() {
        super("Sub message");
    }

    String doSomething() {

        return errMsg + " from something";
    }
}

Se la tua classe figlia "dimentica" di inizializzare la finale tramite il super costruttore, il compilatore darà un avviso di errore, proprio come quando un metodo astratto non è implementato.

Non ci vedo alcun punto. Puoi spostare la funzione nella classe astratta e sovrascrivere semplicemente un campo protetto. Non so se funziona con le costanti ma l'effetto è lo stesso:

public abstract class Abstract {
    protected String errorMsg = "";

    public String getErrMsg() {
        return this.errorMsg;
    }
}

public class Foo extends Abstract {
    public Foo() {
       this.errorMsg = "Foo";
    }

}

public class Bar extends Abstract {
    public Bar() {
       this.errorMsg = "Bar";
    }
}

Quindi il tuo punto è che vuoi imporre l'implementazione / l'override / qualsiasi cosa errorMsgnelle sottoclassi? Pensavo volessi solo avere il metodo nella classe base e non sapessi come affrontare il campo allora.

Ovviamente avrebbe potuto essere progettato per consentire questo, ma sotto le coperte avrebbe comunque dovuto eseguire un invio dinamico, e quindi una chiamata al metodo. Il design di Java (almeno all'inizio) era, in una certa misura, un tentativo di essere minimalista. Cioè, i progettisti hanno cercato di evitare di aggiungere nuove funzionalità se potevano essere facilmente simulate da altre funzionalità già presenti nel linguaggio.

Leggendo il tuo titolo, ho pensato che ti stessi riferendo a membri di istanze astratte; e non ne vedevo molto utile. Ma i membri statici astratti è tutta un'altra cosa.

Ho spesso desiderato di poter dichiarare un metodo come il seguente in Java:

public abstract class MyClass {

    public static abstract MyClass createInstance();

    // more stuff...

}

Fondamentalmente, vorrei insistere sul fatto che le implementazioni concrete della mia classe genitore forniscono un metodo factory statico con una firma specifica. Ciò mi consentirebbe di ottenere un riferimento a una classe concreta con Class.forName()ed essere certo di poterne costruire uno in una convenzione di mia scelta.

Un'altra opzione è definire il campo come pubblico (finale, se lo desideri) nella classe di base, quindi inizializzare quel campo nel costruttore della classe di base, a seconda della sottoclasse attualmente utilizzata. È un po 'losco, in quanto introduce una dipendenza circolare. Ma almeno non è una dipendenza che può mai cambiare - cioè, la sottoclasse esisterà o non esisterà, ma i metodi oi campi della sottoclasse non possono influenzare il valore di field.

public abstract class Base {
  public final int field;
  public Base() {
    if (this instanceof SubClassOne) {
      field = 1;
    } else if (this instanceof SubClassTwo) {
      field = 2;
    } else {
      // assertion, thrown exception, set to -1, whatever you want to do 
      // to trigger an error
      field = -1;
    }
  }
}