VARIABLES EN JAVA

VARIABLES EN JAVA
¿Qué es una variable?
Tipado fuerte
Almacenamiento de la información
Tipos de datos numéricos
Otros tipos de variables en JAVA
Declarar variables en Java
Declarar variables numéricas
Declarar variables booleanas
Declarar variables char
Cadenas de texto - String
Métodos más utilizados de String
Constantes
Recomendaciones al declarar variables
Comentarios

Note
Prueba a ejecutar este código:

int edad = 20;

[Link]("Mi edad es: " + edad);

Si se ejecuta bien debería mostrarte por pantalla Mi edad es: 20

Te estarás preguntando que acabas de hacer. int edad = 20; es una variable. Por así
decirlo una "caja" de tipo int, que es un tipo de dato numérico entero, a la que hemos dado
el valor 20.
Y en [Link] le hemos dicho que al texto nos concatene el valor de esa
variable con el operador de suma "+"
Por tanto, has mostrado por pantalla el valor de una variable, las cuales veremos en
profundidad en este tema.

1
 ¿Qué es una variable?
Una variable no es más ni menos que una zona de memoria donde se puede almacenar
información del tipo que desee el programador.
Se utilizan para almacenar los datos que manejan los programas. Pueden guardar todo tipo
de información, desde cantidades numéricas y textos, hasta valores booleanos.
Como el propio nombre indica, los datos almacenados en dichas variables pueden “variar”
a lo largo de la ejecución del programa.
Necesitamos un espacio de memoria donde poder almacenar los valores que tienen
almacenados las variables en cada momento.
En casi cualquier lenguaje de programación podremos reservar esos "espacios", y
asignarles un nombre con el que acceder a ellos. Esto es lo que se conoce como
"variables".
Para no desperdiciar la memoria de nuestro ordenador, el espacio de memoria que hace
falta "reservar" será distinto según el “tipo de datos” que queramos almacenar(enteros,
reales, caracteres, cadenas, etc).

Tipado fuerte
JAVA es un lenguaje con un tipado fuerte, esto significa que se debe indicar el tipo de
datos que queremos guardar dentro de una variable. El tipo de tipado es una característica
propia de cada lenguaje.
Esto hace a JAVA más “estricto” en la declaración de variables, esto normalmente se
traduce en una mayor protección contra posibles errores. Por ejemplo:
Vamos a declarar una variable que se llama cantidad y es de tipo numérico
Vamos a declarar una variable que se llama nombre y es de tipo texto
En otros lenguajes como JavaScript o Python simplemente indicaremos que vamos a
declarar dos variables, que se llaman nombre y cantidad

Almacenamiento de la información
En computación toda la información se almacena en código binario , es decir, a base a
dos valores, el cero y el uno. A esta unidad mínima de información se le denomina bit. Es
decir, en un bit, únicamente podemos almacenar un cero o un uno. Normalmente, cuando
hablamos de capacidad de almacenamiento, lo expresamos en bytes, 1 byte son 8 bits

2
 Dependiendo de la cantidad de bits que utilicemos, tendremos más combinaciones
distintas, esto nos proporciona la capacidad de almacenar todo tipo de valores.
Por ejemplo, en 2 bits tenemos 4 combinaciones:

Tipos de datos

Tipos de datos numéricos

Tipo de Información ¿Admite
Rango Ocupa
datos representada decimales?

byte Datos enteros no -128 ↔ +127 1 byte

2
short Datos enteros no -32768 ↔ +32767
bytes

Datos -2147483648 ↔ 4
int no
enteros +2147483648 bytes

-9223372036854775808 ↔ 8
long Datos enteros no
+9223372036854775807 bytes

Datos con
Precisión aproximada 4
float coma de 32 si
de 7 dígitos bytes
bits

Datos con
Precisión aproximada de 16 8
double coma de 64 si
dígitos bytes
bits

Note
¿Por qué necesitamos tipos diferentes? Un pequeño ejemplo:

3
 byte edad = 25; // Suficiente para edades (0-127)
int poblacion = 47000000; // Necesario para población española

Otros tipos de variables en JAVA

Tenemos otros tipos básicos de variables, los cuales no son numéricos:

char : Almacena un único carácter , puede ser una letra, un dígito numérico, o cualquier
otro carácter alfanumérico. Ocupa 2 bytes y sigue un estándar llamado Unicode (que a su
vez engloba a otro estándar anterior llamado ASCII)
boolean : Se usa para evaluar condiciones, y puede tener el valor "verdadero" (true) o
"false" (false). Ocupa 1 bit.
String : Se utiliza para almacenar cadenas de caracteres, es decir, puede almacenar un
conjunto de char. Aunque no es un tipo primitivo, es un tipo de dato muy utilizado

