Apuntes Java: Tipos, valores y variables

Tipos

Java es un lenguaje con control fuerte de Tipos (Strongly Typed). Esto significa que cada variable y cada expresión tiene un Tipo que es conocido en el momento de la compilación. El Tipo limita los valores que una variable puede contener, limita las operaciones soportadas sobre esos valores y determina el significado de la operaciones. El control fuerte de tipos ayuda a detectar errores en tiempo de compilación.

En Java existen dos categorías de Tipos:

  • Tipos primitivos
  • Referencias

Las referencias se usan para manipular objetos. Se verán en una lección posterior. Ahora nos centraremos en los tipos primitivos.

Tipos primitivos

Los tipos primitivos permiten manipular valores numéricos con distintos grados de precisión, caracteres y valores booleanos (verdadero / falso). Los Tipos Primitivos son:

  • boolean : Puede contener los valores true o false.
  • byte : Enteros. Tamaño 8-bits. Valores entre -128 y 127.
  • short : Enteros. Tamaño 16-bits. Entre -32768 y 32767.
  • int : Enteros. Tamaño 32-bits. Entre -2147483648 y 2147483647.
  • long : Enteros. Tamaño 64-bits. Entre -9223372036854775808 y 9223372036854775807.
  • float : Números en coma flotante. Tamaño 32-bits.
  • double : Números en coma flotante. Tamaño 64-bits.
  • char : Caracteres. Tamaño 16-bits. Unicode. Desde 'u0000' a 'uffff' inclusive. Esto es desde 0 a 65535.

El tamaño de los tipos de datos no depende de la implementación de Java. Son siempre los mismos.

Variables

Una variable es un área en memoria que tiene un nombre y un Tipo asociado. El Tipo es o bien un Tipo primitivo o una Referencia.

Es obligatorio declarar las variables antes de usarlas. Para declararlas se indica su nombre y su Tipo, de la siguiente forma:

tipo_variable nombre ;

Ejemplos:

int i;         // Declaracion de un entero
char letra;    // Declaracion de un caracter
boolean flag;  // Declaracion de un booleano
  • El ; es el separador de sentencias en Java.
  • El símbolo // indica comentarios de línea. Desde // todo lo que sigue se considera comentario hasta el final de la línea.
  • En Java las mayúsculas y minúsculas son significativas. No es lo mismo el nombre letra que Letra
  • Todas las palabras reservadas del lenguaje van en minúsculas (int , char , boolean, en los ejemplos)
  • Las palabras reservadas, en general, no pueden usarse como nombres de variables. Pueden causar confusión.
  • Los nombres de variables deben empezar por una letra (mayúscula o minúscula) y pueden tener cualquier longitud.
  • Todas las palabras que forman parte del lenguaje van en negrita a lo largo de todos los apuntes.

Se pueden asignar valores a las variables mediante la instrucción de asignación. Por ejemplo:

i = 5;          // a la variable i se le asigna el valor 5
letra = 'c';    // a la variable letra se le asigna el valor 'c'
flag = false;  // a la variable flag se le asigna el valor false

En la asignación, lo que hay a la derecha del signo = se evalua, y el resultado se asigna a la variable que hay a la izquierda del signo =.

La declaración y la asignación se pueden combinar en una sola expresión:

int i = 5;         
char letra = 'c';   
boolean flag = false;

Literales

En los literales numéricos puede forzarse un tipo determinado con un sufijo:

  • Entero largo: l ó L.
  • Float: f ó F.
  • Double: d ó D.

Por ejemplo:

