j'essaye de réaliser une classe abstraite "matrice" qui ne dépends pas d'une
implémentation particulière (je veux pouvoir l'implémenter par un tableau à
2 dimension, par une matrice creuse (tableau) etc...). J'ai pour cela 2
méthodes abstraites :
abstract float get (int i, int j)
abstract void put (int i, int j, float val) pour acceder aux coefficients
Dans cette classe abstraite j'aimerais aussi coder l'opération d'addition
matricielle suivant cette spécification :
(Matrice est ma classe abstraite)
public Matrice addition (Matrice M);
et l'utiliser comme ca :
Destination = Source1.addition(Source2);
Cependant,
dans ma méthode addition, si je veux retourner une nouvelle matrice, je ne
vois pas d'autre solution que de faire un Matrice M = new Matrice, ce qui
déplait fortement au compilo, comme prévu. (classe abstraite qui ne peut
être instanciée).
Quel est l'idée manquante ?
Merci,
Etienne
************ CODE ************
package MatTransform;
abstract class Matrice
{
............
abstract public float get(int ligne, int colonne);
abstract public void put(int ligne, int colonne, float val);
..............
public Matrice addition (Matrice M)
{
Matrice D = new Matrice (M.IntervalleLigne, M.IntervalleColonne); //
impossible......
for (int i = M.IntervalleLigne.valeurMin();
i<=M.IntervalleLigne.valeurMax(); i++)
{
for (int j = M.IntervalleColonne.valeurMin();
j<=M.IntervalleColonne.valeurMax(); j++)
{
D.put(i,j, this.get(i,j)+M.get(i,j));
}
}
return D;
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Emmanuel Puybaret
j'essaye de réaliser une classe abstraite "matrice" qui ne dépends pas d'une implémentation particulière (je veux pouvoir l'implémenter par un tableau à 2 dimension, par une matrice creuse (tableau) etc...). J'ai pour cela 2 méthodes abstraites :
abstract float get (int i, int j) abstract void put (int i, int j, float val) pour acceder aux coefficients
Dans cette classe abstraite j'aimerais aussi coder l'opération d'addition matricielle suivant cette spécification : (Matrice est ma classe abstraite)
public Matrice addition (Matrice M); et l'utiliser comme ca :
Destination = Source1.addition(Source2);
Cependant, dans ma méthode addition, si je veux retourner une nouvelle matrice, je ne vois pas d'autre solution que de faire un Matrice M = new Matrice, ce qui déplait fortement au compilo, comme prévu. (classe abstraite qui ne peut être instanciée).
Quel est l'idée manquante ?
Il y a plein de solutions possibles mais la plus simple est d'instancier un objet de la même classe que this par exemple: Matrice M = (Matrice)this.getClass().newInstance(); Dans ce cas, il faut que la classe de l'objet est un constructeur sans paramètre.
Cordialement -- Emmanuel PUYBARET Email : Web : http://www.eteks.com Auteur du Cahier du programmeur Java [1] / Editions Eyrolles : http://www.eteks.com/services/cahierjava1.html
j'essaye de réaliser une classe abstraite "matrice" qui ne dépends pas d'une
implémentation particulière (je veux pouvoir l'implémenter par un tableau à
2 dimension, par une matrice creuse (tableau) etc...). J'ai pour cela 2
méthodes abstraites :
abstract float get (int i, int j)
abstract void put (int i, int j, float val) pour acceder aux coefficients
Dans cette classe abstraite j'aimerais aussi coder l'opération d'addition
matricielle suivant cette spécification :
(Matrice est ma classe abstraite)
public Matrice addition (Matrice M);
et l'utiliser comme ca :
Destination = Source1.addition(Source2);
Cependant,
dans ma méthode addition, si je veux retourner une nouvelle matrice, je ne
vois pas d'autre solution que de faire un Matrice M = new Matrice, ce qui
déplait fortement au compilo, comme prévu. (classe abstraite qui ne peut
être instanciée).
Quel est l'idée manquante ?
Il y a plein de solutions possibles mais la plus simple est d'instancier un
objet de la même classe que this par exemple:
Matrice M = (Matrice)this.getClass().newInstance();
Dans ce cas, il faut que la classe de l'objet est un constructeur sans
paramètre.
Cordialement
--
Emmanuel PUYBARET
Email : puybaret@eteks.com
Web : http://www.eteks.com
Auteur du Cahier du programmeur Java [1] / Editions Eyrolles :
http://www.eteks.com/services/cahierjava1.html
j'essaye de réaliser une classe abstraite "matrice" qui ne dépends pas d'une implémentation particulière (je veux pouvoir l'implémenter par un tableau à 2 dimension, par une matrice creuse (tableau) etc...). J'ai pour cela 2 méthodes abstraites :
abstract float get (int i, int j) abstract void put (int i, int j, float val) pour acceder aux coefficients
Dans cette classe abstraite j'aimerais aussi coder l'opération d'addition matricielle suivant cette spécification : (Matrice est ma classe abstraite)
public Matrice addition (Matrice M); et l'utiliser comme ca :
Destination = Source1.addition(Source2);
Cependant, dans ma méthode addition, si je veux retourner une nouvelle matrice, je ne vois pas d'autre solution que de faire un Matrice M = new Matrice, ce qui déplait fortement au compilo, comme prévu. (classe abstraite qui ne peut être instanciée).
Quel est l'idée manquante ?
Il y a plein de solutions possibles mais la plus simple est d'instancier un objet de la même classe que this par exemple: Matrice M = (Matrice)this.getClass().newInstance(); Dans ce cas, il faut que la classe de l'objet est un constructeur sans paramètre.
Cordialement -- Emmanuel PUYBARET Email : Web : http://www.eteks.com Auteur du Cahier du programmeur Java [1] / Editions Eyrolles : http://www.eteks.com/services/cahierjava1.html
Etienne Baudin
Il y a plein de solutions possibles mais la plus simple est d'instancier un
objet de la même classe que this par exemple: Matrice M = (Matrice)this.getClass().newInstance(); Dans ce cas, il faut que la classe de l'objet est un constructeur sans paramètre.
Ok, merci. Sinon, par simple curiosité, quelles sont les autres méthodes envisageable ?
Etienne
Il y a plein de solutions possibles mais la plus simple est d'instancier
un
objet de la même classe que this par exemple:
Matrice M = (Matrice)this.getClass().newInstance();
Dans ce cas, il faut que la classe de l'objet est un constructeur sans
paramètre.
Ok, merci. Sinon, par simple curiosité, quelles sont les autres méthodes
envisageable ?
Il y a plein de solutions possibles mais la plus simple est d'instancier un
objet de la même classe que this par exemple: Matrice M = (Matrice)this.getClass().newInstance(); Dans ce cas, il faut que la classe de l'objet est un constructeur sans paramètre.
Ok, merci. Sinon, par simple curiosité, quelles sont les autres méthodes envisageable ?
Etienne
Vincent Brabant
Il y a plein de solutions possibles mais la plus simple est d'instancier un objet de la même classe que this par exemple: Matrice M = (Matrice)this.getClass().newInstance(); Dans ce cas, il faut que la classe de l'objet est un constructeur sans paramètre.
Ok, merci. Sinon, par simple curiosité, quelles sont les autres méthodes envisageable ?
Etienne
Créer une autre méthode abstraite,
par exemple abstract Matrice createNewMatrice() Et donc chaque implémentation de Matrice devrait l'implémenter correctement. Et pourrait utiliser ses attributs internes pour créer correctement la matrice de résultat, si besoin est. Et tu aurais donc dans addition, quelque chose du genre Matrice m = createNewMatrice(); au lieu de Matrice m = new Matrice();
Évidemment, il faut alors que chaque classe dérivée de Matrice implémente cette méthode.
Vincent
Il y a plein de solutions possibles mais la plus simple est d'instancier
un objet de la même classe que this par exemple:
Matrice M = (Matrice)this.getClass().newInstance();
Dans ce cas, il faut que la classe de l'objet est un constructeur sans
paramètre.
Ok, merci. Sinon, par simple curiosité, quelles sont les autres méthodes
envisageable ?
Etienne
Créer une autre méthode abstraite,
par exemple abstract Matrice createNewMatrice()
Et donc chaque implémentation de Matrice devrait l'implémenter
correctement. Et pourrait utiliser ses attributs internes pour créer
correctement la matrice de résultat, si besoin est.
Et tu aurais donc dans addition, quelque chose du genre
Matrice m = createNewMatrice();
au lieu de Matrice m = new Matrice();
Évidemment, il faut alors que chaque classe dérivée de Matrice
implémente cette méthode.
Il y a plein de solutions possibles mais la plus simple est d'instancier un objet de la même classe que this par exemple: Matrice M = (Matrice)this.getClass().newInstance(); Dans ce cas, il faut que la classe de l'objet est un constructeur sans paramètre.
Ok, merci. Sinon, par simple curiosité, quelles sont les autres méthodes envisageable ?
Etienne
Créer une autre méthode abstraite,
par exemple abstract Matrice createNewMatrice() Et donc chaque implémentation de Matrice devrait l'implémenter correctement. Et pourrait utiliser ses attributs internes pour créer correctement la matrice de résultat, si besoin est. Et tu aurais donc dans addition, quelque chose du genre Matrice m = createNewMatrice(); au lieu de Matrice m = new Matrice();
Évidemment, il faut alors que chaque classe dérivée de Matrice implémente cette méthode.
Vincent
Nicolas Repiquet
"Emmanuel Puybaret" a écrit dans le message news: BBC0068F.C5DA%
Il y a plein de solutions possibles mais la plus simple est d'instancier un
objet de la même classe que this par exemple: Matrice M = (Matrice)this.getClass().newInstance(); Dans ce cas, il faut que la classe de l'objet est un constructeur sans paramètre.
Je suis pas d'accord.
Utiliser la réflection pour résoudre un problème de design c'est moche. Comme le dit Vincent Brabant, il suffit de mettre dans la classe abstraite Matrice une méthode abstraite renvoyant une nouvelle instance de l'implementation visée : c'est plus rapide, c'est plus propre, les éventuelles erreurs sont detectées à la compilation, et on peut passer des paramêtres =)
My 2 Cents.
-- Nicolas Repiquet
"Emmanuel Puybaret" <puybaret@eteks.com> a écrit dans le message news:
BBC0068F.C5DA%puybaret@eteks.com...
Il y a plein de solutions possibles mais la plus simple est d'instancier
un
objet de la même classe que this par exemple:
Matrice M = (Matrice)this.getClass().newInstance();
Dans ce cas, il faut que la classe de l'objet est un constructeur sans
paramètre.
Je suis pas d'accord.
Utiliser la réflection pour résoudre un problème de design c'est moche.
Comme le dit Vincent Brabant, il suffit de mettre dans la classe abstraite
Matrice une méthode abstraite renvoyant une nouvelle instance de
l'implementation visée : c'est plus rapide, c'est plus propre, les
éventuelles erreurs sont detectées à la compilation, et on peut passer des
paramêtres =)
"Emmanuel Puybaret" a écrit dans le message news: BBC0068F.C5DA%
Il y a plein de solutions possibles mais la plus simple est d'instancier un
objet de la même classe que this par exemple: Matrice M = (Matrice)this.getClass().newInstance(); Dans ce cas, il faut que la classe de l'objet est un constructeur sans paramètre.
Je suis pas d'accord.
Utiliser la réflection pour résoudre un problème de design c'est moche. Comme le dit Vincent Brabant, il suffit de mettre dans la classe abstraite Matrice une méthode abstraite renvoyant une nouvelle instance de l'implementation visée : c'est plus rapide, c'est plus propre, les éventuelles erreurs sont detectées à la compilation, et on peut passer des paramêtres =)