Declarar variables en Java

La forma de "declarar" una variable en JAVA es detallando primero el tipo de datos que
podrá almacenar y después el nombre(identificador) que daremos la variable. Además, se
puede indicar un valor inicial a través del igual.
Para finalizar la asignación de la variable debemos introducir un punto y coma.

La declaración de variables funciona de la siguiente forma:

1. Se evalúa la expresión a la derecha del igual.
2. Se guarda el resultado de la expresión sobre la variable a la izquierda del igual.
Además podemos asignar a una variable el valor de otra variable, e incluso, realizar
operaciones con ellas:

4
 int cantidad = 5 + 2; //guardamos en cantidad un 7
int precio = 10; //guardamos en precio un 10
precio = 5; //modificamos el precio a 5
int precioFinal = cantidad * precio; //guardamos un 35 en precioFinal
precioFinal = precioFinal + 10; //guardamos 45 en precioFinal

Se pueden declarar varias variables del mismo tipo "a la vez", separando con comas:

int a = 5, b = 10; // "a" y "b" son enteros y valen 5 y 10

short c = -1, d, e = 4; // "c" vale -1, "d" no tiene valor, "e" vale 4
int f, g; // declaramos las variables "f" y "g" de tipo entero

El nombre de la variable , su identificador, debe seguir las siguientes reglas:

Debe comenzar por letra, subrayado (_) o el carácter $.
No pueden comenzar por un número, pero después sí podemos incluirlos.
Las variables son case-sensitive, es decir, diferencian entre mayúsculas y
minúsculas.
No pueden utilizarse espacios en blanco ni símbolos de operadores
El % no está permitido, si el $ y la ç. También los acentos y la ñ, pero no se
recomienda utilizarlos
No pueden coincidir con ninguna palabra reservada:

abstract, assert, boolean, break, byte, case, catch, char, class,

const, continue, default, do, double, else, enum, extends, false,
final, finally, float, for, goto, if, implements, import, instanceof,
int, interface, long, native, new, null, package, private, protected,
public, return, short, static, strictfp, super, switch, synchronized,
this, throw, throws, transient, true, try, void, volatile, whil

Declarar variables numéricas

Para utilizar decimales se usa el punto, y una ‘f’ final para indicar el tipo float .
Podemos utilizar una ‘d’ final para indicar que es de tipo double , pero no es obligatorio

5
 float floatSinDecimal = 1f; // "f1" es de tipo float y vale 1.0
float floatConDecimal = 5.4f; // "f2" es de tipo float y vale 5.4

double doubleSinDecimal = 2; // "d1" es de tipo double y vale 2.0

double doubleConDecimal = 4.001d; // "d2" es de tipo double y vale 4.001

Declarar variables booleanas

Las variables booleanas son muy utilizadas en programación y sirven para evaluar
condiciones. Este tipo de variables únicamente pueden almacenar dos valores, verdadero
o falso
Para declarar variables de tipo booleano se utiliza la palabra boolean. Para asignar valores
debemos utilizar las palabras reservadas true, y false. Las palabras reservadas nunca van
entre comillas

boolean seguir = true; // correcto

boolean parar = false; // correcto

Podemos asignar también el resultado de una expresión lógica a este tipo de variables:

boolean seguir = 3 > 5; // false

boolean parar = 7 != 6; // true

Declarar variables char

Para declarar variables de tipo char debemos poner su valor entre comillas simples:

char letra = 'A'; // "letra" es un carácter y tiene guardada la letra A

char simbolo = '*'; // "simbolo" es un carácter y tiene guardado el
carácter asterisco *

En JAVA las variables de tipo char internamente funcionan como enteros, de hecho
podemos cambiar su valor a través de operaciones aritméticas. Los valores más
frecuentes están definidos en la tabla ASCII.

6
 char letra = 'A'; // "letra" y tiene guardada la letra A, que en código ASCII
es 65
letra = letra + 1; // "letra" y tiene guardada la letra B, cuyo codigo ASCII es
66
letra = letra + 3; // "letra" y tiene guardada la letra E, que corresponde a 69

Tip
Puedes encontrar toda la tabla ASCII con sus valores en el siguiente enlace: [Link]
[Link]/

Cadenas de texto - String

