Tipos de variables en Java

En el lenguaje Java, todas las variables deben declararse antes de usarse.

El formato básico para declarar una variable es el siguiente:

type identifier [ = value][, identifier [= value] ...] ;

Explicación del formato:

  • type -- tipo de dato.
  • identifier -- es el nombre de la variable, se pueden declarar múltiples variables del mismo tipo separadas por comas,.

A continuación se enumeran algunos ejemplos de declaración de variables. Observa que algunos incluyen el proceso de inicialización.

int a, b, c;         //Declarar tres enteros de tipo int: a, b, c int d = 3, e = 4, f = 5; //Declarar tres enteros y asignarles un valor inicial byte z = 22;         //Declarar e inicializar z String s = "ejemplo"; //Declarar e inicializar la cadena s double pi = 3.14159; //Declarar la variable de punto flotante de doble precisión pi char x = 'x';        //Declarar que el valor de la variable x es el carácter 'x'.

Los tipos de variables admitidos por el lenguaje Java son:

  • Variables locales (Local Variables):Las variables locales se declaran dentro de métodos, constructores o bloques. Se destruyen después de que el método, constructor o bloque donde se declararon termina de ejecutarse. Las variables locales deben inicializarse al declararse; de lo contrario, se producirá un error de compilación.

    public void exampleMethod() {
    int localVar = 10; // 局部变量
    // ...
}

  • Variables de instancia (Instance Variables):Las variables de instancia se declaran dentro de la clase, pero fuera de métodos, constructores o bloques. Pertenecen a la instancia de la clase, y cada instancia de la clase tiene su propia copia. Si no se inicializan explícitamente, las variables de instancia reciben un valor predeterminado (0 para tipos numéricos, false para boolean, null para referencias a objetos).

    public class ExampleClass {
    int instanceVar; // 实例变量
}

  • Variables estáticas o variables de clase (Class Variables):Las variables de clase son variables declaradas con la palabra clave static dentro de la clase. Pertenecen a la clase y no a las instancias. Todas las instancias de la clase comparten el mismo valor de la variable de clase. Las variables de clase se inicializan cuando la clase se carga, y solo se inicializan una vez.

    public class ExampleClass {
    static int classVar; // 类变量
}

  • Variables de parámetro (Parameters):Los parámetros son variables declaradas en métodos o constructores, utilizadas para recibir los valores que se pasan al invocar dicho método o constructor. El ámbito de las variables de parámetro se limita al interior del método.

    public void exampleMethod(int parameterVar) {
    // 参数变量
    // ...
}

En el siguiente ejemplo se define una clase EjemploTest, que incluye una variable miembro instanceVar y una variable estática staticVar.

En el método method() se define una variable de parámetro paramVar y una variable local localVar. Dentro del método, asignamos el valor de la variable local a la variable miembro, asignamos el valor de la variable de parámetro a la variable estática y luego imprimimos los valores de estas variables.

En el método main(), creamos un objeto EjemploTest y llamamos a su método method().

Ejemplo

public class EjemploTest { //Variable miembro private int instanceVar; //Variable estática private static int staticVar; public void method(int paramVar) { //Variable local int localVar = 10; //Uso de variables instanceVar = localVar; staticVar = paramVar; System.out.println("Variable miembro:" + instanceVar); System.out.println("Variable estática:" + staticVar); System.out.println("Variable de parámetro:" + paramVar); System.out.println("Variable local:" + localVar); } public static void main(String[] args) { EjemploTest v = new EjemploTest(); v.method(20); } }

Al ejecutar el código anterior, la salida es la siguiente:

成员变量: 10
静态变量: 20
参数变量: 20
局部变量: 10

Variables de parámetro en Java

Las variables de parámetro en Java son variables declaradas en métodos o constructores, utilizadas para recibir los valores que se pasan al método o constructor. Las variables de parámetro son similares a las variables locales, pero solo existen cuando se invoca el método o constructor y solo pueden usarse dentro del método o constructor.

La sintaxis de declaración de un método en Java es la siguiente:

accessModifier returnType methodName(parameterType parameterName1, parameterType parameterName2, ...) {
    // 方法体
}
  • parameterType -- representa el tipo de la variable de parámetro.
  • parameterName -- representa el nombre de la variable de parámetro.

Al invocar un método, debemos pasar valores para las variables de parámetro. Estos valores pueden ser constantes, variables o expresiones.

Hay dos formas de pasar los valores de las variables de parámetro en los métodos:Paso por valoryPaso por referencia。

  • Paso por valor:Durante la invocación del método, se pasa una copia del valor del argumento real. Cuando a la variable de parámetro se le asigna un nuevo valor, solo se modifica el valor de la copia, sin afectar el valor original. Los tipos de datos básicos en Java utilizan el paso por valor para transmitir los valores de las variables de parámetro.

  • Paso por referencia:Durante la invocación del método, se pasa la referencia (es decir, la dirección de memoria) del argumento real. Cuando a la variable de parámetro se le asigna un nuevo valor, se modifica el contenido del valor original. Los tipos de objeto en Java utilizan el paso por referencia para transmitir los valores de las variables de parámetro.

El siguiente es un ejemplo sencillo que muestra el uso de las variables de parámetro en un método:

Ejemplo

public class EjemploTest {
    public static void main(String[] args) {
        int a = 10, b = 20;
        swap(a, b); // llamar al método swap
        System.out.println("a = " + a + ", b = " + b); // mostrar los valores de a y b
    }
   
    public static void swap(int x, int y) {
        int temp = x;
        x = y;
        y = temp;
    }
}

Al ejecutar el código anterior, la salida es la siguiente:

a = 10, b = 20

Variables locales en Java

Las variables locales en Java son variables declaradas dentro de métodos, constructores o bloques de sentencias. Su ámbito se limita al bloque de código donde se declaran.

La sintaxis para declarar una variable local es:

type variableName;
  • type -- representa el tipo de la variable.
  • variableName -- representa el nombre de la variable.

Explicación:

  • Ámbito: El ámbito de una variable local se limita al método, constructor o bloque de código donde se declara. Una vez que el flujo de ejecución del código sale de este ámbito, la variable local ya no es accesible.

  • Ciclo de vida: El ciclo de vida de una variable local comienza en el momento de su declaración y finaliza cuando el método, constructor o bloque de código termina su ejecución. Después, la variable local será recolectada como basura.

  • Inicialización: Las variables locales deben inicializarse antes de usarse. Si no se inicializan, el compilador mostrará un error, porque Java no proporciona valores predeterminados para las variables locales.

  • Declaración: La declaración de una variable local debe realizarse al comienzo del método o bloque de código. Al declararla se puede especificar el tipo de dato, seguido del nombre de la variable, por ejemplo:int count;。

  • Asignación: Una variable local debe ser asignada después de su declaración para poder usarse dentro del método. La asignación puede ser directa o mediante una llamada a método o una expresión.

  • Restricciones: Las variables locales no pueden ser accedidas directamente por otros métodos de la clase; son privadas del método o bloque de código donde se declaran.

  • Gestión de memoria: Las variables locales se almacenan en la pila de la máquina virtual de Java (JVM), a diferencia de las variables de instancia u objetos que se almacenan en el montón.

  • Recolección de basura: Dado que el ciclo de vida de las variables locales está estrictamente limitado a la ejecución del método o bloque de código, dejan de ser referenciadas una vez que el método o bloque termina, por lo que el recolector de basura de la JVM recupera automáticamente la memoria que ocupan.

  • Reutilización: El nombre de una variable local puede reutilizarse en diferentes métodos o bloques de código, porque su ámbito es local y no causa conflictos de nombres.

