constructeur pour classe abstraite

Bonjour
je mets en pratique la notion d'interface et abstraite.
Ce que j'arrive pas à enregistrer est la création d'un constructeur pour une classe abstraite employés.
Pourquoi crée un constructeur pour une classe qu'on ne peut pas instancier.
si j'ai bien compris, une classe Abstraite n'est pas instanciable.

Merci de m'éclairer.

Une classe abstraite est un peu un modèle et ce sont ses classes dérivées qui peuvent être instanciées.

Bonjour,

si ta classe C hérite d'une classe P (abstraite ou non), chacun des constructeurs définis dans C appellera un constructeur de la classe P.

Même si tu ne mets pas d'appel explicite "super()", l'appel est fait.
Ainsi, les deux codes sont équivalents:
Code:

1 2 3 4 5 public class A { public A() { super(); } }
Code:

1 2 3 4 public class A { public A() { } }
Sachant cela, tu peux avoir envie d'initialiser des membres de ta classe abstraite à l'initialisation. C'est à cela que servira un constructeur dans la classe abstraite.

Salut,

si une classe abstraite ne peut être instanciée, c'est quand même une classe avec des méthodes et des attributs : il est donc nécessaire d'avoir un constructeur.

par exemple :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public abstract class AbstractOperation  {
 
    protected final String operateur;
    protected final int nombreOperandesMinimum;
    protected final int nombreOperandesMaximum;
 
    public AbstractOperation(String operateur, int nombreOperandesMinimum) {
        this(operateur, nombreOperandesMinimum, -1);
    }
    public AbstractOperation(String operateur, int nombreOperandesMinimum, int nombreOperandesMaximum) {
        this.operateur=operateur;
        this.nombreOperandesMinimum=nombreOperandesMinimum;
        this.nombreOperandesMaximum=nombreOperandesMaximum;
    }
 
    public final String getOperateur() {
       return operateur;
    }
 
    public final int calcule(int...operandes) {
        if ( operandes.length<nombreOperandesMinimum ) throw new IllegalArgumentException("Pas assez d'opérandes");
        if ( nombreOperandesMaximum!=-1 && operandes.length>nombreOperandesMaximum) throw new IllegalArgumentException("Trop d'opérandes");
        int resultat=0;
        for(int operande : operandes) {
           resultat = appliqueOperateur(resultat,operande);
        }
        return resultat;
    }
 
    protected abstract int appliqueOperateur(int resultatPrecedent, int operande);
 
    public String toString() {
        return operateur;
    }
 
    public String toString(int...operandes) {
if ( operandes.length<nombreOperandesMinimum ) throw new IllegalArgumentException("Pas assez d'opérandes");
        if ( nombreOperandesMaximum!=-1 && operandes.length>nombreOperandesMaximum) throw new IllegalArgumentException("Trop d'opérandes");
         StringBuilder sb=new StringBuilder();
         for(int i=0;i<operandes.length;i++) {
             if (i>0) sb.append(operateur);
             sb.append(i);
         }
         return sb.toString();
    }
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
public class OperateurPlus extends AbstractOperateur {
 
   public OperateurPlus() {
       super("+",2);
   }
 
    protected final int appliqueOperateur(int resultatPrecedent, int operande) {
        return resultatPrecedent + operande;
    }
 
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class OperateurFactorielle extends AbstractOperateur {
 
   public OperateurFactorielle() {
       super("!",1,1);
   }
 
    protected final int appliqueOperateur(int resultatPrecedent, int operande) {
        int factorielle=1;
        for(int i=2; i<operande; i++){
            factorielle*=i;
        }
        return factorielle;
    }
 
public String toString(int...operandes) {
if ( operandes.length<nombreOperandesMinimum ) throw new IllegalArgumentException("Pas assez d'opérandes");
        if ( nombreOperandesMaximum!=-1 && operandes.length>nombreOperandesMaximum) throw new IllegalArgumentException("Trop d'opérandes");
      return operande[0]+operateur;
    }
 
}

Merci, pour vos éclaircissements.