Variables Java

En este artículo, vamos a explicar a todos los estudiantes de Java qué son las variables de Java y cómo trabajar con ellas.

¿Qué es la variable Java?

Una variable en Java se puede considerar como una caja. Esta "caja" tiene un tamaño determinado: la memoria que se le asigna. La cantidad de memoria que se asignará depende del tipo de variable, pero hablaremos de esto un poco más adelante. Al mismo tiempo, el tamaño de la caja en sí no se puede cambiar después de su creación, pero sí el contenido. La caja puede estar vacía. Puede "insertar" algún valor en él y luego extraer y poner algún otro valor. Así, una variable es un campo que almacena valores de datos durante la ejecución de un programa Java. Esta caja tiene características importantes:

siempre puede contener un solo valor (o puede estar vacío, en cuyo caso contendrá el valor predeterminado),
Tiene un tipo de datos. Su tamaño depende del tipo de datos, así como de qué área particular de la memoria se le asigna el lugar (dónde se encuentra).

Cómo declarar variables

Para declarar variables en Java, debe especificar su tipo y nombre. Aquí hay un ejemplo de cómo declarar tres variables:

int myInt;
String s;
Object variableName;

Aquí int , String y Object son el tipo de datos y myInt , s , variableName son nombres de variables. El tipo de datos debe elegirse en función de las necesidades del programa, y es mejor elegir un nombre para que quede claro de qué se trata. Por supuesto, para los principiantes no es tan estricto, pero en proyectos grandes, los nombres de variables como 's' pueden afectar la legibilidad del código. Por lo tanto, es mejor acostumbrarse a nombrar las variables de una manera que deje claro para qué sirven desde el principio. Dentro de lo razonable, por supuesto.

Cómo inicializar variables

Cuando declaras una variable, le asignas memoria. La inicialización significa que "pones" un cierto valor en la "caja". Esto se puede hacer inmediatamente durante la declaración de la variable o más tarde. Además, el valor de una variable puede cambiar durante la ejecución del programa. Ejemplo:

public class VariableTest {
    public static void main(String[] args) {
        int myInt = 5;
        String s;
        s = "init";
        System.out.println(s);
        s = s+5;
        System.out.println(s);
    }
}

Aquí declaramos e inicializamos la variable myInt en una línea, asignamos inmediatamente memoria para ella (32 bits para cada número int), le dimos un nombre y luego colocamos el valor 5 en la memoria asignada. Luego declaramos que estábamos asignando espacio de memoria para la cadena s , y ya un comando separado le puso el valor "init". Después de eso, imprimimos la cadena y cambiamos el valor de la variable s . En este programa, imprimimos las líneas y, si lo ejecuta, verá el siguiente resultado:

init init5

Tipos de datos de variables en Java: primitivos y no primitivos

Los tipos de datos de las variables en Java se dividen en dos grupos:

Los tipos de datos primitivos incluyen byte , short , int , long , float , double , boolean y char
Tipos de datos no primitivos como String , Arrays y Classes

Aquí hay un ejemplo de trabajo con variables:

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point number
       char myLetter = 'a';         // character
       boolean myBool = true;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

int , char , boolean y float son primitivos. String no es primitivo. ¿ Qué pasa con la variable myStudent ? Este es un objeto de la clase Student creada por el usuario . Fue creado simplemente para ilustrar el trabajo con variables no primitivas. Son la mayoría en Java, ya que casi todo en este lenguaje de programación es un objeto. Para su comprensión, aquí está el código de la clase Student :

import java.util.Date;

public class Student {
   String surname;
   String name;
   String secondName;
   Long birthday; // Long instead of long is used by Gson/Jackson json parsers and various orm databases

   public Student(String surname, String name, String secondName, Date birthday ){
       this.surname = surname;
       this.name = name;
       this.secondName = secondName;
       this.birthday = birthday == null ? 0 : birthday.getTime();
   }

   @Override
   public int hashCode(){
       //TODO: check for nulls
       //return surname.hashCode() ^ name.hashCode() ^ secondName.hashCode() ^ (birthday.hashCode());
       return (surname + name + secondName + birthday).hashCode();
   }
   @Override
   public boolean equals(Object other_) {
       Student other = (Student)other_;
       return (surname == null || surname.equals(other.surname) )
               && (name == null || name.equals(other.name))
               && (secondName == null || secondName.equals(other.secondName))
               && (birthday == null || birthday.equals(other.birthday));
   }
}

Tipos de variables en Java: locales, de instancia y estáticas