  • Parámetros y valores de retorno: Los parámetros de un método pueden considerarse un tipo especial de variable local. Se inicializan cuando el método es invocado y su ciclo de vida termina cuando el método retorna.

Ejemplo

El siguiente es un ejemplo sencillo que muestra el uso de variables locales:

Ejemplo

public class LocalVariablesExample {
    public static void main(String[] args) {
        int a = 10; // declaración e inicialización de la variable local a
        int b;     // declaración de la variable local b
        b = 20;    // inicialización de la variable local b
       
        System.out.println("a = " + a);
        System.out.println("b = " + b);
       
        // Si no se inicializa la variable local antes de usarla, el compilador mostrará un error
        // int c;
        // System.out.println("c = " + c);
    }
}

En el ejemplo anterior declaramos e inicializamos dos variables locales a y b, y luego imprimimos sus valores. Ten en cuenta que si no inicializas una variable local antes de usarla, el compilador mostrará un error.

En el siguiente ejemplo, age es una variable local definida en el método pupAge(). Su ámbito se limita a este método:

package com.ejemplo.test; public class Test{ public void pupAge(){ int age = 0; age = age + 7; System.out.println("La edad del perrito es:" + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

El resultado de compilar y ejecutar el ejemplo anterior es:

小狗的年龄是: 7

En el siguiente ejemplo, la variable age no está inicializada, por lo que se produce un error en la compilación:

package com.ejemplo.test; public class Test{ public void pupAge(){ int age; age = age + 7; System.out.println("La edad del perrito es:" + age); } public static void main(String[] args){ Test test = new Test(); test.pupAge(); } }

El resultado de compilar y ejecutar el ejemplo anterior es:

Test.java:4:variable number might not have been initialized
age = age + 7;
         ^
1 error

Variables miembro (variables de instancia)

  • Las variables miembro se declaran dentro de una clase, pero fuera de métodos, constructores y bloques de sentencias.
  • Cuando un objeto es instanciado, el valor de cada variable miembro queda determinado.
  • Las variables miembro se crean cuando se crea el objeto y se destruyen cuando el objeto se destruye.
  • El valor de una variable miembro debe ser referenciado por al menos un método, constructor o bloque de sentencias, de modo que el exterior pueda obtener la información de la variable de instancia a través de estos medios.
  • Las variables miembro pueden declararse antes o después de su uso.
  • Los modificadores de acceso pueden modificar las variables miembro.
  • Las variables miembro son visibles para los métodos, constructores o bloques de sentencias de la clase. En general, las variables miembro deben declararse privadas. Mediante el uso de modificadores de acceso, las variables miembro pueden hacerse visibles para las subclases.
  • Las variables miembro tienen valores predeterminados. El valor predeterminado de las variables numéricas es 0, el de las variables booleanas es false y el de las variables de tipo referencia es null. El valor de la variable puede especificarse en la declaración o en el constructor.
  • Las variables miembro pueden accederse directamente mediante el nombre de la variable. Sin embargo, en métodos estáticos y en otras clases, se debe usar el nombre completamente calificado:ObjectReference.VariableName。

La sintaxis de declaración de una variable miembro es:

accessModifier type variableName;
  • accessModifier -- indica el modificador de acceso, que puede ser public, protected, private o el nivel de acceso predeterminado (es decir, sin especificar explícitamente un modificador de acceso).
  • type -- indica el tipo de la variable.
  • variableName -- indica el nombre de la variable.

A diferencia de las variables locales, el valor de las variables miembro se asigna cuando se crea el objeto; incluso si no se inicializan, se les asigna un valor predeterminado, por ejemplo, las variables de tipo int tienen un valor predeterminado de 0 y las variables de tipo boolean tienen un valor predeterminado de false.

Las variables miembro pueden accederse mediante el objeto, o mediante el nombre de la clase (si son variables miembro estáticas). Si las variables miembro no se inicializan explícitamente, se les asignará un valor predeterminado. Pueden inicializarse en el constructor u otros métodos, o accediendo a ellas mediante el objeto o el nombre de la clase y estableciendo sus valores.

Ejemplo

En el siguiente ejemplo declaramos dos variables miembro a y b, y las accedemos y establecemos. Observe que podemos acceder a las variables miembro a través del objeto, y también a las variables miembro estáticas a través del nombre de la clase.

Ejemplo

public class EjemploTest {
      private int a; // Variable miembro privada a
      public String b = "Hello"; // Variable miembro pública b
     
      public static void main(String[] args) {
         EjemploTest obj = new EjemploTest(); // Crear objeto
         
          obj.a = 10; // Acceder a la variable miembro a y establecer su valor en 10
          System.out.println("a = " + obj.a);
         
          obj.b = "World"; // Acceder a la variable miembro b y establecer su valor en "World"
          System.out.println("b = " + obj.b);
      }
  }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

a = 10
b = World

En el siguiente ejemplo declaramos dos variables miembro name y salary, y las accedemos y establecemos.

Código del archivo Employee.java:

import java.io.*; public class Employee{ //Esta variable miembro es visible para las subclases public String name; //Variable privada, visible solo en esta clase private double salary; //Asignar valor a name en el constructor public Employee (String empName){ name = empName; } //Establecer el valor de salary public void setSalary(double empSal){ salary = empSal; } //Imprimir información public void printEmp(){ System.out.println("Nombre :" + name ); System.out.println("Salario :" + salary); } public static void main(String[] args){ Employee empOne = new Employee("EJEMPLO"); empOne.setSalary(1000.0); empOne.printEmp(); } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

$ javac Employee.java 
$ java Employee
名字 : EJEMPLO
薪水 : 1000.0

Variables de clase (variables estáticas)

Una variable estática en Java es una variable definida en la clase, que está relacionada con la clase y no con la instancia. Es decir, sin importar cuántas instancias de la clase se creen, la variable estática solo tiene una copia en memoria, compartida por todas las instancias.

Las variables estáticas se crean cuando se carga la clase y existen durante toda la ejecución del programa.

Forma de definición

La forma de definir una variable estática es usar en la clasestaticla palabra clave para modificar la variable, que generalmente también se denomina variable de clase.

En el siguiente ejemplo definimos una variable estáticacount, cuyo valor inicial es 0:

Ejemplo

public class MyClass {
    public static int count = 0;
    // Otras variables miembro y métodos
}

Forma de acceso

Dado que las variables estáticas están relacionadas con la clase, se puede acceder a ellas mediante el nombre de la clase, y también mediante el nombre de la instancia.

Ejemplo

MyClass.count = 10; // Acceder mediante el nombre de la clase
MyClass obj = new MyClass();
obj.count = 20; // Acceder mediante el nombre de la instancia

Ciclo de vida

El ciclo de vida de las variables estáticas es tan largo como el ciclo de vida del programa. Es decir, se crean cuando se carga la clase y existen durante toda la ejecución del programa, y no se destruyen hasta que el programa termina. Por lo tanto, las variables estáticas pueden usarse para almacenar datos que todo el programa necesita usar, como información de configuración, variables globales, etc.

Momento de inicialización

Las variables estáticas se inicializan cuando se carga la clase, y su orden de inicialización está relacionado con el orden de definición.

Si una variable estática depende de otra variable estática, debe definirse después de esta.

Ejemplo

public class MyClass {
    public static int count1 = 0;
    public static int count2 = count1 + 1;
    // Otras variables miembro y métodos
}

En el ejemplo anterior, count1 debe inicializarse antes que count2; de lo contrario, se producirá un error en tiempo de compilación.

Diferencia entre constantes y variables estáticas

Las constantes también están relacionadas con la clase, pero son variables modificadas con la palabra clave final; una vez que se les asigna un valor, no se pueden modificar. A diferencia de las variables estáticas, el valor de una constante ya se determina en tiempo de compilación, mientras que el valor de una variable estática puede cambiarse en tiempo de ejecución. Además, las constantes se usan generalmente para almacenar valores fijos, como constantes matemáticas, información de configuración, etc., mientras que las variables estáticas se usan generalmente para almacenar datos variables, como contadores, estado global, etc.

En resumen, las variables estáticas son variables relacionadas con la clase, tienen unicidad y compartición, y pueden usarse para almacenar datos que todo el programa necesita usar, pero se debe prestar atención al momento de inicialización y a la diferencia con las constantes.

Modificadores de acceso de las variables estáticas

Los modificadores de acceso de las variables estáticas pueden ser public, protected, private o el modificador de acceso predeterminado (es decir, no escribir ningún modificador de acceso).

Cabe señalar que la visibilidad de las variables estáticas es diferente de la de las variables de instancia, porque las variables estáticas están relacionadas con la clase y no dependen de ninguna instancia.

Seguridad de hilos de las variables estáticas

En Java, las variables estáticas pertenecen a la clase, no a las instancias de objetos. Por lo tanto, cuando varios hilos acceden simultáneamente a una clase que contiene variables estáticas, es necesario considerar su seguridad de hilos.

Las variables estáticas solo tienen una copia en memoria, compartida por todas las instancias. Por lo tanto, si un hilo modifica el valor de una variable estática, otros hilos también verán el valor modificado al acceder a dicha variable estática. Esto puede provocar problemas de acceso concurrente, porque varios hilos pueden modificar la variable estática al mismo tiempo, dando lugar a resultados indeterminados o problemas de consistencia de datos.

Para garantizar la seguridad de hilos de las variables estáticas, es necesario adoptar medidas de sincronización adecuadas, como mecanismos de sincronización, clases atómicas o la palabra clave volatile, para leer y modificar correctamente el valor de las variables estáticas en entornos multihilo.

Convención de nombres de las variables estáticas

La convención de nomenclatura para las variables estáticas (también llamadas variables de clase) generalmente sigue el estilo camelCase, y a menudo se usan letras mayúsculas con palabras separadas por guiones bajos, y se deben identificar explícitamente con la palabra clave static.

  • Usar notación camelCase:La nomenclatura de las variables estáticas debe usar notación camelCase, es decir, la primera letra en minúscula y la primera letra de cada palabra posterior en mayúscula. Por ejemplo:myStaticVariable。

  • Todo en mayúsculas:Las variables estáticas suelen usar letras mayúsculas, con palabras separadas por guiones bajos. Esto se conoce como "Upper Snake Case". Por ejemplo:MY_STATIC_VARIABLE。

  • Descriptivo:El nombre de la variable debe ser significativo y expresar claramente el propósito de la variable. Evite usar caracteres individuales o abreviaturas sin un significado claro.

  • Evitar abreviaturas:Trate de evitar abreviaturas para mejorar la legibilidad del código. Si es necesario usar abreviaturas, asegúrese de que sean ampliamente comprendidas y explíquelas en los comentarios.

Ejemplo

public class MyClass {
    // Usar notación camelCase
    public static int myStaticVariable;

    // Usar Upper Snake Case
    public static final int MAX_SIZE = 100;

    // Evitar abreviaturas
    public static final String employeeName;

    // Nombre de variable descriptivo
    public static double defaultInterestRate;
}

Escenarios de uso de las variables estáticas

Las variables estáticas se usan generalmente en los siguientes escenarios:

  • Almacenar estado global o información de configuración
  • Contadores o información estadística
  • Datos en caché o recursos compartidos
  • Constantes o métodos de clases de utilidades
  • Variable de instancia en el patrón singleton

Ejemplo

El siguiente ejemplo define una clase AppConfig que contiene tres variables estáticas APP_NAME, APP_VERSION y DATABASE_URL, utilizadas para almacenar el nombre, la versión y la URL de conexión a la base de datos de la aplicación. Estas variables se declaran como final, lo que indica que son constantes inmutables.

En el método main(), imprimimos los valores de estas variables estáticas.

Código del archivo AppConfig.java:

public class AppConfig { public static final String APP_NAME = "MyApp"; public static final String APP_VERSION = "1.0.0"; public static final String DATABASE_URL = "jdbc:mysql://localhost:3306/mydb"; public static void main(String[] args) { System.out.println("Application name: " + AppConfig.APP_NAME); System.out.println("Application version: " + AppConfig.APP_VERSION); System.out.println("Database URL: " + AppConfig.DATABASE_URL); } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

Application name: MyApp
Application version: 1.0.0
Database URL: jdbc:mysql://localhost:3306/mydb

Se puede observar que la información de configuración global almacenada en estas variables estáticas puede usarse en todo el programa y no se modifica. Este ejemplo muestra otra aplicación común de las variables estáticas; a través de ellas podemos almacenar convenientemente información de configuración global o implementar otros datos que necesiten compartirse globalmente.

El siguiente ejemplo define una clase Counter que contiene una variable estática count, utilizada para registrar cuántos objetos Counter se han creado.

Cada vez que se crea un nuevo objeto, el constructor incrementa el contador en uno. El método estático getCount() se utiliza para obtener el valor actual del contador.

En el método main(), creamos tres objetos Counter e imprimimos el valor del contador.

Código del archivo Counter.java:

public class Counter { private static int count = 0; public Counter() { count++; } public static int getCount() { return count; } public static void main(String[] args) { Counter c1 = new Counter(); Counter c2 = new Counter(); Counter c3 = new Counter(); System.out.println("Número de objetos creados hasta ahora:" + Counter.getCount()); } }

El resultado de compilar y ejecutar el ejemplo anterior es el siguiente:

目前为止创建的对象数: 3

Puede verse que el contador registra que se han creado tres objetos. Este ejemplo muestra una aplicación sencilla de las variables estáticas; a través de ella podemos contar fácilmente el número de creaciones de objetos, o registrar otros datos que necesiten compartirse globalmente.

En este capítulo hemos aprendido los tipos de variables de Java. En el próximo capítulo presentaremos el uso de los modificadores de Java.

Otras extensiones