IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage Java Discussion :

conception classes Matrice


Sujet :

Langage Java

  1. #1
    Membre habitué
    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2008
    Messages
    379
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 38
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2008
    Messages : 379
    Points : 129
    Points
    129
    Par défaut conception classes Matrice
    Bonjour,

    pour un projet j'ai développé une classe Matrice qui représente les pixels d'une image. Donc les attributs de ma classe étaient :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    public class Matrice
    {
    	private int [][] mtx;
    	private int nbLigne;
    	private int nbCol;
     
    [...]
    }
    et elle ne peut contenir que des entiers compris entre 0 et 255 (image en niveau de gris).

    Par la suite, un imprévu nous a donné le besoin d'avoir en plus des matrices de double.

    Du coup, j'ai transformé la classe Matrice en MatriceInt, et j'ai créé une classe MatriceDouble contenant les méthodes dont on avait besoin.
    Mais certaines méthodes étaient identique ou quasi-identique, je me suis donc dit que créer une classe abstraite Matrice ne serait pas un mal.
    Voici la classe Matrice en question :
    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
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    /**
     * Projet : LAM
     * Paquetage : fr.statlife.LAM
     * Fichier : Matrice.java
     *
     * @author Mathilde Pellerin
     * @date 6 juil. 2010
     */
    package fr.statlife.LAM;
     
    /**
     * 
     * @author Mathilde Pellerin
     */
    public abstract class Matrice
    {
    	protected int nbLigne;
    	protected int nbCol;
     
    	public Matrice(int nbLigne, int nbCol)
    	{
    		this.nbLigne = nbLigne;
    		this.nbCol = nbCol;
    	}
     
    	/**
             * equals : indique si un autre objet TabInt est egal a celui-la
             * @param obj : Objet avec lequel on fait la comparaison
             * @return true si l'objet est le meme que celui passe en argument
             */
    	public boolean equals(Object obj)
    	{
    		boolean egal = true;
     
    		//Les objets ne sont pas egaux si :
    		// -> les deux classes ne sont pas du meme type
    		if(this.getClass().getName() != obj.getClass().getName())
    			egal = false;
    		// -> les deux matrices ne sont pas de meme dimensions
    		else if((this.getNbCol() != ((Matrice) obj).getNbCol()) || (this.getNbLigne() != ((Matrice) obj).getNbLigne()))
    			egal = false;
     
    		return egal;
    	}
     
    	/////////////////////
    	// ACCESSEURS //
    	////////////////////
    	/**
             * getNbLigne : recupere le nombre de lignes de la matrice
             * @return nbLigne
             */
    	public int getNbLigne()	{return nbLigne;}
     
    	/**
             * getNbCol : recupere le nombre de colonnes de la matrice
             * @return nbCol
             */
    	public int getNbCol(){return nbCol;}
    }
    Mon problème, c'est que certaines méthodes sont identiques dans les classes MatriceInt et MatriceDouble, mais font appel à l'attribut mtx qui est un int[][] dans une classe et un double[][] dans l'autre. Du coup, je ne peux pas mettre cet attribut dans la classe abstraite...

    J'ai bien conscience que mon problème porte sur la conception, mais je n'arrive pas à savoir quelle est la solution la plus propre ?
    • tenter d'utiliser la généricité?
    • laisser ces classes dans leur état actuel malgré la duplicité du code de certaines méthodes?
    • Trouver un moyen pour ne faire qu'une seule classe matrice qui réponde à toutes les contraintes (matrice d'int compris entre 0 et 255 dans un cas et matrice de double dans l'autre)?


    Bref, j'ai besoin de conseils avisés pour partir dans la bonne direction et avoir quelque chose de propre et bien conçu au final...
    Merci d'avance pour toute l'aide que vous pourrez m'apporter

  2. #2
    Modérateur
    Avatar de Alkhan
    Homme Profil pro
    ingénieur full stack
    Inscrit en
    Octobre 2006
    Messages
    1 232
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur full stack

    Informations forums :
    Inscription : Octobre 2006
    Messages : 1 232
    Points : 2 061
    Points
    2 061
    Par défaut
    bonjour,

    pour le code que tu nous montre en effet il est possible d'utiliser les generics :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
     
    public class Matrice<T>
    {
    	private T [][] mtx;
    	private int nbLigne;
    	private int nbCol;
     
    [...]
    }
    Il n'y a pas de problème, il n'y a que des solutions.
    Cependant, comme le disaient les shadoks, s'il n'y a pas de solution, c'est qu'il n'y a pas de problème.
    Si toutefois le problème persiste, la seule solution restante est de changer le périphérique qui se trouve entre la chaise et l'écran

    Mes Articles : Mon premier article est sur le language D
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  3. #3
    Membre habitué
    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2008
    Messages
    379
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 38
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2008
    Messages : 379
    Points : 129
    Points
    129
    Par défaut
    merci de ta réponse.
    Mais ça reste un peu flou : suggères-tu d'utiliser un générique dans la classe Abstraite Matrice et de spécifier le type T dans les classes MatriceInt et MatriceDouble?

    Ou alors de ne faire qu'une seule classe Matrice générique?
    Dans ce deuxième cas, comment gérer le fait que certaines méthodes sont spécifiques aux matrices d'entiers et que d'autre sont spécifiques aux matrices de double?

  4. #4
    Modérateur
    Avatar de Alkhan
    Homme Profil pro
    ingénieur full stack
    Inscrit en
    Octobre 2006
    Messages
    1 232
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur full stack

    Informations forums :
    Inscription : Octobre 2006
    Messages : 1 232
    Points : 2 061
    Points
    2 061
    Par défaut
    lorsque tu dis que certaines méthodes sont spécifiques au traitement de matriceInt ou MatriceDouble, tu veux dire que le traitement est différent ou qu'il y a des méthodes qui existe dans l'une et pas dans l'autre ?
    Cette différence n'est pas uniquement lié au fait que ta matrice est de type double ou int ?

    Peux tu donner des exemples de ces différences ?
    Il n'y a pas de problème, il n'y a que des solutions.
    Cependant, comme le disaient les shadoks, s'il n'y a pas de solution, c'est qu'il n'y a pas de problème.
    Si toutefois le problème persiste, la seule solution restante est de changer le périphérique qui se trouve entre la chaise et l'écran

    Mes Articles : Mon premier article est sur le language D
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  5. #5
    Membre habitué
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    173
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 173
    Points : 151
    Points
    151
    Par défaut
    Bonjour,

    Moi je ferai comme suit:

    Tu déclare une classe abstraite Generique : Matrice<T>. qui contient les traitements commun et/ou les traitement où seul la différence consiste dans le faite que ce soit des double ou des int.

    Et puis tu créera les classe fille MatriceInt et MatriceDouble qui contiendront les traitements spécifiques.

    Le traitement est differents peuvent etre dans methodes ayant la meme signature mais un traitement différent, je te suggère de les déclarer comme méthodes abstraites dans la classe mère.

    J'espère que cela te servira

  6. #6
    Membre habitué
    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2008
    Messages
    379
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 38
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2008
    Messages : 379
    Points : 129
    Points
    129
    Par défaut
    Citation Envoyé par Alkhan Voir le message
    lorsque tu dis que certaines méthodes sont spécifiques au traitement de matriceInt ou MatriceDouble, tu veux dire que le traitement est différent ou qu'il y a des méthodes qui existe dans l'une et pas dans l'autre ?
    les deux mon capitaine !

    Citation Envoyé par Alkhan Voir le message
    Cette différence n'est pas uniquement lié au fait que ta matrice est de type double ou int ?

    Peux tu donner des exemples de ces différences ?
    voici un exemple de méthodes qu'il y a dans les deux mais dont le traitement est différent :
    dans MatriceInt :
    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
    /**
             * setPixel : modifie un pixel de la matrice (case du tableau 2D)
             * @param indiceLigne : indice de la ligne
             * @param indiceCol : indice de la colonne
             * @param valeur : valeur du pixel
             */
    	public void setElement(int indiceLigne, int indiceCol, int valeur) throws IndexOutOfBoundsException, IllegalArgumentException
    	{
    		if(indiceLigne < 0 || indiceLigne >= this.getNbLigne() || indiceCol < 0 || indiceCol >= this.getNbCol())
    			throw new IndexOutOfBoundsException("setPixel : indice ["+indiceLigne+","+indiceCol
    					+"] en dehors des limites de la matrice : ["+this.getNbLigne()+","+this.getNbCol()+"]");
    		else if(valeur < 0 || valeur > 255)
    			throw new IllegalArgumentException("setPixel : valeur = " + valeur +
    					"\nun pixel doit avoir une valeur comprise entre 0 et 255");
     
    		this.mtx[indiceLigne][indiceCol] = valeur;
    	}
    et la même méthode dans MatriceDouble:
    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
     
    	/**
             * setCoeff : modifie un coefficient de la matrice (case du tableau 2D)
             * @param indiceLigne : indice de la ligne
             * @param indiceCol : indice de la colonne
             * @param valeur : valeur du coefficient
             * @exception IndexOutOfBoundsException
             */
    	public void setElement(int indiceLigne, int indiceCol, double valeur) throws IndexOutOfBoundsException
    	{
    		if(indiceLigne < 0 || indiceLigne >= this.getNbLigne() || indiceCol < 0 || indiceCol >= this.getNbCol())
    			throw new IndexOutOfBoundsException("MatriceInt.setCoeff : indice ["+indiceLigne+","+indiceCol
    					+"] en dehors des limites de la matrice : ["+this.getNbLigne()+","+this.getNbCol()+"]");
     
    		this.mtx[indiceLigne][indiceCol] = valeur;
    	}
    et après, y'a des méthodes qu'il y a seulement dans MatriceInt et d'autre qu'il y a seulement dans MatriceDouble...


    Citation Envoyé par amine_en_france Voir le message
    Bonjour,

    Moi je ferai comme suit:

    Tu déclare une classe abstraite Generique : Matrice<T>. qui contient les traitements commun et/ou les traitement où seul la différence consiste dans le faite que ce soit des double ou des int.

    Et puis tu créera les classe fille MatriceInt et MatriceDouble qui contiendront les traitements spécifiques.
    d'accord, je vais tester ça...
    Mais du coup, ça va pas mal changer le code des appels aux matrices non?

    Citation Envoyé par amine_en_france Voir le message
    Le traitement est differents peuvent etre dans methodes ayant la meme signature mais un traitement différent, je te suggère de les déclarer comme méthodes abstraites dans la classe mère.

    J'espère que cela te servira
    pas sur d'avoir compris ce que tu disais là...

  7. #7
    Modérateur
    Avatar de Alkhan
    Homme Profil pro
    ingénieur full stack
    Inscrit en
    Octobre 2006
    Messages
    1 232
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur full stack

    Informations forums :
    Inscription : Octobre 2006
    Messages : 1 232
    Points : 2 061
    Points
    2 061
    Par défaut
    Dans ton cas il est en effet impossible d'utiliser une classe unique du fait que tu as des spécificité dans chaque matrice.

    Petite précision toutefois, si tu souhaites utiliser les generics, tu ne peux pas le faire avec des type simple.
    Ca donnera quelque chose du genre :

    Pour Matrice:

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    public abstract class Matrice<T>
    {
    	protected T [][] mtx;
    	protected int nbLigne;
    	protected int nbCol;
     
            public abstract void setElement(int indiceLigne, int indiceCol, T valeur) throws IndexOutOfBoundsException, IllegalArgumentException;
     
     
    }
    Pour MatriceInt :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
     
    public class MatriceInt extends Matrice<Integer> {
     
    	@Override
    	public void setElement(int indiceLigne, int indiceCol, Integer valeur) throws IndexOutOfBoundsException, IllegalArgumentException {
    		// ton code
     
    	}
     
            // autres méthodes spécifiques a MatriceInt
    }
    Il n'y a pas de problème, il n'y a que des solutions.
    Cependant, comme le disaient les shadoks, s'il n'y a pas de solution, c'est qu'il n'y a pas de problème.
    Si toutefois le problème persiste, la seule solution restante est de changer le périphérique qui se trouve entre la chaise et l'écran

    Mes Articles : Mon premier article est sur le language D
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  8. #8
    Membre habitué
    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2008
    Messages
    379
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 38
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2008
    Messages : 379
    Points : 129
    Points
    129
    Par défaut
    merci beaucoup, avec tout ça je vais pouvoir m'en sortir et surtout faire quelque chose de propre

    juste une dernière petite question : vu qu'il faut utiliser des objets Integer et Double plutôt que les types primitifs, pour la méthode getElement qui jusqu'à présent était comme ça :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    /**
             * getPixel : recupere un pixel de la matrice (case du tableau 2D)
             * @param indiceLigne : indice de la ligne
             * @param indiceCol : indice de la colonne
             * @return entier correspondant au pixel voulu
             */
    	public int getElement(int indiceLigne, int indiceCol) throws IndexOutOfBoundsException
    	{
    		if(indiceLigne < 0 || indiceLigne >= this.getNbLigne() || indiceCol < 0 || indiceCol >= this.getNbCol())
    			throw new IndexOutOfBoundsException("getElement : indice(s) en dehors des limites de la matrice");
     
    		return this.mtx[indiceLigne][indiceCol];
    	}
    le code étant le même pour MatriceInt et MatriceDouble, je peux le mettre directement dans Matrice a priori.
    Oui, mais ça m'obligerais à faire un cast de Integer vers int (ou de Double vers double) à chaque fois que je l'utiliserais dans mes autres classes, non? à moins que les types primitifs et les objets correspondant soient directement compatibles (ça m'étonnerait mais bon...)?
    ou alors je dois changer mon code de partout en modifiant les int en Integer?...

  9. #9
    Modérateur
    Avatar de Alkhan
    Homme Profil pro
    ingénieur full stack
    Inscrit en
    Octobre 2006
    Messages
    1 232
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Haute Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : ingénieur full stack

    Informations forums :
    Inscription : Octobre 2006
    Messages : 1 232
    Points : 2 061
    Points
    2 061
    Par défaut
    en effet si la méthode getElement est identique tu dois la mettre dans Matrice.
    cependant attention au type de retour qui doit être T.

    Citation Envoyé par zaboug Voir le message
    ou alors je dois changer mon code de partout en modifiant les int en Integer?...
    La réponse est non, car depuis la 1.5 il existe ce que l'on appel l'autoboxing qui transforme automatiquement ton type complexe en type simple et inversement.

    par exemple tu peux appeler ta méthode setElement comme suit :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
     
    maMatriceint.setElement(0, 1, 15);
    Il n'y a pas de problème, il n'y a que des solutions.
    Cependant, comme le disaient les shadoks, s'il n'y a pas de solution, c'est qu'il n'y a pas de problème.
    Si toutefois le problème persiste, la seule solution restante est de changer le périphérique qui se trouve entre la chaise et l'écran

    Mes Articles : Mon premier article est sur le language D
    N'oubliez pas de consulter les FAQ Java et les cours et tutoriels Java

  10. #10
    Membre habitué
    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2008
    Messages
    379
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 38
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2008
    Messages : 379
    Points : 129
    Points
    129
    Par défaut
    ça c'est une super nouvelle !
    car j'avoue que ça m'enchantait pas des masse de repasser partout pour modifier les types

    Du coup un grand merci à vous deux pour tous ces bons conseils

  11. #11
    Membre habitué
    Profil pro
    Inscrit en
    Janvier 2007
    Messages
    173
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Janvier 2007
    Messages : 173
    Points : 151
    Points
    151
    Par défaut
    J'ai trouvé ton exercice interessant et j'ai essayé de le faire .

    La classe mère Matrice.java

    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
    31
    32
    33
    34
    35
    36
    37
     
    package Tests;
     
    public abstract class Matrice<T> {
     
    	T[][] mxy;
     
    	int L;
     
    	int l;
     
    	public Matrice(int L, int l, T val) {
    		this.l = l;
     
    		this.L = L;
     
    	}
     
    	public void initVal(T val) {
     
    		for (int x = 0; x < L; x++) {
    			for (int y = 0; y < l; y++) {
    				mxy[x][y] = val;
    			}
    		}
     
    	}
     
    	public void afficherMatrice() {
    		for (int i = 0; i < L; i++) {
    			for (int j = 0; j < l; j++) {
    				System.out.println(mxy[i][j]);
    			}
    		}
    	}
     
    	abstract T trace();
    Elle contient un constructeur, une méthode d'affichage qui sera utilisé par les filles et une méthode abstraite redéfinie par chacune des classes filles

    MatriceInt.java

    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
     
    package Tests;
     
    public class MatriceInt extends Matrice<Integer>{
     
     
     
    	public MatriceInt(int L, int l, Integer val) {
    		super(L, l, val);
    		mxy = new Integer[L][l];
    		initVal(val);
    	}
     
     
     
    	@Override
    	public Integer trace() {
    		int trace = 0;
    		if (l != L) {
    			System.out
    					.println("Impossible de calculer la trace pour une matrice non carré");
    		}
    		for (int i = 0; i < l; i++) {
    			trace += mxy[i][i];
    		}
    		return trace;
    	}
     
    }
    MatriceDouble.java
    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
     
    package Tests;
     
    public class MatriceDouble extends Matrice<Double> {
     
     
     
    	public MatriceDouble(int L, int l, Double val) {
    		super(L, l, val);
    		mxy = new Double[L][l];
    		initVal(val);
    	}
     
    	@Override
    	public Double trace() {
    		double trace = 0;
    		if (l != L) {
    			System.out
    					.println("Impossible de calculer la trace pour une matrice non carré");
    		}
    		for (int i = 0; i < l; i++) {
    			trace += mxy[i][i];
    		}
    		return trace;
    	}
     
    }
    Remarque que chacune des classe surcharge le constructeur à son gout.

    Et enfin la class main.java

    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
     
     
    public class Main {
     
    	public static void main(String[] args) throws InterruptedException {
     
     
    		MatriceDouble matriceDouble = new MatriceDouble(5, 5, new Double(350));
     
    		//Methode definie dans la class mère
    		matriceDouble.afficherMatrice();
     
    		//methode definie dans la classe fille
    		System.out.println("trace : " + matriceDouble.trace());
     
    	}
     
    }
    J'espère que ca rapportera plus de lumière en cas de besoin

  12. #12
    Nouveau membre du Club
    Inscrit en
    Juillet 2010
    Messages
    19
    Détails du profil
    Informations forums :
    Inscription : Juillet 2010
    Messages : 19
    Points : 29
    Points
    29
    Par défaut
    Mais pourquoi utiliser la généricité ?
    Pour encapsuler un scalaire il y a la classe java.lang.Number de laquelle hérite Integer Double BigDecimal et consors.
    Dans ce cas on déclare la matrice de Number dans la classe mère et on l'instancie dans la classe fille avec new Integer[][] ou new Double[][] et on récupère les valeurs avec Number.intValue() ou Number.doubleValue().

  13. #13
    Membre habitué
    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2008
    Messages
    379
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 38
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2008
    Messages : 379
    Points : 129
    Points
    129
    Par défaut
    Citation Envoyé par lnotray Voir le message
    Mais pourquoi utiliser la généricité ?
    Pour encapsuler un scalaire il y a la classe java.lang.Number de laquelle hérite Integer Double BigDecimal et consors.
    Dans ce cas on déclare la matrice de Number dans la classe mère et on l'instancie dans la classe fille avec new Integer[][] ou new Double[][] et on récupère les valeurs avec Number.intValue() ou Number.doubleValue().
    je ne connaissais pas cette classe Number, cela dit, ta proposition ne répond bien à la problématique car il ne faut pas oublié que l'on a des traitements différents pour les int et les double (voir posts précédents).

    amine_en_france : contente que l'exercice t'ai plu et merci pour ton exemple, il me sera bien utile
    je n'ai pas encore eu le temps de corriger les classes Matrice (une urgence m'est tombé dessus), mais ça ne saurait tarder...

  14. #14
    Membre habitué
    Femme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Juin 2008
    Messages
    379
    Détails du profil
    Informations personnelles :
    Sexe : Femme
    Âge : 38
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : Juin 2008
    Messages : 379
    Points : 129
    Points
    129
    Par défaut
    finalement, retour en arrière, je n'utiliserai pas les génériques car les objets Integer et Double prennent trop de place pour ce que je dois faire...
    plus de détails ici.

+ Répondre à la discussion
Cette discussion est résolue.

Discussions similaires

  1. [Conception] Class interne ou externe ?
    Par TTKiBosse dans le forum Langage
    Réponses: 13
    Dernier message: 10/01/2007, 11h36
  2. [Conception] classes internes ou gestion des events
    Par TTKiBosse dans le forum Général Java
    Réponses: 2
    Dernier message: 06/12/2006, 19h25
  3. [Conception] class au dessus d'une base de donnée
    Par le_chainon_manquant dans le forum PHP & Base de données
    Réponses: 4
    Dernier message: 21/07/2006, 13h14
  4. aide classe matrice
    Par ba10 dans le forum C++
    Réponses: 8
    Dernier message: 17/05/2006, 09h10
  5. [Debutant][Conception] Classes abstraites et interface.
    Par SirDarken dans le forum Langage
    Réponses: 4
    Dernier message: 29/10/2004, 01h02

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo