Discussion :

[exe2bin]

Bonsoir à tous ,
voici une interface :

Code :

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

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

et voici ma classe :

Code :

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

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 :

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

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 ??

[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 :

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

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

[exe2bin]

voilà ce que j'ai fait :

Code :

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

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 :

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

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 ??

[tchize_]

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

[exe2bin]

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

Code :

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

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

et pouvoir l'utiliser comme celà :

Code :

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

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 ?

[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.

[joel.drigo]

Salut,

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 :

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
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 :

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
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 :

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

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

Et l'implémenter :

Code :

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

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

Code :

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

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

Et faire :

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
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.