Quelle est la différence entre un champ, une variable, un attribut et une propriété dans les POJO Java?
En faisant référence aux variables privées internes des POJO Java qui ont des getters/setters, j'ai utilisé les termes suivants:
- champ
- variable
- attribut
- propriété
Y a-t-il une différence entre ce qui précède? Si oui, quel est le terme correct à utiliser? Existe-t-il un terme différent à utiliser lorsque cette entité est persistante?
De là: http://docs.Oracle.com/javase/tutorial/information/glossary.html
champ
- Un membre de données d'une classe. Sauf indication contraire, un champ n'est pas statique.
propriété
- Caractéristiques d'un objet que les utilisateurs peuvent définir, telles que la couleur d'une fenêtre.
attribut
- Non répertorié dans le glossaire ci-dessus
variable
- Une donnée nommée par un identifiant. Chaque variable a un type, tel que int ou Object, et une portée. Voir aussi variable de classe, variable d'instance, variable locale.
Oui il y a.
Variable peut être local, champ ou constant (bien que ce soit techniquement faux). C'est vague comme attribut. En outre, vous devez savoir que certaines personnes aiment appeler des variables final non-statiques (locales ou d'instance)
" Valeurs ". Cela provient probablement des langages JVM FP émergents tels que Scala.
Le champ est généralement une variable privée dans une classe d'instance. Cela ne signifie pas qu'il y a un getter et un setter.
Attribute est un terme vague. Il peut facilement être confondu avec XML ou Java Naming API. Essayez d'éviter d'utiliser ce terme.
Propriété est la combinaison de getter et de setter.
Quelques exemples ci-dessous
public class Variables {
//Constant
public final static String MY_VARIABLE = "that was a lot for a constant";
//Value
final String dontChangeMeBro = "my god that is still long for a val";
//Field
protected String flipMe = "wee!!!";
//Property
private String ifYouThoughtTheConstantWasVerboseHaHa;
//Still the property
public String getIfYouThoughtTheConstantWasVerboseHaHa() {
return ifYouThoughtTheConstantWasVerboseHaHa;
}
//And now the setter
public void setIfYouThoughtTheConstantWasVerboseHaHa(String ifYouThoughtTheConstantWasVerboseHaHa) {
this.ifYouThoughtTheConstantWasVerboseHaHa = ifYouThoughtTheConstantWasVerboseHaHa;
}
}
Il y a beaucoup plus de combinaisons, mais mes doigts sont fatigués :)
Dietel et Dietel ont une bonne manière d’expliquer les champs par rapport aux variables.
“Ensemble, les variables statiques et les variables d’instance d’une classe sont appelées ses champs.” (Section 6.3)
"Les variables ne doivent être déclarées en tant que champs que si elles doivent être utilisées dans plusieurs méthodes de la classe ou si le programme doit enregistrer leurs valeurs entre les appels aux méthodes de la classe." (Section 6.4)
Ainsi, les champs d’une classe sont ses variables d’instance ou statiques, c’est-à-dire déclarées avec la portée de la classe.
Référence - Dietel P., Dietel, H. - Java ™ Procédure (premiers objets), Dixième édition (2014)
Si votre question vous demandait d'utiliser JAXB et de choisir la bonne variable XMLAccessType, j'avais la même question. JAXB Javadoc indique qu'un "champ" est une variable d'instance non statique, non transitoire. Une "propriété" a une paire getter/setter (elle doit donc être une variable privée). Un "membre public" est public et constitue donc probablement une constante. Toujours dans JAXB, un "attribut" fait référence à une partie d'un élément XML, comme dans <myElement myAttribute="first">hello world</myElement>.
Il semble qu'une "propriété" Java en général puisse être définie comme un champ avec au moins un getter ou une autre méthode publique permettant d'obtenir sa valeur. Certaines personnes disent aussi qu'une propriété doit avoir un passeur. Pour des définitions comme celle-ci, le contexte est tout.
Si vous prenez des indices d'Hibernate:
Hibernate lit/écrit l'état de l'objet avec son champ. Hibernate mappe également les propriétés de style Java Bean à DB Schema . Hibernate Accédez aux champs de chargement/enregistrement de l'objet . Si le mappage est effectué par propriété, hibernate utilise les méthodes getter et setter.
C'est l'encapsulation qui différencie signifie que vous avez getter/setters pour un champ et qu'il s'appelle propriété, avec cela et que nous cachons la structure de données sous-jacente de cette propriété dans setMethod, nous pouvons empêcher les modifications non désirées à l'intérieur des setters. Tout ce que l’encapsulation représente ...
Les champs doivent être déclarés et initialisés avant d'être utilisés. Principalement pour un usage interne en classe.
Propriétés peuvent être changées par le setter et elles sont exposées par les getters. Ici, le prix du terrain a le getter/setters, donc c'est la propriété.
class Car{
private double price;
public double getPrice() {…};
private void setPrice(double newPrice) {…};
}
<class name="Car" …>
<property name="price" column="PRICE"/>
</class>
De même, avec fields , [En veille prolongée, c’est la méthode recommandée pour utiliser MAP avec des champs, où private int id; est annoté @Id, mais avec Property vous avez plus de contrôle]
class Car{
private double price;
}
<class name="Car">
<property name=" price" column="PRICE" access="field"/>
</class>
Le document Java dit: Field est une donnée membre d'une classe. Un champ est une variable d'instance non statique, non transitoire . Le champ est généralement une variable privée d'une classe d'instance.
Les variables sont composées de champs et de non-champs.
Les champs peuvent être soit:
- Champs statiques ou
- des champs non statiques également appelés instanciations, par ex. x = F ()
Les non-champs peuvent être soit:
- les variables locales, l'analogue des champs mais à l'intérieur d'une méthode plutôt qu'à l'extérieur de chacune d'elles, ou
- paramètres, par exemple y dans x = f (y)
En conclusion, la distinction clé entre les variables est de savoir si elles sont des champs ou des non-champs, ce qui signifie si elles sont à l'intérieur d'une méthode ou en dehors de toutes les méthodes.
Exemple de base (excusez-moi pour ma syntaxe, je ne suis qu'un débutant)
Class {
//fields
method1 {
//non-fields
}
}
En réalité, ces deux termes sont souvent utilisés pour représenter la même chose, mais il existe des situations exceptionnelles. Un champ peut stocker l'état d'un objet. De plus, tous les champs sont des variables. Il est donc clair qu'il peut y avoir des variables qui ne sont pas des champs. En examinant les 4 types de variables (variable de classe, variable d'instance, variable locale et variable de paramètre), nous pouvons voir que les variables de classe et les variables d'instance peuvent affecter l'état d'un objet. En d'autres termes, si une variable de classe ou d'instance change, l'état de l'objet change. Nous pouvons donc dire que les variables de classe et les variables d'instance sont des champs, alors que les variables locales et les variables de paramètre ne le sont pas.
Si vous voulez comprendre plus profondément, vous pouvez aller à la source ci-dessous: -
Ma compréhension est comme ci-dessous, et je ne dis pas que c'est correct à 100%, je pourrais aussi bien me tromper.
Une variable est quelque chose que vous déclarez, qui peut par défaut changer et avoir des valeurs différentes, mais qui peut aussi être explicitement dite finale. En Java, ce serait:
public class Variables {
List<Object> listVariable; // declared but not assigned
final int aFinalVariableExample = 5; // declared, assigned and said to be final!
Integer foo(List<Object> someOtherObjectListVariable) {
// declare..
Object iAmAlsoAVariable;
// assign a value..
iAmAlsoAVariable = 5;
// change its value..
iAmAlsoAVariable = 8;
someOtherObjectListVariable.add(iAmAlsoAVariable);
return new Integer();
}
}
Donc, fondamentalement, une variable est tout ce qui est déclaré et peut contenir des valeurs. La méthode foo ci-dessus retourne une variable par exemple .. Elle retourne une variable de type Integer qui contient l'adresse mémoire du nouvel Integer (); Toutes les autres choses que vous voyez ci-dessus sont aussi des variables, listVariable, aFinalVariableExample et sont expliquées ici:
Un champ est une variable où la portée est plus claire (ou concrète). La variable renvoyant de la méthode de méthode foo n'est pas claire dans l'exemple ci-dessus, je ne l'appellerais donc pas un champ. D'autre part, iAmAlsoVariable est un champ "local", limité par la portée de la méthode foo, et listVariable est un champ "instance" où la portée du champ (variable) est limitée par la portée de l'objet.
Une propriété est un champ accessible/mutable. Tout champ qui expose un getter/setter est une propriété.
Je ne connais pas d'attribut et je voudrais aussi répéter que c'est ma compréhension de ce que sont les variables, les champs et les propriétés.
La question est ancienne, mais une autre différence importante entre une variable et un champ est qu'un champ obtient une valeur par défaut lorsqu'il est déclaré. Une variable, en revanche, doit être initialisée.