Constantes abstraites??

Version imprimable

29/04/2006, 18h21
Razgriz

Constantes abstraites??
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:

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?
29/04/2006, 21h14
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:

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

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
30/04/2006, 02h25
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:

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...

8-)

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:

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;
    }

30/04/2006, 12h18
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é.

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:

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);
   ...
}

02/05/2006, 06h59
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
02/05/2006, 23h40
Razgriz

oui mais pour les puissances le problème n'est pas résolu... Vu qu'on utilise des fonctions exponentielles et logarithmiques, que je ne VEUX pas utiliser.

Pour les racines je m'en sors comme suit :
Pour la reice nième de u, je construis le polynome x^n - u = 0.
J'applique l'algotithme de Newton, (je suis certain que les hypothèses sont vérifiées car les polynômes sont simples) et je trouve une racine réelle : racine n-ième de u...

Il fallait y penser ;-)
05/05/2006, 13h44
Razgriz

c'est bon j'ai trouvé je ne m'y prenais pas bien... Il suffit de créer un interface Identity, avec une seule méthode, identity(), que je devrais implémenter dans toutes mes classes matrice, polynome, complex, ...
Tout simplement.