È possibile ma non come l'avete.
Devi aggiungere un costruttore no-args alla classe base e il gioco è fatto!
public abstract class A {
private String name;
public A(){
this.name = getName();
}
public abstract String getName();
public String toString(){
return "simple class name: " + this.getClass().getSimpleName() + " name:\"" + this.name + "\"";
}
}
class B extends A {
public String getName(){
return "my name is B";
}
public static void main(String [] args) {
System.out.println(new C());
}
}
class C extends A {
public String getName() {
return "Zee";
}
}
quando non si aggiunge un costruttore (qualsiasi) a una classe il compilatore aggiungere il valore predefinito non contructor arg per voi.
Quando il defualt no arg chiama a super(); e dal momento che non ce l'hai nella super classe ricevi questo messaggio di errore.
Questa è la domanda.
Ora, ampliando la risposta:
Sei consapevole che la creazione di una sottoclasse (comportamento) per specificare un valore diverso diverso (i dati) non ha senso ?? !!! Spero che tu lo faccia.
Se l'unica cosa che cambia è il "nome", basta una sola classe parametrizzata!
Quindi non è necessario questo:
MyClass a = new A("A");
MyClass b = new B("B");
MyClass c = new C("C");
MyClass d = new D("D");
o
MyClass a = new A(); // internally setting "A" "B", "C" etc.
MyClass b = new B();
MyClass c = new C();
MyClass d = new D();
Quando puoi scrivere questo:
MyClass a = new MyClass("A");
MyClass b = new MyClass("B");
MyClass c = new MyClass("C");
MyClass d = new MyClass("D");
If I were to change the method signature of the BaseClass constructor, I would have to change all the subclasses.
Beh questo è il motivo per cui l'ereditarietà è l'artefatto quello crea l'accoppiamento ALTO, che è unde siribile nei sistemi OO. Dovrebbe essere evitato e forse sostituito con la composizione.
Pensa se davvero ne hai davvero bisogno come sottoclasse. Ecco perché si vede molto spesso interfacce utilizzate insted:
public interface NameAware {
public String getName();
}
class A implements NameAware ...
class B implements NameAware ...
class C ... etc.
Qui B e C potrebbero hanno ereditato da A, che avrebbe creato un livello molto alto di accoppiamento tra loro, utilizzando le interfacce l'accoppiamento è ridotto, se A decide lo farà non sarà più "NameAware", le altre classi non si romperanno.
Ovviamente, se si desidera riutilizzare il comportamento, questo non funzionerà.
Per favore, lascia il costruttore 'ridondante'! Mantiene la leggibilità del tuo codice e tutti i moderni IDE possono crearlo automaticamente, quindi devi solo digitare una scorciatoia. –
Rileggendo la mia domanda un anno dopo e mi viene in mente che avrei potuto rimuovere i costruttori (incluso nella classe base) come suggerito da matt b, e quindi usare un metodo factory statico per creare istanze. – Joel