Declaración y Tipos de Variables en Java

Basico

La siguiente manera es como se declara una variable en Java. También veremos los tipos de variables: locales, de instancia y estáticas; con ejemplos.

1. ¿Qué es una Variable?

Una variable es el nombre dado a una ubicación de memoria. Es la unidad básica de almacenamiento en un programa. El valor almacenado en una variable se puede cambiar durante la ejecución del programa.

En Java, todas las variables deben declararse antes de que puedan ser utilizadas.

El valor almacenado puede cambiarse (variar) a medida que el programa ejecuta sus instrucciones, de ahí el término “variable“.

2. ¿Cómo declarar variables?

Podemos declarar las variables en Java de la siguiente manera:

Cómo declarar variables Java
Cómo declarar variables en Java
  • tipo de dato: tipo de datos que se pueden almacenar en esta variable.
  • nombre_variable: nombre dado a la variable.
  • valor: es el valor inicial almacenado en la variable.

Ejemplos:

float simpleInterest; //Declarando variable float
int time = 10, speed = 20; //Declarando e Inicializando la variable integer
char var = 'h'; // Declarando e Inicializando la variable character

Por ejemplo, el tipo de dato String se puede especificar para permitir que una variable llamada “mensaje” contenga texto con esta declaración:

String mensaje;
class PrimeraVariable
{
public static void main ( String[] args ) { 
   String mensaje = "Valor inicial";
   System.out.println(mensaje);
   mensaje = "Valor modificado" ;
   System.out.println(mensaje);
 }
}

Salida:

Valor inicial
Valor modificado

Los nombres de variables también deben evitar las palabras clave de Java, ya que tienen un significado especial en el lenguaje Java.

3. Tipos de variables

Hay tres tipos de variables en Java:

  • Variables locales
  • Variables de instancia
  • Variables estáticas

Ahora aprendamos sobre cada una de estas variables en detalle.

3.1. Variables locales

Una variable definida dentro de un bloque, método o constructor se llama variable local.

  • Estas variables se crean cuando el bloque ingresado o método se llama y destruye después de salir del bloque o cuando la llamada regresa del método.
  • El alcance de estas variables solo existe dentro del bloque en el que se declara la variable, es decir, podemos acceder a estas variables solo dentro de ese bloque.

Ejemplo 1:

public class StudentDetails
{
    public void StudentAge() 
    {   //variable local age
        int age = 0;
        age = age + 5;
        System.out.println("La edad del estudiante es : " + age);
    }
 
    public static void main(String args[])
    {
        StudentDetails obj = new StudentDetails();
        obj.StudentAge();
    }
}

Salida:

La edad del estudiante es : 5

En el programa anterior, la variable age (edad) es una variable local para el método StudentAge(). Si usamos la variable age fuera del método StudentAge(), el compilador producirá un error como se muestra a continuación en el programa.

Ejemplo 2:

public class StudentDetails
{
    public void StudentAge() 
    {   //variable local age
        int age = 0;
        age = age + 5;
    }
 
    public static void main(String args[]) 
    {   
        //utilizando la variable local age fuera de su alcance
        System.out.println("La edad del estudiante es : " + age);
    }

Salida:

error: cannot find symbol
 " + age);

3.2. Variables de instancia

Las variables de instancia son variables no estáticas y se declaran en una clase fuera de cualquier método, constructor o bloque.

  • Como las variables de instancia se declaran en una clase, estas variables se crean cuando un objeto de la clase se crea y se destruye cuando se destruye el objeto.
  • A diferencia de las variables locales, podemos usar especificadores de acceso para variables de instancia. Si no especificamos ningún especificador de acceso, se utilizará el especificador de acceso predeterminado.

Ejemplo:

import java.io.*;
class Points
{   
    //Estas variables son variables de instancia.
    //Estas variables están en una clase y no están dentro de ninguna función/método
    int engPoints;
    int mathsPoints;
    int phyPoints;
}
 
class PointsDemo
{
    public static void main(String args[])
    {   //primer objeto
        Points obj1 = new Points();
        obj1.engPoints = 50;
        obj1.mathsPoints = 80;
        obj1.phyPoints = 90;
 
        //segundo objeto
        Points obj2 = new Points();
        obj2.engPoints = 80;
        obj2.mathsPoints = 60;
        obj2.phyPoints = 85;
 
        //mostrando puntos para el primer objeto
        System.out.println("Puntos para el primer objeto:");
        System.out.println(obj1.engPoints);
        System.out.println(obj1.mathsPoints);
        System.out.println(obj1.phyPoints);
     
        //mostrando puntos para el segundo objeto
        System.out.println("Puntos para el segundo objeto:");
        System.out.println(obj2.engPoints);
        System.out.println(obj2.mathsPoints);
        System.out.println(obj2.phyPoints);
    }
}

Salida:

Puntos para el primer objeto:
50
80
90
Puntos para el segundo objeto:
80
60
85

Como puede ver en el programa anterior, las variables engPoints, mathsPoints, phyPoints; son variables de instancia. En caso de que tengamos varios objetos como en el programa anterior, cada objeto tendrá sus propias copias de variables de instancia. Del resultado anterior se desprende que cada objeto tendrá su propia copia de la variable de instancia.

3.3. Variables estáticas

Las variables estáticas también se conocen como variables de clase. 

