¿Cuál es la diferencia entre campo, variable, atributo y propiedad en los POJO de Java?

Al referirme a las variables privadas internas de los POJO de Java que tienen captadores / definidores, he usado los siguientes términos:

• campo
• variable
• atributo
• propiedad

¿Hay alguna diferencia entre lo anterior? Si es así, ¿cuál es el término correcto para usar? ¿Hay un término diferente para usar cuando esta entidad persiste?

Desde aquí: http://docs.oracle.com/javase/tutorial/information/glossary.html

• campo

  • Un miembro de datos de una clase. A menos que se especifique lo contrario, un campo no es estático.

• propiedad

  • Características de un objeto que los usuarios pueden establecer, como el color de una ventana.

• atributo

  • No figura en el glosario anterior.

• variable

  • Un elemento de datos nombrado por un identificador. Cada variable tiene un tipo, como int u Object, y un ámbito. Ver también variable de clase, variable de instancia, variable local.

Sí hay.

La variable puede ser local, de campo o constante (aunque esto es técnicamente incorrecto). Es vago como atributo. Además, debe saber que a algunas personas les gusta llamar variables finales no estáticas (locales o de instancia)

" Valores ". Esto probablemente proviene de lenguajes emergentes JVM FP como Scala.

El campo es generalmente una variable privada en una clase de instancia. No significa que haya un getter y un setter.

El atributo es un término vago. Se puede confundir fácilmente con XML o Java Naming API. Intenta evitar usar ese término.

La propiedad es la combinación getter y setter.

Algunos ejemplos a continuación.

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;
    }

}

Hay muchas más combinaciones, pero mis dedos se están cansando :)

Si su pregunta fue solicitada usando JAXB y queriendo elegir la correcta XMLAccessType, tenía la misma pregunta. El Javadoc JAXB dice que un "campo" es una variable de instancia no estática, no transitoria. Una "propiedad" tiene un par getter / setter (por lo que debería ser una variable privada). Un "miembro público" es público y, por lo tanto, es probablemente una constante. También en JAXB, un "atributo" se refiere a parte de un elemento XML, como en <myElement myAttribute="first">hello world</myElement>.

Parece que una "propiedad" de Java, en general, puede definirse como un campo con al menos un captador u otro método público que le permita obtener su valor. Algunas personas también dicen que una propiedad necesita tener un setter. Para definiciones como esta, el contexto lo es todo.

Dietel y Dietel tienen una buena manera de explicar los campos frente a las variables.

"En conjunto, las variables estáticas y las variables de instancia de una clase se conocen como sus campos". (Sección 6.3)

"Las variables deben declararse como campos solo si son necesarias para su uso en más de un método de la clase o si el programa debe guardar sus valores entre llamadas a los métodos de la clase". (Sección 6.4)

Por lo tanto, los campos de una clase son sus variables estáticas o de instancia, es decir, declaradas con alcance de clase.

Referencia: Dietel P., Dietel, H. - Programación de Java ™ (objetos iniciales), décima edición (2014)

Si tomas una pista de Hibernate:

Hibernate lee / escribe el estado del objeto con su campo. Hibernate también asigna las propiedades de estilo Java Bean a DB Schema. Hibernar Acceda a los campos para cargar / guardar el objeto. Si la asignación se realiza por propiedad, hibernate usa getter y setter.

Es la Encapsulación la que diferencia los medios donde tiene getter / setters para un campo y se llama propiedad, con eso y ocultamos la estructura de datos subyacente de esa propiedad dentro de setMethod, podemos evitar cambios no deseados dentro de los setters. Todo lo que significa encapsulación ...

Los campos deben declararse e inicializarse antes de ser utilizados. Principalmente para uso interno de clase.

Las propiedades pueden ser cambiadas por setter y están expuestas por getters. Aquí el precio de campo tiene captadores / establecedores, por lo que es propiedad.

class Car{
 private double price;
 public double getPrice() {…};
 private void setPrice(double newPrice) {…};
}

<class name="Car" …>
<property name="price" column="PRICE"/>
</class>

Del mismo modo, utilizando campos , [en hibernación es la forma recomendada de MAP utilizando campos, donde private int id; está anotado en @Id, pero con Property tienes más control]

class Car{
  private double price;
}
<class name="Car">
<property name=" price" column="PRICE" access="field"/>
</class>