Una cadena de texto (en inglés, "String") es un bloque de caracteres alfanuméricos, que
usaremos para poder almacenar palabras y frases. Puede tener cero o más caracteres.

El valor de una variable de tipo String siempre debe ir entre comillas dobles
Podemos "concatenar" cadenas, juntar dos cadenas para dar lugar a una nueva.

String nada = " "; //cadena vacia

String nombre = "Fernando";
String apellido = "Alonso";
String nombreCompletoSinEspacio = nombre + apellido; //FernandoAlonso
String nombreCompletoConEspacio = nombre + " " + apellido; //Fernando Alonso

Podemos combinar Strings tanto con cantidades numéricas, como con variables que las
contienen. Sin embargo, debemos tener en cuenta que si queremos mostrar el cálculo
dentro del String, dicho cálculo deberemos ponerlo entre paréntesis, de lo contrario, lo
concatenará.

7
 String nombre = "Alonso";
String frase;
int numeroVictorias = 33;
frase = nombre + " tiene " + numeroVictorias +" victorias"; //Alonso tiene 33
victorias
frase = nombre + " tiene " + numeroVictorias + 5 + "victorias"; //Alonso tiene
335 victorias
frase = nombre + " tiene " + (numeroVictorias + 5) + "victorias"; //Alonso tiene
38 victorias
frase = nombre + " tiene " + numeroVictorias - 5 + "victorias"; //ERROR
frase = 15 + 5 + nombre; //20Alonso
frase = 5 - 15 + nombre; //-10Alonso
frase = 5 - 10 + nombre + 5 + 10 + (5 + 5); //-5Alonso51010

Métodos más utilizados de String

Un método es un bloque de código que realiza una tarea específica.
La clase String contiene una serie de métodos con lo que se puede trabajar.
Algunos de los más usados son los siguientes:

Método Descripción

Devuelve la longitud (número de caracteres)

length()
de la cadena

Devuelve el carácter que hay en cierta

charAt(int pos)
posición

toLowerCase() Devuelve la cadena convertida a minúsculas

toUpperCase() Devuelve la cadena convertida a mayúsculas

substring(int desde, int Devuelve una subcadena: varias letras a

hasta) partir de una posición dada

replace(char antiguo, char Devuelve una cadena con un carácter

nuevo) reemplazado por otro

Devuelve una cadena sin espacios blanco

trim()
iniciales ni finales

8
 Método Descripción

startsWith(String Indica si la cadena empieza con una cierta

subcadena) subcadena

Indica si una cadena termina con una cierta

endsWith(String subcadena)
subcadena

Indica la posición en que se encuentra una

indexOf(String subcadena,
cierta subcadena (buscando desde el
[int desde])
principio a partir de una posición opcional)

Indica la posición en que se encuentra una

lastIndexOf(String
cierta subcadena (buscando desde el final a
subcadena, [int desde])
partir de una posición opcional)

Devuelve un String que es la representación

valueOf(objeto) como texto del objeto que se le indique
(número, boolean, etc.)

concat(String cadena) Devuelve la cadena con otra añadida al final

Mira si dos cadenas son iguales (lo mismo

equals(String cadena)
que ==)

Mira si dos cadenas son iguales, pero

equalsIgnoreCase(String
despreciando las diferencias entre
cadena)
mayúsculas y minúsculas

Compara una cadena con la otra. Devuelve 0

compareTo(String cadena2) si son iguales, negativo si la cadena es
menor que cadena2 y positivo si es mayor

En ningún momento estamos modificando el String de partida. Eso sí, en muchos de los
casos creamos un String modificado a partir del original
El método compareTo() se basa en el orden lexicográfico: una cadena que empiece por
"A" se considerará "menor" que otra que empiece por la letra "B"; si la primera letra es
igual en ambas cadenas, se pasa a comparar la segunda, y así sucesivamente. Las
mayúsculas y minúsculas se consideran diferentes
Un comentario extra sobre los Strings: Java convertirá a String todo aquello que
indiquemos entre comillas dobles. Por ejemplo, es válido la expresión
"Prueba".length()
Ejemplos:

9
 String nombre = "Pepe"; //Pepe
