C'est possible mais pas comme vous l'avez.
Vous devez ajouter un constructeur no-args à la classe de base et c'est tout!
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";
}
}
Lorsque vous n'ajoutez pas de constructeur (aucun) à une classe, le compilateur ajoute le constructeur par défaut no arg pour vous.
Quand defualt no arg appelle super (); et comme vous ne l'avez pas dans la super classe, vous obtenez ce message d'erreur.
C'est à peu près la question en soi.
Maintenant, élargissez la réponse:
Etes-vous conscient que la création d'une sous-classe (comportement) pour spécifier une valeur différente (données) n'a aucun sens ?? !!! J'espère que tu vas le faire.
Si la seule chose qui change est le "nom" alors une seule classe paramétrée suffit!
Vous n'avez donc pas besoin de ceci:
MyClass a = new A("A");
MyClass b = new B("B");
MyClass c = new C("C");
MyClass d = new D("D");
ou
MyClass a = new A(); // internally setting "A" "B", "C" etc.
MyClass b = new B();
MyClass c = new C();
MyClass d = new D();
Quand vous pouvez écrire ceci:
MyClass a = new MyClass("A");
MyClass b = new MyClass("B");
MyClass c = new MyClass("C");
MyClass d = new MyClass("D");
Si je devais changer la signature de méthode du constructeur BaseClass, je devrais changer toutes les sous-classes.
Eh bien, c'est pourquoi l'héritage est l'artefact qui crée un couplage HIGH, ce qui n'est pas souhaitable dans les systèmes OO. Il devrait être évité et peut-être remplacé par la composition.
Pensez si vous en avez vraiment besoin en tant que sous-classe. C'est pourquoi vous voyez très souvent des interfaces utilisées instées:
public interface NameAware {
public String getName();
}
class A implements NameAware ...
class B implements NameAware ...
class C ... etc.
Ici, B et C auraient pu hériter de A qui aurait créé un couplage très ÉLEVÉ entre eux, en utilisant des interfaces le couplage est réduit, si A décide qu'il ne sera plus "NameAware" les autres classes ne seront pas cassées.
Bien sûr, si vous souhaitez réutiliser un comportement, cela ne fonctionnera pas.