long n = 5l;
float numero = 53f;
  • En los literales numéricos para float y double puede usarse el exponente (10 elevado a...) de la forma: 1.5e3D (equivale a 1500)
  • Literales hexadecimales: Al valor en hexadecimal se antepone el símbolo 0x. Por ejemplo: 0xf (valor 15)
  • Literales booleanos: true (verdadero) y false (falso). Únicos valores posibles.
  • Literales caracter: Un caracter entre apóstrofes (') o bien una sequencia de escape (también entre '). Las secuencias de escape están formadas por el símbolo 'barra invertida' seguido de una letra o un número. Algunas secuencias de escape útiles:
    • n:    Salto de línea
    • t:    Tabulador
    • b:    Backspace.
    • r:    Retorno de carro
    • uxxxx: donde xxxx es el código Unicode del carácter. Por ejemplo u0027 es el apostrofe (')

Operaciones sobre tipos primitivos

Un operador es un símbolo que realiza una acción (operación) sobre los valores a los que afecta. Aplicado sobre tipos primitivos permiten efectuar operaciones básicas como las operaciones aritméticas (suma, resta, etc) y de otro tipo.

La siguiente tabla muestra un resumen de los operadores existentes para las distintas clases de tipos primitivos. El grupo 'Enteros' incluye byte, short, int, long y char. El grupo 'Coma flotante' incluye floatdouble.

Tipos Grupo de operadores Operadores
Enteros Operadores de comparación que devuelven un valor boolean < (menor) , <= (menor o igual) , > (mayor), >= (mayor o igual), == (igual), != (distinto)
  Operadores numéricos, que devuelven un valor int o long + (unario, positivo), - (unario, negativo), + (suma) , - (resta) , * (multiplicación), / (división), % (resto), ++ (incremento), --(decremento), <<, >>, >>> (rotación) , ~ (complemento a nivel de bits), & (AND a nivel de bits), | (OR a nivel de bits) ^(XOR a nivel de bits)
Coma flotante Operadores de comparación que devuelven un valor boolean < (menor) , <= (menor o igual) , > (mayor), >= (mayor o igual), == (igual), != (distinto)
  Operadores numéricos, que devuelven un valor float o double + (unario, positivo), - (unario, negativo), + (suma) , - (resta) , * (multiplicación), / (división), % (resto), ++ (incremento), --(decremento).
Booleanos Operadores booleanos == (igual), != (distinto), ! (complemento), & (AND), | (OR),  ^ (XOR), && (AND condicional), || (OR condicional) 

Los operadores unarios actúan sobre un sólo valor, mientras que los binarios actúan sobre dos:

int a = 2;
int b = -a; // Operador unario que devuelve el valor negativo. El resultado es -2.
int c = a + b; // Operador binario suma. El resultado es 0.

Expresiones

Una expresión es un conjunto de valores literales o variables separados por operadores cuya evaluación produce un resultado. Se puede usar una expresión para definir el valor de una variable o para asignarle un valor:

int a; // declaramos la variable a
int b = 5; // declaramos la variable b y le asignamos un valor
a = (b * 2) + 1; // (b * 2) + 1 es una expresión, que se evalua, y su resultado (11) es asignado a la variable a

El modificador final

Una variable puede contener valores distintos (de ahí su nombre) a lo largo de la ejecución del programa. Si queremos tener una constante, es decir, un nombre para un valor fijo, que no cambia a lo largo de la vida del programa se usa el modificador final, de la siguiente forma:

[final] tipo_variable nombre  [ = expresión] ;

  • En la sintaxis los [ ] indican que esa parte es opcional.
  • Existen otros modificadores, que se verán en sucesivas lecciones y que afectan de distinta forma a la variable que se declara.

Ejemplos:

double pi = 3.141592;
double e = 2.71828;

Conversiones de tipos

La conversión de tipos se produce cuando en una expresión se mezclan tipos primitivos distintos. Si los tipos son incompatibles se produce un error en tiempo de compilación, pero si los tipos son compatibles, entonces se produce una conversión de tipos y después se evalúa la expresión. Hay que tener cuidado con la conversión de tipos porque ello puede dar lugar a resultados no deseados.

Ejemplos:

int a = 1;
boolean b = true;
float c = a + b; // Error en la compilación. Los tipos int y boolean no son compatibles para el operador suma.
int a = 2;
int b = 1;
float c = (a + b) / 2; // Dado que todos los operandos son enteros, la suma y posterior división es una operación entera. El resultado es 1.0
// Si queremos que la operación se realice con precisión float deberiamos poner:
float c = ((float)a + (float)b) / 2f; // En este caso el resultado será 1.5, ya que todas las operaciones se hacen con valores float

La expresión (float)a convierte el tipo entero de a en tipo float. Esta operación se denomina casting.

 

Última actualización: 25/10/2016

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *