Discussion :

[CoderInTheDark]

Bonjour,

Je souhaite définir une classe abstraite qui dérive de JComboBox, et laisser le type de données en generic.
Car je souhaite définir une méthode utilitaire pour ajouter la possibilité d'insérer un item all/tout.
Ce code est dupliqué dans toutes mes listes je souhaite le factoriser dans toutes mes implémentations

Je dois donc instancier un objet, qi sera définis dans la classe enfant.
Je voudrais savoir si il y a une syntaxe pour appeler un constructeur généric ?
Ou dois-je choisir une autre voie ?

Je suis en Java11

Voici une idée de l'implémentation

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
public abstract class BComboBox<T> extends JComboBox {
	protected boolean allOption;
 
 
	public void addAllOption(boolean all) {
//ou à la place du booléen on recherche si il y a un objet "all" dans la liste
		if(!allOption) {
//ici je voudrais instancier un type generic T
			insertItemAt(new <T>.("ALL", "Tout"), 0);
	}
}
 
public void removeAllOption() {
//ou à la place du booléen on recherche si il y a un objet "all" dans la liste
	if(allOption ) {
removeItemAt(0);
	}
}
 
private boolean isAllOptionActived( {
....
}
}
 
public abstract class BComboBox<T> extends JComboBox {
	protected boolean allOption;
 
 
	public void addAllOption(boolean all) {
		if(!allOption) {
			insertItemAt(new <T>.("ALL", "Tout"), 0);
	}
}
 
public void removeAllOption() {
	if(allOption ) {
removeItemAt(0);
	}
}
}

Cordialement

[thelvin]

Hello,

non ça n'existe pas, mais tu peux remplacer par la nécessité de fournir une fabrique de ton objet générique. Et donc chaque fois que tu veux créer un nouvel objet tu demandes à cette fabrique de t'en faire un :

Ça ressemblerait à ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public abstract class BComboBox<T> extends JComboBox {
    private BiFunction<String, String, T> factory;
 
    public BComboBox(BiFunction<String, String, T> factory) {
        this.factory = factory;
    }
 
    public void addAllOption(boolean all) {
        if (!allOption) {
            insertItemAt(factory.apply("ALL", "Tout"),0);
        }
    }
}

Ensuite mettons que comme <T> tu veuilles utiliser un type comme celui-ci :

Code :

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

record StringPair(String first, String second) { }

Pour en construire une instance avec "ALL" et "Tout" on se contente donc de faire new StringPair("ALL", "Tout") .

Du coup la sous-classe ressemblerait à :

Code :

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

1
2
3
4
5
public class BComboBoxExample extends BComboBox<StringPair> {
    public BComboBoxExample() {
        super((s1, s2) -> new StringPair(s1, s2));
    }
}

[seroze]

Je n'ai pas réussi à instancier le générique. Je comptais sur Class.forName() mais il faut le nom de la classe. Je n'ai pas trouvé de code qui fonctionne pour récupérer le nom de la classe générique.
L'utilisation de Classe.forName est montréé à partir de la 21eme minute ici :

Dans les autres voies, je trouve des solutions.
Ma première remarque, c'est que je ne comprends pas pourquoi tu veux que ta classe BComboBox soit abstraite. A cause de cela, je dois inutilement l'utiliser en classe anonyme :

Code :

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

BComboBox<String> bc = new BComboBox<String>() {};

Seconde remarque, Il est possible d'utiliser la composition plutôt que l'héritage. Cela conserver la possibilité d'hériter d'autre chose, et en plus, le complèteur de code n'est pas pollué par les méthodes de JComboBox quand on utilise BComboBox.

Code :

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

1
2
3
4
5
6
7
8
 
public abstract class CComboBox<T> {
	private JComboBox<T> cb;
	public CComboBox() {
		super();
		cb = new JComboBox<T>();
	}
}

Pour la résolution du problème je trouve 3 possibilités :
1) Fournir l'élément Tous à la méthode addAllOption

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
 