Hay tres tipos diferentes de variables en Java, las hemos enumerado de la siguiente manera:

Variables locales
Variables de instancia
Variables estáticas

Variables locales

Una variable declarada dentro del cuerpo del método se denomina variable local. Además, las variables locales se declaran dentro de constructores y bloques. Puede usar variables locales solo dentro de ese método, constructor o bloque donde se crearon y los otros métodos en la clase ni siquiera saben que la variable existe. Por lo tanto, las variables locales se crean cuando se ingresa el método, el constructor o el bloque y la variable se destruye una vez que el método, el constructor o el bloque no funcionan. Una variable local no se puede definir con la palabra clave estática . Aún más: no puede usar modificadores de acceso para variables locales. Aquí hay un ejemplo:

public class VariableTest {
   public static void main(String[] args) {
       System.out.println(myMethod("C plus "));
   }
           private static String myMethod(String myString) {
       String myOtherString = "plus";
       return myString + myOtherString;
   }
}

Aquí myOtherString es una variable local. No puede usarlo desde el otro método, pero myMethod . Las variables locales no pueden tener valores predeterminados. Si al menos una variable local no se inicializa en el programa, el programa no funcionará correctamente. Hagamos un pequeño cambio en uno de los ejemplos anteriores y "olvidémonos" de inicializar la variable myBool :

public class VariableTest {
   public static void main(String[] args) {

       int myInt = - 5;               // integer (whole number)
       float myFloat = 2.718281828459045f;    // Floating point
       char myLetter = 'a';         // character
       boolean myBool;       // boolean
       String myText = "Hero";     // String
       System.out.println(myInt + " " +
               myFloat +" " + myLetter + " " +  myBool + " " + myText);
       Student myStudent = new Student("Walker","Johnny", "Kyle", null);

   }
}

Si intentamos ejecutar el programa, arrojará un error:

Error: (10, 50) java: es posible que la variable myBool no se haya inicializado

Variables de instancia

Una variable declarada dentro de la clase pero fuera del cuerpo de cualquier método, constructor o bloque se denomina variable de instancia. Las variables de instancia se crean cuando se crea un objeto utilizando la nueva palabra clave. Se destruye cuando se destruye el objeto. No se puede declarar como estático, pero puede usar modificadores de acceso para las variables de instancia. Las variables de instancia son visibles para todos los métodos, constructores y bloques de la clase. Por lo general, las variables de instancia son privadas, pero puede cambiar la visibilidad de las subclases. Las variables de instancia, a diferencia de las variables locales, tienen valores predeterminados. Para todos los tipos de números primitivos, el valor predeterminado es 0, para los valores booleanos es falso y para las referencias a objetos es nulo. Los valores se pueden asignar durante la declaración o dentro del constructor. Aquí hay un ejemplo:

//instance variable example
public class Employee {

   // here we have a public instance variable. It is visible for this class and child classes
   public String name;

   //this instance variable is private so it’s visible for the Employee class only. You can use setters and getters to get it
   private double salary;

   public Employee (String empName) {
       name = empName;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public double getSalary() {
       return salary;
   }

   public void setSalary(double employeeSalary) {
       salary = employeeSalary;
   }

   public static void main(String args[]) {
       Employee employee = new Employee("Johnny");
       employee.setSalary(1500);
       System.out.println("name = " + employee.getName());
       System.out.println("salary = " + employee.getSalary());
   }
}

Variables estáticas

Una variable que se declara como estática se denomina variable estática. Java le ofrece declarar dichas variables fuera de un método, constructor o bloque. No puede ser local, pertenecen a clase, no a instancias. Eso significa que una sola copia de una variable estática una vez creada y compartida entre todas las instancias de la clase. La asignación de memoria para variables estáticas ocurre solo una vez cuando la clase se carga en la memoria. Pueden tener cualquier visibilidad, pero normalmente se declaran como públicos. También tienen valores predeterminados, como variables de instancia.

public class Box
{
   public void add(int data)
   {
       Storage.sum = Storage.sum + data;
       Storage.count++;
   }

   public void remove(int data)
   {
       Storage.sum = Storage.sum - data;
       Storage.count--;
   }
}

public class Storage
{
   public static int count = 0;
   public static int sum = 0;
}

En el ejemplo anterior, creamos una clase de almacenamiento separada , movimos las variables de conteo y suma a ella y las declaramos estáticas. Se puede acceder a las variables estáticas públicas desde cualquier método del programa (y no solo desde un método). Para reforzar lo que aprendió, le sugerimos que vea una lección en video de nuestro Curso de Java