Discussion :

[javan00b]

J'aimerais savoir,

par exemple, si je passe une reference d'un objet string a une autre classe, est-ce qu'il existe une méthode pour savoir l'origine de cette objet, de où a-t-elle été déclaré ou initialisé ?

En fait c'est parce que...

j'ai crée une classe serveur que j'aimerais pouvoir réutiliser dans n'importe quel de mes projets, mais celle-ci doit invoquer une methode dans la classe qui l'a instancier et par consequent la classe serveur doit connaitre son nom dynamiquement. donc je me demandais si il y avais une autre facon que de passé une reference de la classe directement dans les parametre d'initialisation jusqu'au constructeur de ma classe Serveur, exemple:

Serveur srv = new Serveur(maclass.class);

c'est la ligne que j'utilise en ce moment, sa pas l'air tres propre et je sais qu'il existe une autre facon de procédé.

aidez moi svp

[gronono]

Bonjour,

Je ne suis pas sur d'avoir bien saisi. Mais je pense que c'est le principe même des interfaces, non ?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
public interface FaitQQChose {
  public void faitQQChose();
}
 
public class Server {
  public Server(FaitQQChose faitQQChose) {
     faitQQChose.faitQQChose();
  }
}

Ainsi ta classe serveur est indépendante de l'implémentation de l'interface FaitQQChose.

J'espère t'avoir aider.

[javan00b]

ce que je cherche a faire en gros:

jai une classe serveur que j'instancie dans mes projets quand jen ai besoin. dans cette classe apres avoir recu les donnée du client elle renvoie a la methode Classeprincipale.traitement(); pour que les informations envoyer par le client sois traité.

jaimerais que ma classe serveur puissent s'adapter automatiquement avec tout autres projets sans aucune modification: en ce moment je doit toujour modifier cette ligne: ***nomdelaclasse***.traitement(args);

alors j'ai pensais reglé la solution avec la reflexivité, en passant une reference de la classe principal a ma classe serveur et en utilisant la methode.getName()...

alors ma ligne serai remplacer par une invocation du style

try{
meth = cls.getMethod("traitement");
meth.invoke(cls);

/* EUH EUH JCOUPE SA ICI POUR EVITÉ LES EXCEPTION bien sur ya des arguments mais cest un exemple. */

cls serai la reference de la classe principal passer en argument lors de l'instanciation de ma classe serveur

en bon debutant jai cru que c'est comme sa que fesais les vrais ? mais peux etre que je me trompe ?

dois-je me tourner vers les interfaces ?

[gronono]

Si tu ne veux (ou peux) pas utiliser les interfaces, effectivement, tu peux utiliser l'api reflexion. En gros le code va ressembler à :

Code :

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

1
2
3
4
5
6
7
8
9
 
public class Serveur {
  /** Effectue un appel à object.methodName().
    * methodName doit être une méthode de object et ne doit pas avoir d'argument. */
  public Serveur(Object object, String methodName) {
    Method method = object.getClass().getDeclaredMethod(methodName, new Class[0]);
    method.invoke(new Object[0]);
  }
}

Reste à gérer les nombreuses exceptions, le retour de la méthode, les paramètres de la méthode, .....

Le plus simple reste l'utilisation d'interface qui à utiliser une interface générique comme Runnable.

Je n'arrive pas à trouver de cas concret où l'utilisation d'interface ne serait pas possible.

[javan00b]

merci de ton aide, je vais aller lire un peu sur les interfaces, je n'ai jamais rien lu haha.

j'espere que sa pourra m'aider sinon je m'en tiendrai a l'utilisation de l'api, mais je te fait confiance pour les interfaces.

edit: je crois deja avoir compris le concept en 2min, l'interface serait dans le meme fichier que ma classe serveur,

ensuite ma classe principal implemente l'interface ce qui l'oblige a avoir toute les methodes de celle-ci exemple public void traitement(String recu)

mais ensuite dans ma classe serveur que devient le: maclasse.traitement(data) ???? moninterface.traitement(data) qui redirige automatique vers la classe principal a cause de l'implementation ? cest bien cela ?

[gronono]

Je crois que tu as compris le principe. Voici un exemple :

L'interface :

Code :

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

1
2
3
4
5
 
public interface FaitUnTraitement {
    /** Effectue un traitement sur la chaine spécifiée. */
    public void traitement(String msg);
}

La classe Serveur :

Code :

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

1
2
3
4
5
6
 
public class Serveur {
    public Serveur(FaitUnTraitement faitUnTraitement) {
        faitUnTraitement.traitement("C'est mon serveur l'appelant.");
    }
}

Une implémentation de FaitUnTraitement affichant la chaine :

Code :

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

1
2
3
4
5
6
7
8
 
public class PrintTraitement implements FaitUnTraitement {
    @Override
    public void traitement(String msg) {
        System.out.println(msg);
    }
 
}

La classe de Test pour tester tout ça :

Code :

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

1
2
3
4
5
6
7
 
public class Test {
    public static void main(String[] args) {
        FaitUnTraitement traitement = new PrintTraitement();
        Serveur serveur = new Serveur(traitement);
    }
}

Ton serveur est capable de manipuler n'importe quelle implémentation de FaitUnTraitement.
Dans le test, le traitement consiste à afficher un ligne dans la console. C'est la classe Serveur qui finalement appelle PrintTraitement via l'interface.

[javan00b]

MERCI GROSNONO tu est loin d'etre nono

merci 1000x