public abstract class BComboBox<T> extends JComboBox {
	protected boolean allOption;
 
	public void addAllOption(T all) {
		if (!allOption) {
			insertItemAt(all, 0);
		}
		allOption = true;
	}
 
	public void removeAllOption() {
		if (allOption) {
			removeItemAt(0);
		}
		allOption = false;
	}
 
	private boolean isAllOptionActived() {
		return allOption;
	}
 
}

2) Demander l'élément Tous au constructeur :

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
 
public  class B2ComboBox<T> extends JComboBox {
	protected boolean allOption;
	private T allOptionElement;
 
	private T getAllOptionElement() {
		return allOptionElement;
	}
 
	public B2ComboBox(T allOptionElement) {
		super();
		this.allOptionElement = allOptionElement;
	}
 
	public void addAllOption() {
		if (!allOption) {
			insertItemAt(getAllOptionElement(), 0);
		}
		allOption = true;
	}
 
.....
 
}

3) Demander l'élément Tous à la classe fille en passant par une méthode abstraite :

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
 
public abstract  class B3ComboBox<T> extends JComboBox {
	protected boolean allOption;
 
	public abstract T getAllOptionElement();
 
	public void addAllOption() {
		if (!allOption) {
			insertItemAt(getAllOptionElement(), 0);
		}
		allOption = true;
	}
 
.....
 
}

Voici l'exemple d'utilisation :

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
 
public class test {
	public static void main(String[] args) {
		System.out.println("Début test");		
		CComboBox<String> cc = new CComboBox<String>() {};
 
		System.out.println("Version 1");
		BComboBox<String> bc = new BComboBox<String>() {};
		bc.addAllOption("Tous");
 
		System.out.println("Version 2");
		B2ComboBox<String> bc2 = new B2ComboBox<String>("Tous") ;
		bc2.addAllOption();
 
		System.out.println("Version 3");
		B3ComboBox<String> bc3 = new B3ComboBox<String>() {
			@Override
			public String getAllOptionElement() {				
				return "Tous";
			}
		};
		bc3.addAllOption();
		System.out.println("test terminé");
 
	}
}

[CoderInTheDark]

Bonjour,

Merci à vous deux.

Pour mieux cerner mon besoin.

Dans un premier temps j'ai fait mon paquage "Bog" Boite à outils graphiques.
J'y ai regroupé tous mes objets swing et j'ai un peu factorisé

J'ai dérivé plusieurs fois de JComboBox, pour créer des listes dédiées à mes objets métiers, que j'réutilise dans des composants surtout des JInternal frame

Chaque liste est dédiées à un type d'objet métier.

J'impose un constructeur avec un argument une interface avec une méthode pour accéder au DAO pour la remplir avec l'objet métier visé.

Je me suis appperçu que parfois j'avais besoin d'un item de liste "tout".
D'où mon idée de factoriser la méthode ajouter item tout....
Car pour l'instant le code est dupliqué et ça ne plait pas beaucoup, car c'est pratiquement la même chose, car ça n'a pas été codé en même temps.

Je pourrai envisager aussi d'ajouter cet item du type d'une classe "AllOption".
Mais pour l'instant j'utilise la généricité pour limiter à un objet métier, et que java me colle un warning car une JComboBox attends cet argument

Je peux faire aussi dériver mes objets métier d'un même type parents "MyBuisnessObject", je cherche encore un nom

[thelvin]

Moui mais c'est trop vague. Ce qu'il faut c'est du code, surtout la partie où il y a duplication/factorisation.

On sait pas si ce dont on a parlé peut s'appliquer, ou si c'est une mauvaise approche.

[CoderInTheDark]

Voici un exemple mais pour les autres c'est la même chose

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
public class BComboBoxJournaux<> extends JComboBox {
	private static final long serialVersionUID = 1L;
 
	private boolean allOption = false;
 
	private XContextInterface xContext;
 
 
	BComboBoxJournaux(XContextInterface xContext) {
		super(xContext.getJournaux().toArray());
		this.xContext = xContext;
 
		setSelectedIndex(0);
	}
 
