Discussion :

[Razgriz]

est-il possible de définir dans une classe abstraite un constante abstraite, càd une constante que je devrais définir dans les sous classes, dans mon cas, on a la classe abstraite MathObject :

et je veux faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
public static abstract  final MathObject IDENTITY;

le but étant de redéfinir IDENTITY. Dans le cas de la sous-classe Matrix, il représentera la matrice identité, dans le cas d'un nombre complexe, le complexe 1 + 0 i , etc...

Comment peux-t-on faire?

[mavina]

Il n'est pas possible de créer des variables abstraites, et puis tu aurais pu le voire, ca ne passe pas à la compilation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
public abstract class Test
 {
  public static abstract final Test test;
 }

D:\projets\developpez.com\Test.java:5: modifier abstract not allowed here
public static abstract final Test test;
^
1 error

Par contre, tu ne peux pas définir une variable d'une classe abstraite en final, ça n'a pas de sens...

mavina

[Pill_S]

Impossible de créer des constantes abstraites.... soit...

Mais pourquoi ne pas utiliser des méthodes qui devront renvoyer cette fameuse constante !?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
interface I {
  int getConst();
}
...
class C1 implements I {
  public int getConst(){return 1;}
}
class C2 implements I {
  public int getConst(){return 2;}
}
...

Il faut juste que les classes qui implémentent l'interface respectent son contrat, à savoir que plusieurs appels successifs à la méthode getConst doivent toujours renvoyer la même valeur...

Si on y réfléchit, nul besoin d'utiliser des constantes abstraites, les méthodes peuvent les remplacer avantageusement...

C'est bien foutu Java quand même...

[Razgriz]

bah, j'ai résolu le problème autrement : je mets ici le bout de code, il entre dans la conception d'une librairie mathématique :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
     /**
     * Returns a MathObject at the power n.     
     * @param n the power to apply to the MathObject.
     * @param obj the MathObject to get the power.
     * @return a MathObject at the power n.
     **/
    public static MathObject pow(int n, MathObject obj)
    {        
        if(n == 0)
        {
            if(obj instanceof ComplexNumber)
            {
                ComplexNumber cplx = (ComplexNumber)obj;
                return new ComplexNumber(1);
            }
            else if(obj instanceof Polynome)
                return new Polynome(1);
            else if(obj instanceof Matrix)
            {
                Matrix mat = (Matrix)obj;
                return new Matrix(mat.getNbrRows(), Matrix.IDENTITY, null);
            }
        }
    else if(n % 2 == 0)        
        obj = pow(2 , pow(n/2 , obj));        
    else
        obj.multpiply(pow(2 , pow(n/2 , obj)));
    return obj;
    }

[Razgriz]

lol c'est peut-être un peu obscur, mais pour ne pas vous mettre tous les codes, new Polynome(1) construit un polynome constant (le seul terme étant égal à 1), new ComplexNumber(1) construit le réél 1, et la dernière instruction construit une matrice identité.

[herve91]

Le problème avec ton implémentation c'est que le jour où tu voudras gérer d'autres types de MathObj, tu seras obligé de modifier le code de la méthode pow(). Il serait plus judicieux d'utiliser le polymorphisme :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public abstract class MathObject {
   ...
   public abstract MathObject valueOf(int n);
}
 
public class ComplexNumber {
   public MathObject valueOf(int n) {
      return new ComplexNumber(n);
   }
}
 
public class Matrix {
   public MathObject valueOf(int n) {
      return new Matrix(this.getNbrRows(), IDENTITY.multiply(n), null);
   }
}
 
public static pow(int n, MathObject obj) {        
   if (n == 0) {
      return obj.valueOf(1);
   ...
}

[bouye]

Et meme la c'est pas super complet puisque si mes (faibles et tres lointains) souvenirs de maths sont bons ca ne permet pas de faire des racines (ex : racine carrree (4) = 4 ^ ½) et autres puissances negatives (ex: nottation scientifique 10 ^ -1)...
Autant coder la fonction puissance* directement avec des simplification/surcharges speciales quand on a des nombres entiers.

* xª = e ^ (a ln x)

X appartient a IR+
a appartient a IR