Interface et Généricité

Version imprimable

Bonsoir à tous ,
voici une interface :

Code:

1
2
3
4
 
public interface Triable<T> {
    public int tri(T elem);
}

et voici ma classe :

Code:

1
2
3
4
5
6
7
 
public class tri_exemple implements Triable<T> {
    public int tri(T elem) {return 1;}
    public static void main(String[] args) {
        ;
    }
}

Pourtant lors de la compilation j'obtiens des erreurs :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
tri_exemple.java:8: cannot find symbol
symbol: class T
public class tri_exemple implements Triable<T> {
                                            ^
tri_exemple.java:9: cannot find symbol
symbol  : class T
location: class tri_exemple
    public int tri(T elem) {;}
                   ^
2 errors

Je ne comprend pas ??

14/06/2017, 17h13
thelvin

Ben, ton interface Triable a un paramètre <T>. Très bien, parfait.

Et tu essaies d'implémenter cette interface avec une classe tri_exemple.

C'est bien joli, mais il faut préciser ce que vaut le paramètre <T> de cette interface que tu implémentes, maintenant ! C'est quoi, <String>, <Date>, <OutputStream> ? Quoi ?

Ou alors, ta classe tri_exemple est elle aussi paramétrée, et elle n'impose rien de plus au paramètre que ne le faisait déjà l'interface. Dans ce cas il faut le dire qu'elle est paramétrée aussi !

Code:

public class tri_exemple<T> implements Triable<T> {

voilà ce que j'ai fait :

Code:

1
2
3
4
5
6
7
8
 
public class tri_exemple<T> implements Triable<T> {
    public int tri(T elem) {return 1;}
    public static void main(String[] args) {
        int i = 5;
        System.out.println(tri(i));
    }
}

mais maintenant :

Code:

1
2
3
4
5
 
tri_exemple.java:12: tri(T) in tri_exemple<T> cannot be applied to (int)
        System.out.println(tri(i));
                           ^
1 error

Pourquoi donc ??

14/06/2017, 21h47
tchize_

T est un object, int n'est pas un Object. Utilise Integer.

En réalité je souhaite creer une méthode générique au sein d'une interface ,comme ceci :

Code:

1
2
3
4
 
publc interface Triable {
    public <Type> int methode(>Type> element);
}

et pouvoir l'utiliser comme celà :

Code:

1
2
3
4
5
6
7
8
9
10
11
 
public class maClasse {
    public <Type> int methode(<Type> element) { ... }
    public static main(String[] args) {
        int i = 5;
       double d = 2.36;
       String s = "blablabla";
 
       methode(i);methode(d);methode(s);
}
}

Est ce correct ?

15/06/2017, 12h26
thelvin

Hello,

Non, ce n'est pas correct, on comprend rien à ce que tu dis.

Arrête de faire des exemples partiels qui n'ont aucun sens et à la place, parle-nous exactement comme tu le ferais si on était pas dans ta tête et qu'on ne pouvait pas lire tes pensées :

Explique nous, vraiment ce qu'il vont faire tes objets, vraiment en quoi ils ont un comportement commun que tu veux unifier de manière générique, et un exemple complet, avec point de départ et arrivée, d'à quoi ça va ressembler quand tu l'appelles et à quoi ça sert.

Salut,

Citation:

Envoyé par exe2bin

Est ce correct ?

Non, déjà,parce que la méthode methode n'est pas static. Sans parler des autres approximations syntaxiques. Il faudrait par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class maClasse { public <Type> int methode(Type element) { System.out.println(element); return -1; } public static void main(String[] args) { int i = 5; double d = 2.36; String s = "blablabla"; maClasse instance = new maClasse(); instance.methode(i); instance.methode(d); instance.methode(s); } }
Même pas besoin d'interface pour ça. Mais à quoi ça servirait au juste ? On peut écrire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class maClasse { public int methode(Object element) { System.out.println(element); return -1; } public static void main(String[] args) { int i = 5; double d = 2.36; String s = "blablabla"; maClasse instance = new maClasse(); instance.methode(i); instance.methode(d); instance.methode(s); } }
Même plus besoin de génériques.

Lorsque tu crées une interface, le but est de l'implémenter dans une classe. Le type générique va permettre d'adapter la classe à un type particulier.

Donc on peut écrire :
Code:

1 2 3 public interface Triable<Type> { public int methode(Type element); }
Et l'implémenter :
Code:

1 2 3 4 5 public class IntegerTriable implements Triable<Integer> { public int methode(Integer element) { return element; } }
Code:

1 2 3 4 5 public class StringTriable implements Triable<String> { public int methode(String element) { return element.length(); } }
Et faire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 public class Exemple { public static void main(String[] args) { new IntegerTriable().methode(42); new StringTriable().methode("astalavista"); new Triable<Double>() { public int methode(Double element) { return -1; } }.methode(Math.PI); } }
Je ne sais pas exactement ce que tu cherches à faire, mais peut-être serait-il plus simple que tu nous exposes le problème que tu cherches à résoudre avec tes mots à toi, plutôt que d'essayer de nous présenter quelque chose avec une syntaxe Java, pas forcément adaptée au problème que tu veux résoudre, ou suffisamment incorrecte pour qu'on ne comprenne pas ce que tu cherches à résoudre.

16/06/2017, 12h15
exe2bin

J'ai un algorithme de tri dont j'aimerais faire une méthode (virtuelle) ,pouvant trier un tableau de n'importe quel type primitifs ou objet.
Est ce assez clair !
16/06/2017, 12h30
joel.drigo
Citation:

Envoyé par exe2bin

tableau de n'importe quel type primitifs ou objet.

Déjà, ça, tu ne pourras pas. Une méthode pour trier n'importe quel type objet, oui. Mais pour les types primitifs, il faudra faire une méthode par type.
Ensuite, pour trier les objets, il suffit de s'inspirer de ce que fait déjà Java pour ça :
1. Une méthode qui tri :
  
  Code:
  
  public static <T> void sort(T[] tableau, Comparator<? super T> comparateur) {
2. Une classe qui permet d'ordonner un objet par rapport à un autre
  Code:
  
  1 2 public interface Comparator<T> { int compare(T object1, T object2);
Pour trier un tableau de Integer, on fera :

Code:

Arrays.sort( tableau, Comparator.naturalOrder());

Sachant que Comparator.naturalOrder() retournera une instance de classe qui pourrait être écrite comme ça
Code:

1 2 3 4 5 public class ComparableComparator<T> implements Comparable<T> { public int compare(T o1, T o2) { return o1.compareTo(o2); } }
Autant conserver cette notion de comparateur, en utilisant la classe native, dans ton algorithme, parce que ça permet d'être généralement compatible avec ce qui existe.

Citation:

Envoyé par exe2bin

une méthode (virtuelle)

C'est une notion C++ qui n'a pas vraiment d'équivalent en Java.