	public void addAllOption(boolean all) {
		if(!allOption) {
			insertItemAt(new Journal("ALL", "Tout"), 0);
	}
}
 
public void removeAllOption() {
	if(allOption ) {
removeItemAt(0);
	}
}
 
	public void setSelectedJournal(Journal journal) {
		if (journal != null)
			setSelectedItem(journal);
	}
 
	public void setSelectedJournal(String codeJournal) {
			try {
				setSelectedItem(xContext.getJournal(codeJournal));
			} catch (XComptaObjetIntrouvableException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	}
}

[thelvin]

C'est la même chose que ton premier message, en moins informatif.

Honnêtement là j'en suis réduit à faire un rappel au bon sens : quand tu parles aux gens, en général et ici en particulier, tu devrais le faire exactement comme s'ils n'avaient pas de super-pouvoir et qu'il ne leur était pas possible de lire dans tes pensées ce que tu as choisi de ne pas montrer.

Parce qu'en fait, ils n'ont pas de super-pouvoir et ils ne peuvent savoir de toi et tes problèmes, que ce que tu leur montres.

Or, comme tu peux le constater, tu n'as rien montré qui permette de savoir ce qui se passe avec tes problèmes de factorisation de code. Il fallait donc faire autrement : à savoir montrer suffisamment de choses pour qu'on sache ce qui t'arrive.

(A noter que c'est presque toujours une question de qualité plutôt que de quantité, autrement dit qu'il ne faut pas montrer plus de choses, mais il faut montrer les bonnes choses, celles qui font qu'on sait ce qui se passe, et pas celles qui ne servent à rien pour savoir ce qui se passe. Ici le code que tu as montré, on doit essayer de deviner un peu, mais il semble que la plupart des lignes soient inutiles pour savoir ce qui t'arrive. Ajouter plus de ces lignes-là n'est pas utile. Par contre il faut montrer les lignes et les classes qui montrent où tu en es. Bref, simplement faire ce qui est utile et pas ce qui est inutile.)

[CoderInTheDark]

Bonjour,

Ce n'est pas faux, et même péranptoire de ma part.
Je suis désolé, je ne suis pas toujours claire.
J'avais cru que vous aviez demandé un exemple.

Voici un deuxième exemple commenté, et on voit que ça ressemble beaucoup aux précédent.

De façon global, j'ai fait une boîte graphique pour mes objets métier, Compte, Journaux, Classe.. prête à l'emploi.

Là le besoin est toujours le même pour mes JInternalFrame, avoir une liste remplie avec des objets métiers
C'est pourquoi je veux dériver de JComboBox et généraliser les méthodes en commun .
Ici une méthode pour proposer un item "tout/all", du même type que les objets métiers de la JComBobox

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
 
//Je dérive de JCombobox pour avoir des listes personnalisés
//je pensais faire une classe mère abstraite pour gérer les méthodes communes comme pour l'option "all/tout", qui est commune à toute mes listres
//Je n'ai pas utilisé la générécité sur la combobox 
//car le compilateur lève une erreur//Cannot instantiate the type Compte	BComboBoxComptes.java	
public class BComboBoxComptes extends JComboBox {
//en fonction de l'état si c'est vrai 
	private boolean allOption = false;
 
//Cette interface permet d'appeler  le DAO pour remplir la liste avec les objets métiers pour lesquels elle est destinée
//J'ai plusieurs implémentations pour les DAO
	private XContextInterface xContext;
 
//Je construits une JCombobox remplie
	BComboBoxComptes(XContextInterface xContext) {
		super();
		this.xContext = xContext;
 
//Je récupère mes objets métiers et je rempli ma liste grace l'interface
		addItem(xContext.getComptes().toArray());
		setSelectedIndex(0);
	}
 
//Là les deux méthode utilitaire pour ajouter ou supprimer l'option "all/tout"
//Ces  méthodes sont communes à plusieurs de me listes
//d'ou mon besoin de passer par un généric une classe mère ou une interface et de construire l'objet "ALL/Tout" d'après le généric déclarer dans l'implémentation concrète
//Je peux revenir sur le fait qu'on puisse l'ajouter ou la supprimer après la création
/§/Ca simplifirai le code et se besoin n'est pas vraimen utile
//en ajoutant un paramètre boolean allOption dans le constructeur par défaut à false
//mais j'au rai toujours besoin de construire en fonction du type générique
	public void setAllOption() {
		if (!allOption) {
//On crée un objet métier du même type avec comme clef all par convention
			Compte compte = new Compte("ALL", "tout");
//ici je crée un item tout, mais j'envi ne trouve pas cette option très heureuse
 
			insertItemAt(compte, 0);
			allOption = true;
		}
	}
 
	public void removeAlloption() {
		if (allOption) {
			removeItemAt(0);
		}
	}
 
 
//Et globallement je vais essayer  de reprendre des méthodes du 
	public void setSelectedComptes(String numeroCompte) {
(...)

En espérant avoir été claire

[seroze]

Pourquoi est-ce qu'il te faut créer un Compte "Tous" ?
Est-ce que tu ne pourrais pas utiliser un Objet String ?

exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
public abstract class BComboBox<T> extends JComboBox {
 
	protected boolean allOption;
 
	public void addAllOption() {
		if (!allOption) {
			insertItemAt("Tous", 0);
		}
		allOption = true;
	}

Ensuite à un moment il faudra tester le type de l'objet sélectionné avec if (getSelectedItem() instanceof String) { /* Tous est sélectionné */ }.

Le compilateur fait un avertissement :

Type safety: The method insertItemAt(Object, int) belongs to the raw type JComboBox. References to generic type JComboBox<E> should be parameterized

Ca fonctionne quand même.


De toute façon et de manière péremptoire "Tous" et un élément défini ne devrait pas être du même type.

Sinon, la méthode no 3 que j'ai posté auparavant est bien :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
public abstract  class B3ComboBox<T> extends JComboBox {
	protected boolean allOption;
 
	public abstract T getAllOptionElement();
 
	public void addAllOption() {
		if (!allOption) {
			insertItemAt(getAllOptionElement(), 0);
		}
		allOption = true;
	}

avec la méthode abstraite getAllOptionElement() on sous-traite cette fonction par la classe fille.

Je pense aussi à une autre méthode qui demanderai du changement :
Il faudrait alors demander à la classe XContextInterface de générer l'élément "Tous"
Alors il faudrait créér une interface générique et que chaque Objet DAO implémente cette structure.
getComptes() serait changé en comptesDAO.getList(),
la classe ComptesDAO implémente l'interface utile pour remplir le comboBox : getList et getAllOptionElement()

Le code sera donc :

Code :

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

insertItemAt( xContext.getAllOptionElement(), 0);

[CoderInTheDark]

Bonsoir,

Merci pour ton code.
Ca me donne des idées.

A la base je voulais une option configurable tous, car ce n'est pas toujours pratique de tout sélectionner.
Et j'ai besoin de composant prèt à l'emploi et configurables.

Je n'prévoit pas de mélanger les types dans la collection de la JComboBox.
Car ils servent surtout de filtres pour des reqêtes.
Alors plutôt que mélanger dans les liste j'en mets plusieurs.

La plus part du temps je récupère la clef et m'en sert pour la donner aux DAO.

Si l'item "tout", doit être d'un type différent.
Je peux définir un type abstrait parent pour tous les objets métiers.
Et le définir en tant que type generic de la combobox.
et dériver l'item "tous " aussi de ce super type.

Dans ce cas le DAO doit juste détecter que c'est un item tous et adapte sa requête.

Mais c'est contraignant cet héritage

Avoir un type tous pourquoi pas

Peut être une interface serait bien aussi.
Comme j'ai besoin des mêmes comportements pour les DAO

Cordialement