Las variables son una de las características fundamentales de los lenguajes de programación, permiten acceder a la memoria para almacenar y recuperar los datos con los que nuestros programas van a trabajar. Son por tanto el mecanismo que los lenguajes de programación ponen a nuestra disposición para acceder a la memoria.
Se trata de un mecanismo de lo más sencillo, sólo tenemos que dar un nombre a nuestras variables, a partir de ese momento el compilador traducirá de forma automática ese nombre en un acceso a memoria. Por ejemplo:
//Almacenamos un dato en memoria referenciado por el nombre edad
edad = 5;
//Recuperamos el dato almacenado y lo modificamos
edad = edad + 1;
Java es un lenguaje tipado y nos obliga a declarar nuestras variables antes de poder hacer uso de ellas, con esta declaración le indicamos al compilador el espacio en memoria que debe de reservar para almacenar la información. Por ejemplo:
Aquí estamos reservando memoria para una variable de tipo String y la identificamos con el nombre “cliente”. De ahora en adelante si en el programa hablamos de cliente, estamos haciendo referencia a esa porción de memoria y al valor que contiene.
Podemos asignarle algún valor en el momento de declarar una variable. Por ejemplo:
String cliente = "Isaac Newton";
Aquí reservamos memoria para una cadena de caracteres y le asignamos el valor "Isaac Newton". También podemos declararla y en otro lugar del programa fijarle un valor :
String cliente; // declaración
... // El programa sigue
cliente = "Isaac Newton"; // le damos un valor
La sentencia para declarar una variable se resume como:
Tipo_Dato Nombre_Variable [= Valor];
Definimos el tipo de dato, el nombre y opcionalmente su valor.
Para ver como se utilizan las variables, podemos modificar el primer programa. Agregaremos una variable que contenga el texto que se mostrará en pantalla:
{{Java/!|public}} {{Java/!|class}} HolaMundo {
{{Java/!|public}} {{Java/!|static}} {{Java/!|void}} main(String[] args){
String saludo = "¡Hola Mundo!";
System.out.println( saludo );
}
}
Definimos una variable de tipo String con el nombre "saludo". En la declaración de la variable también la inicializamos con el valor "¡Hola mundo!". Luego llamamos al método que imprimirá el texto en la pantalla haciendo referencia a la variable. En el programa original, explícitamente introducíamos el texto que se mostraría, ahora solo escribimos el nombre de la variable. Cuando el intérprete se encuentre con el nombre de esta variable, tendrá que buscar el valor que almacene en la memoria para mostrarlo por pantalla.
Un variable puede cambiar su valor en el transcurso del programa.
{{Java/!|public}} {{Java/!|class}} UsoVariables{
{{Java/!|public}} {{Java/!|static}} {{Java/!|void}} main(String args[]){
String saludo;
saludo = "Hola Mundo!";
System.out.println( saludo );
saludo = ("Estoy utilizando variables");
System.out.println( saludo );
}
}
Siempre debemos inicializar una variable. Al compilar el programa, el compilador de Java leerá el contenido de la variable y siempre verificará que tenga un valor. De lo contrario el programa no compilará y mostrará un error. Un ejemplo de este caso:
if (x > 0) {
saludo = "Hola Mundo!!!";
}
System.out.println( saludo );
En este caso el compilador mostrará un mensaje de error indicando que la variable x no se ha inicializado con ningún valor. Como se puede observar esta variable solo se inicia cuando se cumple una condición, sin embargo se indica que va a ser utilizada siempre. El compilador detecta este posible error. Un ejemplo de solución posible sería:
int x = 1;
if (x > 0) {
saludo = "Hola Mundo!";
}
System.out.println( saludo );
Agregando estas líneas al final del código de la clase UsoVariables nos mostraría lo siguiente a la salida:
Hola Mundo!
Estoy utilizando variables
Hola Mundo!!!
Nombre de la variable[editar]
El nombre debe ser único en el contexto del programa. Además debe seguir las siguientes reglas:
- No puede ser una palabra reservada del lenguaje o un literal booleano (true o false)
- Puede contener cualquier carácter Unicode, pero no puede comenzar con un número
- No debe contener los símbolos que se utilicen como operadores ( + , - , ?, etc )
- Por convención, los nombres de variables comienzan con una letra en minúscula. Si un nombre consiste en más de una palabra, se escribirá sin espacios entre ellas y cada palabra (salvo la primera) comenzará con una letra mayúscula (por ejemplo : estaBienEsteNombre )
Tipo de variable[editar]
Cada variable debe tener un tipo de dato predefinido. Esto determina el rango de valores que puede almacenar y qué operaciones se pueden realizar así como el resultado que te dará. Por ejemplo, una variable de tipo entero puede almacenar números sin decimales y puede realizar operaciones aritméticas, pero no puede contener palabras.
Existen dos categorías de variables: las de tipo primitivo y las referenciadas. Una variable de tipo primitivo accede al valor asignado directamente. Las referenciadas acceden a través de un puntero, es decir, no almacenan un valor sino una dirección de memoria. Estas últimas son utilizadas por las matrices, las clases y las interfaces.
Tipos de datos primitivos
| Tipo | Tamaño y formato | Rango |
|---|
| | enteros | |
| byte | 8 bits - complemento a 2 |  |
| short | 16 bits - complemento a 2 | - |
| int | 32 bits - complemento a 2 |  |
| long | 64 bits - complemento a 2 |  |
| | números reales | |
| float | 32 bits - IEEE 754 | |
| double | 64 bits - IEEE 754 | |
| | otros | |
| char | 16 bits - caracteres UNICODE | '\u0000' al '\uffff' |
| boolean | 1 bit | true o false |
En otros lenguajes de programación, el formato o el tamaño de los tipos primitivos dependen del microprocesador o del sistema operativo en el que se están ejecutando. En cambio, Java pretende ser independiente de la plataforma y mantiene los formatos sin cambios. Para los caracteres alfanuméricos utiliza la codificación UNICODE de 16 bits, para permitir la inclusión de varios alfabetos.
Constantes
En programación, una constante es un valor que no puede ser alterado durante la ejecución de un programa. Una constante corresponde a una longitud fija de un área reservada en la memoria principal del ordenador, donde el programa almacena valores fijos.
Ejemplo:
1. Ingresar dos números y resolver una ecuación, donde el valor de PI nunca cambia.
2. Ingresar un número del 1 al 7 y de acuerdo al número ingresado que imprima un día de semana.
Expresiones
Una expresión es una combinación de operadores y operandos de cuya evaluación se obtiene un valor. Los operandos pueden ser nombres que denoten objetos variables o constantes, funciones, literales de cualquier tipo adecuado de acuerdo con los operadores u otras expresiones más simples. La evaluación de una expresión da lugar a un valor de algún tipo, una expresión se dice que es del tipo de su resultado.
abstract
|
boolean
|
break
|
byte
|
case
|
catch
|
char
|
class
|
continue
|
default
|
do
|
double
|
else
|
extends
|
false
|
final
|
finally
|
float
|
for
|
if
|
implements
|
import
|
instanceof
|
int
|
interface
|
long
|
native
|
new
|
null
|
package
|
private
|
protected
|
public
|
return
|
short
|
static
|
super
|
switch
|
syncroniced
|
this
|
throw
|
throws
|
transient
|
true
|
try
|
void
|
volatile
|
while
|
var
|
rest
|
|
|
|
|
|
Operadores
Los operadores son aquellos que tras realizar una operación devuelven un resultado, estos se puede caracterizar por el número de operadores, el tipo de operando, y el resultado que generan.
Número de operando. Pueden ser de dos tipos unarios, y binarios. Los unarios son aquellos que solo necesitan de un operando para devolver un valor, mientras que los binarios necesitan de dos o más operando.
