Quelle est la meilleure façon de partager des données entre des classes séparées en Java? J'ai un tas de variables utilisées par différentes classes dans des fichiers distincts de différentes manières. Laissez-moi essayer d'illustrer une version simplifiée de mon problème:
C'était mon code avant: P>
// in the top level class: Container c = new Container(x,y); a.setContainer(c); b.setContainer(c);
4 Réponses :
J'ai du mal à voir quel est votre problème - pourquoi ne voulez-vous pas transmettre x an comme un paramètre?
Oh, eh bien. En supposant que vous ne le faites pas, je ne vois pas besoin d'une nouvelle classe de conteneurs. Faites-le de cette façon: Bien sûr, vous devez ajouter les méthodes de getter public getx () et gety () à top_level_class. si vous le faites ne veut pas que la sous-classe soit dépendante de top_level_class, vous pouvez créer une interface qui donne accès aux variables.
Hmm d'accord. Je vais devoir jeter un coup d'œil sur des interfaces plus. La principale raison pour laquelle je ne voulais pas passer x, y chaque fois est que j'ai plusieurs fonctions dans plusieurs sous-classes qui utilisent chacune (x, y, z, etc.) et que cela ne semblait pas avoir raison de passer à 6-8 variables chacune temps j'appelle une fonction. Les sous-classes étaient dépendants, mais j'essaie de les sortir du fichier afin qu'ils puissent être utilisés dans un projet différent.
@ F20K VOTRE GUT Sentiment de ne pas vouloir passer 6-8 paramètres sur une méthode est sur la bonne voie. Les listes de paramètres qui sont aussi longs indiquant généralement que vous devriez envisager de regrouper ces paramètres dans un objet ou 2.
@Dan, merci pour votre suggestion. Je pense que je vais mettre en œuvre un conteneur. Cela a beaucoup de sens. J'avais juste craqué que ce serait une mauvaise pratique de programmation si j'ai partagé les données de cette façon.
Blockquote La principale raison pour laquelle je ne voulais pas passer x, y est à chaque fois parce que j'ai plusieurs fonctions dans plusieurs sous-classes que chaque utilisation (x, y, z, etc.) et il na pas sembler juste passer comme 6-8 des variables chacun fois que j'appelle une fonction. Les sous-classes utilisées pour dépendre, mais je suis en train de les sortir du fichier afin qu'ils puissent être utilisés dans un autre projet. Blockquote p>
Si tel est le cas, alors vous êtes mieux abstraire vos variables vers une classe de conteneur. Si chaque instance de ces classes ne-dépendant plus va utiliser un grand sous-ensemble de ces variables, alors il est logique de les avoir tous dans un cas. Les variables qui sont logiquement liées doivent être trouvées au même endroit. Votre approche doit être quelque chose comme: p>
public class Top_Level_Class(){ Container container = new Container(x, y, p, q, r, s); SubClass1a a = new SubClass1a(container); SubClass1a b = new SubClass1b(container); // gets user input which changes x, y using container's getters and setters public void main(){ // compute and set p, q, r, s a.doA(); b.doB(); } public class SubClass1a(Container c) { // in its own separate file public void doA(c.getX, c.getY, c.getP, c.getQ, c.getR){ // do something that requires x, y, p, q, and r } } public class SubClass1b(Container c) { // in its own separate file public void doB(c.getX, c.getY, c.getQ, c.getR, c.getS){ // does something else that requires x, y, q, r, and s } } public class Container(x, y, p, q, r, s) { //getters and setters for all variables }
Cette syntaxe est fausse et semble plus compliquée que la suggestion initiale.
Cette question est un peu folle - le code de la question ne compilera pas.
public class Main {
public static void main(String... args) {
MutableDataContainer m = new MutableDataContainer();
ImmutableDataContainer i = computeImmutableData();
new ADoer().doA(m, i);
new BDoer().doB(m, i);
}
...
}
class MutableDataContainer {
private int x, y;
... // getters and setters below
}
class ImmutableDataContainer {
private final int p, q, r, s;
... // getters below
}
Désolé, le code que j'ai écrit là-bas est d'aider à donner une idée de ce que je veux faire. Cela ne fonctionne pas réellement. Le code actuel est en fait plutôt compliqué avec plus de 100 lignes. J'essaie essentiellement de partager des variables très souvent utilisées dans la top_level_class entre les classes d'assistance dans des fichiers séparés. La question est quelle méthode serait la meilleure - efficace-sage et oop-sage
Je suppose que la réponse à votre question est le modèle de conception appelé singleton. Il vous permet essentiellement d'obtenir et d'exploiter la même instance (et unique) d'une classe chaque fois que vous le souhaitez dans votre système.
C'est sa mise en œuvre (veuillez pardonner les erreurs possibles de la syntaxe, je n'ai pas compilé.): puis si ailleurs dans votre code, vous importez le conteneur que vous pouvez écrire par exemple et vous affectera les attributs de l'unique Instance de conteneur Vous avez dans votre système Dans de nombreux cas, il est toutefois préférable d'utiliser le modèle d'injection de dépendance telle qu'elle réduit le couplage entre différents composants.
Très intéressant. Il a une variable statique d'elle-même. Vous vous demandez simplement comment cette chose sort-elle de la portée? Si c'est statique, il ne restera pas existant? Ou puis-je le mettre à NULL quand je suis terminé avec ça?
Désolé mais je suppose que je n'ai pas compris votre question :( de toute façon que son instance est statique, une fois initialisée, il restera existant. Vous n'êtes pas obligé, et vous ne pouviez pas, le mettre à la null. Considérez-le à un référentiel partagé de Vos variables :) Cependant voici une explication du modèle en.wikipedia.org/wiki/singleton_pattern
Hmm bien le singleton aura un sens si je n'ai besoin que de l'instancier une fois. Cependant, ma fonction de haut niveau est en fait un fil qui sera instancié / détruit plusieurs fois à plusieurs reprises tout au long de l'exécution du programme. Eh bien, je suppose que je peux simplement écraser les valeurs à chaque fois.
Créer et détruire le même fil de plusieurs reprises au cours de l'exécution d'un système est assez étrange. Vous voudrez peut-être probablement le dormir et l'éveillé si nécessaire
J'écris un jeu pour Android. Compte tenu du cadre, il est tout à fait possible qu'un utilisateur joue au jeu de sorte que le fil soit créé et détruit plusieurs fois. Le système d'exploitation Android détruira le fil si nécessaire pour libérer des ressources pour d'autres applications. Hmm. Peut-être le mettre au sommeil peut fonctionner, mais je pense que Android le détruira toujours lorsque l'utilisateur quitte le jeu.
J'aimerais ajouter que vous trouverez de nombreuses personnes qui disent que ce modèle est pur du mal à cause du fait qu'il s'agit simplement d'une enveloppe d'une variable globale. Le problème est également que, dans une architecture centrée sur le singletton, les dépendances des classes peuvent ne pas être claires. Personnellement, je pense que le modèle Singleton n'est qu'un modèle de conception vous aidant à être sûr que la classe n'aura qu'une seule instance. Ce n'est pas mauvais sur lui-même, cela dépend de la façon dont vous l'utilisez.
Utilisez instance! = Null au lieu de ! Instance , car le ! n'est pas défini pour ce type d'argument.
La réponse ici est, malheureusement, "cela dépend". programmeurs.SE pourrait être une cible plus fertile pour cette question.
Si la classe interne n'est pas statique, elle peut accéder également aux membres de la classe mère ...
Ce n'est pas une classe intérieure si c'est dans un fichier différent. Et ce n'est pas une sous-classe si cela ne prolonge pas la superclasse.
Oui, la sous-classe est un mauvais choix de mots de ma part. Je vais éditer cela.