Discussion :

[michelp3]

Bonjour voici un code très simple mais je ne vois pas pourquoi çà coince

Meci de votre aide

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
 
package ajeter;
 
 
class C <T> {
 
	public void  m1(<? extends T> val2){
				System.out.println(val2);
 
	}
}
 
public class Nice2 {
	public static void main(String[] args) {
		Integer i = 4;
		C<Number> c = new C<Number>();
		c.m1(i);
	}
}

[ncckto]

Bonjour,
si j'ai bien compris ce que tu veux faire, je te propose ceci :

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
class C<T> {
 
  public void m1(T val2) {
    System.out.println(val2);
  }
}
 
public class Nice2 {
 
  public static void main(String[] args) {
    C<? super Integer> c = new C<Number>();
    c.m1(4);
  }
 
}

cordialement

[thelvin]

Bonjour voici un code très simple mais je ne vois pas pourquoi çà coince

Parce que <? extends T> n'est pas un type et n'a donc rien à faire tout seul devant un nom de variable.

Si tu cherches un type générique auquel on peut assigner n'importe quel objet de type T ou d'un sous-type de T.... Eh ben c'est T, tout simplement. Principe habituel de l'héritage.

[michelp3]

OK mais alors comment je fais si je souhaite imposer

que les arguments passés à la méthode soient des classes filles de T

[thelvin]

Uniquement des classes filles et pas T lui-même ? Tu peux pas. Une méthode par classe fille acceptée.

Bien sûr, une idée simple serait de le faire quand tu choisis T : faire que ce soit une interface, ou une classe abstraite. Comme une interface ou une classe abstraite ne peuvent pas être instanciées, les objets seront forcément de classes filles.

[michelp3]

Ok pour la question précédente mais ceci est aussi basique et m'ennuie autant

Pourquoi la méthode add() ne fonctionne pas

Merci d'avance

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 ajeter;
 
import java.util.ArrayList;
import java.util.List;
 
class Personne{
 
}
 
class Employee extends Personne{
 
}
 
public class Nice3_75_76 {
	public static void main(String[] args) {
		List <? extends Personne> al = new ArrayList<Employee>();
 
			Employee employee = new Employee();
 
			al.add(new Employee());
 
 
	}
 
}

[Cafeinoman]

Comme d'habitude, je suis pas sur, mais :

Code :

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

1
2
3
Employee employee = new Employee();
 
			al.add(new Employee());

ne devrait-il pas être :

Code :

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

1
2
3
Employee employee = new Employee();
 
			al.add(employee);

et ensuite, si comme c'est dit plus haut tu as fait de Personne une classe abstraite (ou une interface...), pourquoi ne pas mettre simplement :

Code :

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

List <Personne> al = new ArrayList<Employee>();

Toute complication entraîne un risque d'erreur... Je fais comme ça dans l'appli RH sur laquelle je bosse, et je n'ai pour l'instant jamais vu de Personne abstraite se pointer sur mon UI...

[tchize_]

Je crois que tu as mal compris comment marche "?" dans les generic.

Ca ne veux pas dire "n'importe quoi", ça veux dire "quelque chose que je ne connais pas".

Ainsi quand tu dis que tu as une List<? extends Employee>, tu es occupé de dire au compilateur que la liste contient un type bien précis qui étends Employé MAIS que tu ne connais pas ce type (ça peut être Chef, Ouvrier ou ResponsableSyndicale).

Du coup, quand tu appelle la méthode add(T), le compilateur est incapable de connaitre le Type concret accepté et du coup est incapable de dire si le type Employee que tu essaie de passer en paramètre est recevable.


Pour expliquer avec un exemple:

Code :

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

1
2
3
4
List<Chef> liste = new ArrayList<Chef>();
List<? extends Employee> autreliste  = liste ; // ceci est valable, Chef est bien un QuelqueChose qui étends employé
autreliste.add(new Employee("Jean")); // est interdit
Chef chef = liste.get(0); // Sinon là on aurait un sérieux problème et un classcastexception à l'exécution.

Dis encore autrement, List<Employee>, ce n'est pas la même chose du tout que List<? extends Employee>

Dans le premier on peux lui passer des employés ou des sous type de employé. Dans le deuxième, on peux lui passer un "?" ou un sous type. Et comme on ne connais par définition pas ?, ça limite fortement l'utilisation

[michelp3]

Bonjour Tchize et merci de ton explication complète qui m'a permis d'avancer

J'ai d'ailleurs revu mon code qui marie maintenant

GENERICITE et POLYMORPHISME

Voic le code , votre avis : Utile ou pas ???

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
package ajeter;
 
import java.util.ArrayList;
import java.util.List;
 
class Personne{
	public String nom;
	public Personne(String nom) {
		this.nom = nom;
	}
	public void quisuisje() {
		System.out.println("Je suis la méthode Personne");
	}
}
 
class Employee extends Personne{
 
	public Employee(String nom) {
		super(nom);
	}
	public void quisuisje() {
		System.out.println("Je suis la méthode Employee");
	}
}
 
class Outils extends Personne{
 
	public Outils(String nom) {
		super(nom);
	}
	public void quisuisje() {
		System.out.println("Je suis la méthode Outils");
	}
}
 
public class Nice3_75_76 {
	public static void main(String[] args) {
 
		// idée de départ afin d'ajouter des Employee à list0
		// List <Personne> liste0 = new ArrayList<Employee>();  //NOT OK
		//**************************************************************
 
		// Contourner le problème 
		//***********************
		ArrayList<Employee> ae = new ArrayList<Employee>();
		ae.add(new Employee("Patrick"));
		ae.add(new Employee("Edouard"));
		for (Employee employee : ae) {
			System.out.println(employee.nom);
		}
 
		List<Personne> liste0 = new ArrayList<Personne>();
 
		System.out.println("--------------");
		List <? extends Personne> l = ae;						
			for (Personne employee : l) {
			System.out.println(employee.nom);
			liste0.add(employee);
		}
 
		System.out.println("------------------");
		for (Personne personne : liste0) {
			System.out.println(personne.nom);
		}
 
		// Mélanger les Employee et les Outils Mais 
		// a chacun sa methode 
		//************************************
		System.out.println("************************");
		ArrayList<Outils> ao = new ArrayList<Outils>();
		ao.add(new Outils("marteau"));
		ao.add(new Outils("tournevis"));
		for (Outils outils : ao) {
			System.out.println(outils.nom);
		}
 
		System.out.println("--------------");
		l = ao;						
			for (Personne outils : l) {
			System.out.println(outils.nom);
			liste0.add(outils);
		}
 
		System.out.println("------------------");
			for (Personne personne : liste0) {
				System.out.println(personne.nom);
				personne.quisuisje();
			}
 
	}
 
}

[tchize_]

pour info, tu n'es pas obligé de faire ça

Code :

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

1
2
3
4
5
		l = ao;						
			for (Personne outils : l) {
			System.out.println(outils.nom);
			liste0.add(outils);
		}

Pour ajouter des items à liste0, tu peux simplement écrire

Code :

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

1
2
 
			liste0.addAll(ao);

ao contient des outils, des outils sont des personnes (ahem, pas le dire aux syndicats), donc on peux ajouter le contenu de ao dans liste0