El documento de Java dice: Field es un miembro de datos de una clase. Un campo es una variable de instancia no estática, no transitoria. El campo es generalmente una variable privada en una clase de instancia.

Las variables se componen de campos y no campos.

Los campos pueden ser:

1. Campos estáticos o
2. campos no estáticos también llamados instancias, por ejemplo, x = F ()

Los no campos pueden ser:

1. variables locales, el análogo de los campos pero dentro de un método en lugar de fuera de todos ellos, o
2. parámetros, por ejemplo, y en x = f (y)

En conclusión, la distinción clave entre las variables es si son campos o no campos, lo que significa si están dentro de un método o fuera de todos los métodos.

Ejemplo básico (disculpe mi sintaxis, solo soy un principiante)

Class {    
    //fields    

    method1 {              
         //non-fields    

    }    
}

En realidad, estos dos términos se utilizan a menudo para representar lo mismo, pero hay algunas situaciones excepcionales. Un campo puede almacenar el estado de un objeto. También todos los campos son variables. Por lo tanto, está claro que puede haber variables que no son campos. Entonces, al observar los 4 tipos de variables (variable de clase, variable de instancia, variable local y variable de parámetro) podemos ver que las variables de clase y las variables de instancia pueden afectar el estado de un objeto. En otras palabras, si una variable de clase o instancia cambia, el estado del objeto cambia. Entonces podemos decir que las variables de clase y las variables de instancia son campos, mientras que las variables locales y las variables de parámetros no lo son.

Si desea comprender más profundamente, puede dirigirse a la fuente a continuación:

http://sajupauledayan.com/java/fields-vs-variables-in-java

La pregunta es antigua, pero otra diferencia importante entre una variable y un campo es que un campo obtiene un valor predeterminado cuando se declara. Una variable, por otro lado, debe inicializarse.

Mi comprensión es la siguiente, y no estoy diciendo que esto sea 100% correcto, bien podría estar equivocado.

Una variable es algo que usted declara, que por defecto puede cambiar y tener valores diferentes, pero también se puede decir explícitamente que es final. En Java eso sería:

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();
    }
}

Básicamente, una variable es cualquier cosa que se declare y pueda contener valores. El método foo anterior devuelve una variable, por ejemplo. Devuelve una variable de tipo Integer que contiene la dirección de memoria del nuevo Integer (); Todo lo demás que ve arriba también son variables, listVariable, aFinalVariableExample y se explica aquí:

Un campo es una variable donde el alcance es más claro (o concreto). La variable que regresa del alcance del método foo no está clara en el ejemplo anterior, por lo que no lo llamaría un campo. Por otro lado, iAmAlsoVariable es un campo "local", limitado por el alcance del método foo, y listVariable es un campo de "instancia" donde el alcance del campo (variable) está limitado por el alcance de los objetos.

Una propiedad es un campo al que se puede acceder / mutar. Cualquier campo que exponga un captador / definidor es una propiedad.

No conozco el atributo y también me gustaría repetir que esta es mi comprensión de qué variables, campos y propiedades son.

• variable- dirección de almacenamiento con nombre. Cada variable tiene un tipo que define un tamaño de memoria, atributos y comportamientos. Hay para este tipo de variables de Java: class variable, instance variable, local variable,method parameter

//pattern
<Java_type> <name> ;

//for example
int myInt;
String myString;
CustomClass myCustomClass;

• field- miembro variable o miembro de datos. Es un variableinterior de un class( class variableo instance variable)

• attribute- en algunos artículos puedes encontrar que attributees una objectrepresentación de class variable. Objectopera por el attributescual define un conjunto de características.

CustomClass myCustomClass = new CustomClass();
myCustomClass.something = "poor fantasy"; //something is an attribute of myCustomClass object with a "poor fantasy" value

• property- field+ acotado getter/setter. Tiene una sintaxis de campo pero utiliza métodos bajo el capó. Javano lo soporta en forma pura. Echar un vistazo a Objective-C, Swift,Kotlin

Por ejemplo Kotlinmuestra:

//field - Backing Field
class Person {
    var name: String = "default name"
        get() = field
        set(value) { field = value }
}

//using
val person = Person()
person.name = "Alex"    // setter is used
println(person.name)    // getter is used

[Variable rápida, propiedad]