  • Estas variables se declaran de forma similar a las variables de instancia, la diferencia es que las variables estáticas se declaran utilizando la palabra clave static dentro de una clase fuera de cualquier constructor o bloque de métodos.
  • A diferencia de las variables de instancia, solo podemos tener una copia de una variable estática por clase, independientemente de cuántos objetos creemos.
  • Las variables estáticas se crean al inicio de la ejecución del programa y se destruyen automáticamente cuando finaliza la ejecución.

Para acceder a variables estáticas, no necesitamos crear ningún objeto de esa clase, simplemente podemos acceder a la variable como:

nombre_clase.nombre_variable;

Ejemplo:

import java.io.*;
class Emp {
 
   // salario como variable estatica
   public static double salary;
   public static String name = "Alex";
}
 
public class EmpDemo
{
     public static void main(String args[]) {
       
      //acceder a la variable estatica sin objeto      
      Emp.salary = 1000;
      System.out.println(Emp.name + " tiene un salario promedio de: " + Emp.salary);
   }
     
}

Salida:

Alex tiene un salario promedio de: 1000.0

4. Variable de instancia vs Variable estática

  • Cada objeto tendrá su propia copia de la variable de instancia, mientras que solo podemos tener una copia de una variable estática por clase, independientemente de cuántos objetos creemos.
  • Los cambios realizados en una variable de instancia utilizando un objeto no se reflejarán en otros objetos, ya que cada objeto tiene su propia copia de la variable de instancia. En caso de estática, los cambios se reflejarán en otros objetos ya que las variables estáticas son comunes a todos los objetos de una clase.
  • Podemos acceder a variables de instancia a través de referencias de objetos y se puede acceder directamente a las variables estáticas usando el nombre de clase.

En resumen, la sintaxis para variables estáticas y de instancia es:

class Example
    {
        static int a; //variable estatica
        int b;        //variable de instancia
    }

5. Creando constantes

La palabra clave “final” es un modificador que se puede usar al declarar variables para evitar cualquier cambio posterior en los valores que inicialmente se les asignaron.

Esto es útil cuando se almacena un valor fijo en un programa para evitar que se altere accidentalmente.

Las variables creadas para almacenar valores fijos de esta manera se conocen como “constantes“, y es convencional nombrar constantes con todos los caracteres en mayúsculas, para distinguirlas de las variables regulares. Los programas que intentan cambiar un valor constante no se compilarán, y el compilador javac generará un mensaje de error.

Ejemplo:

class Constants
{
public static void main ( String[] args ) { 
   //inicializamos tres constantes enteras
   final int CONSTANTE1 = 6 ;
   final int CONSTANTE2 = 1 ;
   final int CONSTANTE3 = 3 ;

   //declaramos variables regulares del tipo int
   int td,pat,fg,total;

   //Inicializamos las variables regulares
   td = 4*CONSTANTE1;
   pat = 3*CONSTANTE2;
   fg = 2*CONSTANTE3; 

  total = (td+pat+fg) ;

  System.out.println("Resultado: " + total);
  }
}

Salida:

Resultado: 33
Nota: El carácter * significa una multiplicación. No se preocupe de momento, a continuación, en este enlace, conocerá todos los Operadores en Java.
Declaración de Variables Java
  • 10/10
    Tipos de Variable - 10/10

Sobre el Autor:

Hey hola! Yo soy Alex Walton y tengo el placer de compartir conocimientos hacía ti sobre el tema de Programación en Java, desde cero, Online y Gratis.

2 comentarios

  1. […] tipos de datos utilizados con más frecuencia en las declaraciones de variables Java se enumeran en la siguiente tabla, junto con una breve […]

  2. María José

    Excelente la explicación sobre las variables. He quedado conforme y clarificado vagas dudas. Agradecida.

Deja una Respuesta

*

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.