Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11

Question POO d'un debutant

2 réponses
Avatar
Ataya
Voila, j'ai une grille (jTable) qui contient une liste de contact qui
s'appelle 'GridLstCtc' et sa classe modele qui s'appelle
'DefaultGridLstCtc'

on a donc:

public class GridLstCtc{
//les variables
private DefaultGridLstCtc _modele;
private String[] noms =3D {"Numero","Date","Type", "Nom"};

//Et le constructeur
public GridLstCtc(){
_modele =3D new DefaultGridLstCtc(noms, 0, this);
_tableau =3D new JTable(_modele);
//Et d'autres instructions qui utilisent _modele et
_tableau
}
//Et des methodes qui utilisent aussi _modele et _tableau
}

Mettons que j'ai plein d'autres grilles de ce type a faire (liste
d'entreprise, liste de personnes, etc...) Je me dit donc en bon
programmeur OO que je veis faire une SuperClasse abstraite puisqu'il
n'y a que _modele et nom qui changent.

Le prb est le suivant: dans ma classe abstraite je ne peut pas preciser
ce qu'est _modele puisqu'il change dans chaque sous classe, donc
finalement je suis oblig=E9 de redefinir completement le constructeur
dans ma sous classe, et le prb est le meme pour les
methodes...Autrement dit ma super classe est vide!!!

Je pense qu'il y a un truc en POO Qui m'a echapp=E9!

Merci de votre aide.

2 réponses

Avatar
vc.spam
Salut,

Si je comprends bien, ta classe GridLstCtc contient le modèle et les
titres des colonnes de la liste. Et ta liste de titre est passée en
constructeur du modèle. Donc il y a duplication dans la classe, là,
pour moi, c'est de trop. AMHA, soit tu les sors du modèle, soit tu ne
les stocks que là...

Tu voudrais faire qq chose de générique pour ce qui s'affichera en
JTable, c'est une bonne idée. Mais t'es pas le premier sur l'affaire:
c'est ce que les créateur de Java ont voulu faire avec le TableModel.

Après, tu peux éventuellement prévoir des classes utilitaire autour
pour, par exemple, gèrer les liste de chose qui se remplissent à la
ligne et pas à la case. Donc, avec un setValueAt(int row, Object o).

Une petite question, ton modèle n'est-il pas une implémentation de
TableModel? Si ça n'est pas le cas, pourquoi? Et si c'est le cas, tu
peux t'appuyer la dessus pour tes méthodes non?

Là comme ça c'est un peu difficile de t'aider vu qu'on ne sait pas
trop ce que font les classes...

A+

Vincent





Voila, j'ai une grille (jTable) qui contient une liste de contact qui
s'appelle 'GridLstCtc' et sa classe modele qui s'appelle
'DefaultGridLstCtc'

on a donc:

public class GridLstCtc{
//les variables
private DefaultGridLstCtc _modele;
private String[] noms = {"Numero","Date","Type", "Nom"};

//Et le constructeur
public GridLstCtc(){
_modele = new DefaultGridLstCtc(noms, 0, this);
_tableau = new JTable(_modele);
//Et d'autres instructions qui utilisent _modele et
_tableau
}
//Et des methodes qui utilisent aussi _modele et _tableau
}

Mettons que j'ai plein d'autres grilles de ce type a faire (liste
d'entreprise, liste de personnes, etc...) Je me dit donc en bon
programmeur OO que je veis faire une SuperClasse abstraite puisqu'il
n'y a que _modele et nom qui changent.

Le prb est le suivant: dans ma classe abstraite je ne peut pas preciser
ce qu'est _modele puisqu'il change dans chaque sous classe, donc
finalement je suis obligé de redefinir completement le constructeur
dans ma sous classe, et le prb est le meme pour les
methodes...Autrement dit ma super classe est vide!!!

Je pense qu'il y a un truc en POO Qui m'a echappé!

Merci de votre aide.


Avatar
Ataya
Bon je vais essayer d'etre plus clair en fait j'ai trois classes:
_DefaultGridLstCtc (le modele : de type
DefaultTableModel)
_AbstractAtayGrid(Ma super classe: de type Jtable)
_GridLstCtc (ma sous classe donc de type
AbstractAtyGrid)

Donc GridLstCtc ne "Contient" pas le modele, mais elle y fait
reference, car c'est le modele qui gere les données.
Pour plus de clarté je vais mettre les sources:

public class DefaultGridLstCtc extends DefaultTableModel implements
Comparator{
/**
* VARIABLES
///////////////////////////////////////////////////////////
*/

private int _colATrier;//le numéro de la colonne à trier



/**
* CONSTRUCTEUR
///////////////////////////////////////////////////////////
*/
public DefaultGridLstCtc(Object[] entetes){
super(entetes, 0);
setColumnCount(entetes.length);//affecte le nombre de colonnes

}

/**
* METHODES ///////////////////////////////////////////////////////////
*/
// surcharge de la methode pour tjs false
public boolean isCellEditable(int row, int column)
{
return (false);
}

// ajoute une ligne de données pour frmstart
public void ajouteLigne(String numero, String date , String type,
String nom)
{
Vector v = new Vector();
v.add(numero);
v.add(date);
v.add(type);
v.add(nom);

addRow(v);
}

// supprime la ligne "ligne" du modèle
public void supprimeLigne(int ligne)
{
removeRow(ligne);
}

//Vidage
public void vidage(){
Object aTrier[] = getDataVector().toArray();
//on vide toutes les lignes du modèle
for (int i = aTrier.length-1; i>=0; i--) removeRow(i);
}

// lance le tri des données en fonction de la colonne "col"
public void trieParColonne(int col)
{
//ce système de vider les lignes puis les rajouter dans
l'ordre permet de ne pas
// perdre le renderer. Si on ne le fait pas, les en-têtes
sont réinitialisées :
// on perd le renderer. DU coup, on n'a pas de retour visuel
lros d'une lcic et
//la police d'affichage des noms de colonnes n'est plus la
même


//on récupère les données du modèle pour les trier
Object aTrier[] = getDataVector().toArray();
//on vide toutes les lignes du modèle
for (int i = aTrier.length-1; i>=0; i--) removeRow(i);
_colATrier = col;
Arrays.sort(aTrier, this);
//on rajoute les lignes dans l'ordre
for (int i=0; i<aTrier.length;i++) { addRow((Vector)aTrier[i]);}
}

// Retourne le tableau
//public GridLstPers getTableau(){return _tableau;}

// Retourne la colonne a trier
public int getColATrier(){return _colATrier;}

// Retourne le nom des colonnes
public Vector getNomsColonnes()
{
Vector noms = new Vector();
for (int i =0; i<getColumnCount(); i++)
noms.add(getColumnName(i));
return noms;
}

// on implémente les méthodes de l'interface COmparator
//retourne -1 si o1 < o2
// retourne 0 si o1 = o2
// retourne 1 si o1 > o2
public int compare(Object o1, Object o2)
{
if (_colATrier==-1)return 0;
Vector v1 = (Vector)o1;
Vector v2 = (Vector)o2;

String s1 = (String)(v1.elementAt(getColATrier()));
String s2 = (String)(v2.elementAt(getColATrier()));

return s1.compareTo(s2);
}

//regarde si o est égal à ce comparateur this
public boolean equals(Object o)
{
if (! (o instanceof DefaultGridLstPers)) return false;
return (getColATrier()==((DefaultGridLstPers)o).getColATrier());
}
}




public abstract class AbstractAtayGrid extends JScrollPane{
/**
* VARIABLES ///////////////////////////////////////////////////////////
*/
protected JTable _tableau;
protected String mySql;
protected TableColumnModel _modeleEntete;
protected AtayConnection MyCon = new AtayConnection();
protected JTableHeader _entete;
protected ButtonHeaderRenderer renderer;

/**
* CONSTRUCTEUR
///////////////////////////////////////////////////////////
*/
public AbstractAtayGrid(){
// on crée un "afficheur" de type bouton pour les en-têtes de
colonnes ...
renderer = new ButtonHeaderRenderer();
}

/**
* METHODES ///////////////////////////////////////////////////////////
*/
protected JTable getTable(){return _tableau;}



public class GridLstCtc extends AbstractAtayGrid{
/**
* VARIABLES ///////////////////////////////////////////////////////////
*/
private DefaultGridLstCtc _modele;
private String[] noms = {"Numero","Date","Type", "Nom"};
private String mySql="SELECT * FROM rqy_lstCtc WHERE 1=1 ";

/**
* CONSTRUCTEUR
///////////////////////////////////////////////////////////
*/
public GridLstCtc(){
// on crée le modèle et on le passe en paramètres au
constructeur de la JTable
_modele = new DefaultGridLstCtc(noms, 0, this);
_tableau = new JTable(_modele);


// ...on récupère le modèle des colonnes pour parcourir les
en-têtes de colonnes afin de leur ajouter l'afficheur.
_modeleEntete = _tableau.getColumnModel();
for (int i=0;i<noms.length;i++) {
_modeleEntete.getColumn(i).setHeaderRenderer(renderer);
}

// on récupère le JTableHeader et on lui ajoute un écouteur
de souri pour
//pouvoir lancer le tri
_entete = _tableau.getTableHeader();
_entete.addMouseListener(new EnteteEcouteur(_entete,renderer,
this));

// Selection impossible
_tableau.setCellSelectionEnabled(false);

//on ajoute à la JTable un écouteur de souri pour lancer
l'appel de la ligne cliquée
_tableau.addMouseListener(new MouseListener(){
public void mouseClicked(MouseEvent e)
{
System.out.println("Nombre de clics souri : " +
e.getClickCount());
if (e.getClickCount()==2&& e.getID() ==
MouseEvent.MOUSE_RELEASED)
{
int ligne = _tableau.getSelectedRow();
String s = (String)_tableau.getValueAt(ligne,
0);
System.out.println("MouseEvent. id sel : " + s);
//_pere.ajouterDansCombo(s);
//_pere.appelerNumero(s);
}
}
public void mouseEntered(MouseEvent e) {}
public void mouseExited(MouseEvent e) {}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}
});


// on "affecte" la JTable à la "vue" du JPanel
setViewportView(_tableau);
_tableau.setShowGrid(true);
_tableau.setGridColor(Color.blue);



// on remplis la grille
remplissage();
}



/**
* METHODES ///////////////////////////////////////////////////////////
*/
// demande au modèle de trier les données en fonction de la colonne
"col"
public void trieParColonne(int col)
{
_modele.trieParColonne(col);
repaint();
}

// demande au modèle d'ajouter une ligne aux données
protected void ajouteLigne(String numero, String date, String type,
String nom)
{
_modele.ajouteLigne(numero, date, type, nom);
repaint();
}

// remplissage de la grille avec le rs
public void remplissage(){

//On vide avant de remplir
_modele.vidage();

MyCon.open(); //Ouverture
ResultSet MyRes = MyCon.GetRs(mySql); //executuion du rs

try{
MyRes.first(); //Mise au depart du curseur
//Boucle de remplissage
while(MyRes.isAfterLast()=lse){
ajouteLigne(MyRes.getString(1),MyRes.getString(2),
MyRes.getString(3), MyRes.getString(4));


MyRes.next();
}
}catch(SQLException sqle){
System.err.println("erreur d'execution : "+sqle);
}

MyCon.close(); //fermeture
}


/**
* CLASSES ///////////////////////////////////////////////////////////
*/



// écoute les évènements réalisés sur les en-têtes de colonn es
et lance le tri
// par la colonne cliquée
class EnteteEcouteur extends MouseAdapter
{
JTableHeader header;
ButtonHeaderRenderer renderer;
GridLstCtc tab;

EnteteEcouteur(JTableHeader header,ButtonHeaderRenderer renderer,
GridLstCtc t)
{
this.header = header;
this.renderer = renderer;
this.tab = t;
}

public void mousePressed(MouseEvent e) {
int col = header.columnAtPoint(e.getPoint());
renderer.setPressedColumn(col);
header.repaint();
}

public void mouseReleased(MouseEvent e) {
int col = header.columnAtPoint(e.getPoint());
renderer.setPressedColumn(-1);
//on lance le tri sur la colonne
tab.trieParColonne(col);
header.repaint();
}
}
}