String apellidos = "Martínez García"; //Martínez García
String nombreCompleto = nombre + apellidos; //PepeMartínez García
int longitud = [Link](); //4
int longitud2 = "245".length(); //3
char letra = [Link](3); //t
String cadena1 = [Link](0,4); //Pepe
String cadena2 = " Hola ".trim(); //Hola
String cadena3_1 = [Link](3,4); //e
String cadena3_2 = [Link](3,3); //
String cadena3_3 = [Link](4,3); //ERROR
String cadena4 = (cadena2 + "Hola").toLowerCase(); //holahola
int posicion1 = [Link]("o" ); //1
int posicion2 = [Link]("hola"); //0
int posicion3 = [Link]("Hola"); //-1

Secuencias de escape

Las secuencias de escape son combinaciones de caracteres que comienzan con una
barra diagonal inversa \ y se utilizan para representar caracteres especiales dentro de
cadenas de texto, o para controlar el formato de la salida en la consola.

Símbolo Descripción

\n Salto de línea. Sitúa el cursor al principio de la línea siguiente

\b Retroceso. Mueve el cursor un carácter atrás en la línea actual.

Tabulador horizontal. Mueve el cursor hacia adelante a una distancia

\t
determinada por el tabulador.

\r Ir al principio de la línea. Mueve el cursor al principio de la línea actual

\f Nueva página. Mueve el cursor al principio de la siguiente página.

\” Comillas. Permite mostrar por pantalla el carácter de las comillas dobles.

10
 Símbolo Descripción

Comilla simple. Permite mostrar por pantalla el carácter de la comilla

\’
simple

\\ Barra inversa

Carácter Unicode, representa un dígito hexadecimal del carácter

\u
Unicode

Ejemplos

String nombre = "Pepe";

String apellidos = "Martínez García";
String nombreCompleto1 = nombre+" "+apellidos; // Pepe Martínez García
String nombreCompleto2 = "\"+nombre+apellidos+\""; // "+nombre+apellidos+"
String nombreCompleto3 = "\""+nombre+apellidos+"\""; // "PepeMartínez García"
String nombre2 = nombre+"\b"+nombre; // PepPepe
String apellidos2 = apellidos+"\r,"+nombre; // ,Pepenez García
String apellidos3 = apellidos+"\b,"+nombre; // Martínez Garcí,Pepe
String apellidos4 = apellidos+"\\,"+nombre; // Martínez García\,Pepe
String apellidos7 = "\u2605 "+nombre; // ★ Pepe
String apellidos8 = "\u2661 "+nombre; // ♡ Pepe

Constantes
A parte de las variables también existen las constantes.
Se tratan de valores fijos cuyo valor no se puede modificar . Se declaran de forma
similar a una variable con valor inicial pero con el prefijo final

final <tipo de datos> <nombre de la constante> = <valor>;

Por ejemplo, si en un programa necesitáramos el valor de PI, sería una constante, ya que
su valor no cambiara en ningún momento del programa.

final double PI=3.141592;

final String ASIGNATURA = "Programación";

11
 Recomendaciones al declarar variables
Una buena elección del identificador de una variable puede ser difícil incluso para
programadores experimentados, sobre todo si tenemos muchas variables.
Usa nombres de variables que sean significativos y que representen el valor o objeto que
almacenan. Por ejemplo, usa float precio en lugar de float p
No empezar con mayúsculas, ya que es una forma de diferenciar los objetos de las
variables. Si el identificador está formado por varias palabras, se deben separar con
mayúsculas o con guión bajo.

Tip
Una buena forma de escribir nombres de variables compuestos por varias palabras es
seguir el camelCase . La primera palabra se escribe en minúscula. Cada palabra siguiente
se inicia con una mayúscula. Por ejemplo, nombreUsuario o precioFinalDelProducto

También es recomendable y una buena práctica declarar los nombres de las constantes
completamente en mayúsculas, es una forma de diferenciarlas del resto de variables

Comentarios
Los comentarios pueden ser colocados en cualquier parte de nuestro código en Java. Su
objetivo es dar orden al código y hacerlo más comprensible, en especial cuando otras
personas tienen que leerlo y trabajar sobre él.
Los comentarios son código JAVA que no se ejecuta.
Aunque cuando empezamos a programar es muy habitual escribir muchos comentarios
sobre nuestro código, debemos evitar el abuso de los mismos.
En JAVA hay 3 formas distintas de añadir comentarios al código: Comentarios de una línea,
comentarios multilínea y comentarios de documentación

12
//Comentarios de una línea, empiezan con doble barra

/*
Comentario multilínea
Esto es una segunda línea de comentario
*/

/**
Comentario de documentación, empiezan con 2 asteriscos. Este
tipo de comentarios los utiliza la herramienta javadoc
*/

13