Discussion :

[5leipnir]

Bonjour, j'ai un problème lié à l'imposibilité de mettre des fonctions statiques dans une interface, et bien qu'ayant vu plein de message parlant de ça je n'ai pas encore trouvé de réponse adaptée...

Je voudrais implementer un algo valide sur different corps.

Je voudrais pouvoir utiliser mon code en gros comme cela dans l'idéal:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class GF17 extends GFp { static int modulo=17; }
 
public class Algo {
    GFelement<GF17> a;
    GFelement<GF17> b;
 
    public GFelement<GF17> monalgo() {
       a=new GFelement<GF17>(val_a);
       b=new GFelement<GF17>(val_b);
       return GF17.add(a,b);
   }
}

toutes les solutions que j'ai essayé ne marchent pas... Existe -t-il un moyen de faire ça proprement en Java ?

[fabszn]

Hello,

Est ce que tu pourrais détailler ta problématique... car la c'est un peu obscure..

[5leipnir]

bon, par exemple, une version qui marche presque...

je défini une interface

Code :

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

1
2
3
4
 
public interface GF {
    int add(int a,int b);
}

ensuite je défini une classe abstraite

Code :

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

1
2
3
4
5
6
7
 
public abstract class GFp implements GF {
    int modulo;
    public int add(int a,int b) {
	return (a+b)%modulo;
    }
}

enfin une classe pour les elements d'un corps

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public class GFelem<T extends GFp> {
    private int value;
 
    public GFelem(int v) { value=v; }
    public int intValue() { return value; }
    public GFelem<T> add(GFelem<T> a) {
	return new GFelem<T>(T.add(value,a.intValue()));
    }
}

Ensuite, j'utilise tout ça

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class GFp17 extends GFp {
    static int modulo=17;
}
 
public class Main {
    public static final void main(String[] args) {
	GFelem<GFp17> a=new GFelem<GFp17>(12);
 
	a.add(a);
 
	System.out.println(a.intValue());
    }
}

Ça compile... mais à l'execution, erreur, add n'est pas une méthode statique.
Je sais, et je suis d'accord, ça n'a pas de raison de marcher...
Mais je ne vois pas comment concevoir mes classes pour obtenir une utilisation vraiment simple, et ce avec la possibilité de définir de nouveaux corps facilement.

C'est plus clair ?

[jibbi]

Salut,

je crois que l'erreur est ici:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
public class GFelem<T extends GFp> {
    private int value;
 
    public GFelem(int v) { value=v; }
    public int intValue() { return value; }
    public GFelem<T> add(GFelem<T> a) {
	return new GFelem<T>(T.add(value,a.intValue()));
    }
}

ça devrait pas être a.add()...

[5leipnir]

Et bien non justement, je ne veux pas "a.add".
Je voudrais que mon element utilise l'addition du corps auquel il appartient.
Comme ça, je pourrais creer un GFelement<blabla> sans me preoccuper de comment faire les operations dans blabla.

Mon probleme c'est que j'aimerais vraiment faire la difference entre corps et les elements du corps... (mais peut etre que c'est une mauvaise idee)

[Sanguko]

Tu fais une classe GFp17 derive de GFp, avec un champ static modulo qui vaut 17. Le probleme c'est que ce champ n'est pas le champ utilisé dans add. D'une manière générale, tu ne peux pas spécialiser un champ static dans une classe derivée.

Si tu veux spécialiser un comportement, il faut obligatoirement passer par une methode d'instance, et pas de classe.

Tu peux peut etre t'en sortir en déclarant un champ static algo dans GFElem, du genre

Code :

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

1
2
3
4
5
6
7
 
class GFElem<T extends GFp> {
    static T algo = new T();
    public GFelem<T> add(GFelem<T> a) {
	return new GFelem<T>(algo.add(value,a.intValue()));
    }
}

Mais personnellement, je ne poursuiverais pas dans cette voie. Ca semble un peu surspecifié. Je te conseille de simplifier un peu tout ca, ca sera sans doute plus vite developpé, plus maintenable, et le jour ou tu auras vraiment le besoin, tu auras alors l'experience pour trouver la solution adequate.