Tipos de datos: simples y estructurados.

De manera muy simple, los lenguajes de programacin deben soportar la escritura

de programas y los programas son conjuntos de operaciones que se realizan sobre
unos datos. Luego, en la redaccin de programas siempre hay que contemplar estas
dos cuestiones: las operaciones y los datos.
Los datos se agrupan en tipos de datos.
Los tipos bsicos o escalares son los que definen elementos simples. Por el
contrario, los tipos estructurados son los que definen elementos complejos, es
decir, elementos constitudos por otros que o son simples o bien son a su vez,
estructurados. En la siguiente tabla se muestra el conjunto universal ms comn
entre los lenguajes de programacin.

+---------------+--------------+---------------------------+-------------------+
| COMPLEJIDAD
|
FAMILIA
|
NOMBRE COMN
|
NOMBRE EN JAVA |
+---------------+--------------+---------------------------+-------------------+
+---------------+--------------+---------------------------+-------------------+
|
Bsico
| Discreto
| Entero, Lgico, Carcter | int, boolean, char|
+---------------+--------------+---------------------------+-------------------+
|
Bsico
| Continuo
|
Real
|
double
|
+---------------+--------------+---------------------------+-------------------+
|
Bsico
| Referencia
|
Puntero
|
|
+---------------+--------------+---------------------------+-------------------+
| Estructurado | Heterogneo |
Registro o Tupla
|
|
+---------------+--------------+---------------------------+-------------------+
| Estructurado | Homogneo
|
Coleccin
|
|
+---------------+--------------+---------------------------+-------------------+

Punteros, registros y colecciones no tienen un nombre en Java, aunque existen

con otra simbologa y consideracin. Los datos lgicos son los cierto y
falso del lgebra de Boole. Los datos de tipo carcter son los smbolos del
alfabeto: letras maysculas y minsculas, nmeros de la base decimal y signos de
puntuacin (no slo esos, pero s, los ms usados e interesantes). Los registros
se constituyen con elementos heterogneos, de manera que cada uno de ellos puede
pertenecer a un tipo de datos distinto; mientras que las colecciones se
constituyen solo con elementos del mismo tipo. Hay un caso particular de
coleccin muy usual que es la coleccin de caracteres. Dichas colecciones suelen
designarse con el nombre String.
Todo tipo de datos debe reunir los siguientes atributos:
Nombre del tipo: palabra reservada del lenguaje.
Literales: una forma especfica para los elementos (una grafa).
Operadores: a veces smbolos y a veces funciones predefinidas.
Con los tipos estructurados hay que disponer de una sintaxis para acceder a los
elementos constitutivos y de unas reglas para saber qu hacer con el dato
estructurado al completo.

EL TIPO int
Bajo este nombre se dispone de nmeros enteros desde el -2147483648 al
2147483647 conforme a una representacin para una palabra de memoria de 32 bits.
Los literales son secuencias de dgitos de la base decimal que en el caso de los
negativos llevan a la izquierda el smbolo - que acta como un operador
monario en notacin prefija, esto es, con el operando a la derecha.

Los operadores:
+---------+-------------------+------------------------------------------------+
| SMBOLO |
SIGNIFICADO
|
CARACTERSTICAS
|
+---------+-------------------+------------------------------------------------+
|
+
| Signo positivo
|
Monario en prefija
|
+---------+-------------------+------------------------------------------------+
|
| Signo negativo
|
Monario en prefija
|
+---------+-------------------+------------------------------------------------+
|
%
| Resto divisin
| Binario en infija.
|
|
|
| El operando de la derecha debe ser > 0
|
+---------+-------------------+------------------------------------------------+
|
/
| Cociente divisin | Binario en infija.
|
|
|
| El operando de la derecha no puede ser 0
|
+---------+-------------------+------------------------------------------------+
|
*
|
Producto
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
|
+
|
Suma
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
|
|
Resta
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
La prioridad entre ellos es decreciente segn se va de arriba a abajo en la
tabla. Los de signo son de igual prioridad entre ellos. Igual que los
multiplicativos % / * entre ellos e igual que los aditivos + - entre ellos.
Entre operadores de igual prioridad, esta se establece de izquierda a derecha
segn aparezcan en la expresin.
Ejemplos:
Literales:
0 -5 1024
Constantes:
final int diasAo = 365;
final int docena = 12;
final int cartasBaraja = 40;
Variables:
int semanas;
int x, y z;
int total = 0;
Expresiones:
7 + 3 // 10
7 - 3 // 4

7 / 3 // 2
7 % 3 // 1
1 + (2 + (3 + (4 - x) - y) - z)
1250 / diasAo
total - (cartasBaraja - (x % docena) + 1)

EL TIPO double
Bajo este nombre se dispone de nmeros reales desde el 1.7*10[superscript:308]
hasta el 1.7*10[superscript:308]conforme a una representacin para una palabra
de memoria de 64 bits.
Los literales son de dos tipos:
Punto flotante: Dos secuencias de dgitos de la base decimal,
separadas por
un punto (.), donde la secuencia de la izquierda
puede comenzar por el
operador - para marcar el literal como
negativo. La secuencia de la
izquierda constituye la parte
entera del literal real y la secuencia de la
derecha, la parte decimal.
Notacin cientfica: Un literal en punto flotante seguido de la
letra e o
E y un literal entero. El literal a la izquierda
de la letra se corresponde
con el coeficiente en dicha notacin y el literal a la derecha, con el orden de
magnitud o exponente.
Los operadores:
+---------+-------------------+------------------------------------------------+
| SMBOLO |
SIGNIFICADO
|
CARACTERSTICAS
|
+---------+-------------------+------------------------------------------------+
|
+
| Signo positivo
|
Monario en prefija
|
+---------+-------------------+------------------------------------------------+
|
| Signo negativo
|
Monario en prefija
|
+---------+-------------------+------------------------------------------------+
|
/
| Cociente divisin | Binario en infija.
|
|
|
| El operando de la derecha no puede ser 0
|
+---------+-------------------+------------------------------------------------+
|
*
|
Producto
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
|
+
|
Suma
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
|
|
Resta
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
La prioridad entre ellos es decreciente segn se va de arriba a abajo en la
tabla. Los de signo son de igual prioridad entre ellos. Igual que los
multiplicativos / * entre ellos e igual que los aditivos + - entre ellos. Entre
operadores de igual prioridad, esta se establece de izquierda a derecha segn
aparezcan en la expresin.
Ejemplos:
Literales
1.5 -60.2 3.141595 5e12 5.0E12 5.0E-12 -5.0E12
Constantes
final double gravitacionUniversal = 6.67E-11;
final double numeroAvogadro = 6.022E23;
final double cargaElectron = 1.6E-19;
Variables
double base = 4.3;
double altura = 12.9;
double area, perimetro;

Expresiones
7.0 +
7.0 7.0 *
7.0 /
(base

3.0 // 10.0
3.0 // 4.0
3.0 // 21.0
3.0 // 2.3333333333333335
* altura) / 2.0 // 27.735

EL TIPO char
Bajo este nombre se dispone del conjunto de caracteres que conforman el alfabeto
del computador como si de un conjunto de smbolos simples se tratara. Java usa
el conjunto de caracteres UNICODE en una representacin de 16 bits. Estn
numerados desde el 0 al 65535. Los 128 primeros se corresponden con el
subconjunto ASCII. Solo los correspondientes a las letras (maysculas y
minsculas), a los nmeros de la base decimal y a algunos signos de puntuacin
son interesantes. Tener en cuenta que tanto los cdigos del subconjunto de
letras maysculas como los del subconjunto de las minsculas y como los del de
los nmeros, son consecutivos y correlativos. Es decir, detrs del cdigo de una
letra viene el cdigo de la letra correspondiente en el orden alfabtico y no
hay ningn otro cdigo en medio.
Los literales son de dos tipos:
Un smbolo del alfabeto con representacin grfica (uno cualquiera de un
teclado) encerrado entre apstrofos o comillas simples.
Una secuencia de escape tambin entre apstrofos. Las secuencias de escape
estn formadas por el smbolo "\" y una letra o bien, el smbolo "\", la letra
"u" y un nmero entero positivo (nmero de orden de UNICODE). Por ejemplo, el
literal del propio apstrofo se escribira '\u0027'. Las secuencias de escape
ms tiles son:
'\n' salto de lnea
'\f' salto de pgina
'\t' tabulador
'\b' backspace
'\r' retorno de carro
Los operadores: Son los mismos que para los valores de tipo "int". Java toma el
nmero de orden que tienen en UNICODE y es ese nmero con el que trabaja.
Ejemplos:
Literales
'0' 'b' 'B' '.' '\u72'
Constantes
final char ese = 's';
final char cero = '0';
final char euro = '';
Variables
char letra1, letra2;
char letra3 = 'z';
Expresiones
cero + '9'
'Z' - 'A'
(letra1 + letra2) / letra3

EL TIPO boolean
Bajo este nombre se caracteriza el conjunto de los dos nicos valores de la
lgica booleana: los valores cierto y falso.
Los literales son las palabras reservadas true y false.
Los operadores:
+---------+--------------+------------------------------------------------+
| SMBOLO | SIGNIFICADO |
CARACTERSTICAS
|
+---------+--------------+------------------------------------------------+
+---------+--------------+------------------------------------------------+
|
!
| Negacin
|
Monario en prefija
|
+---------+--------------+------------------------------------------------+
|
&&
| Conjuncin |
Binario en infija
|
+---------+--------------+------------------------------------------------+
|
||
| Disyuncin |
Binario en infija
|
+---------+--------------+------------------------------------------------+
La prioridad entre ellos es decreciente segn se va de arriba a abajo en la
tabla.
Literales
true false
Constantes
final
final
final
final

boolean
boolean
boolean
boolean

seco = true;
humedo = false;
soleado = false;
lluvioso = true;

Variables
boolean alMonte, alCine;
boolean alMedico = false;
Expresiones
seco && soleado
!humedo || lluvioso
(lluvioso && !soleado) || (!seco && humedo)

OTRAS OPERACIONES
Existen los operadores de comparacin que se citan en la siguiente tabla.
+---------+-------------------+------------------------------------------------+
| SMBOLO |
SIGNIFICADO
|
CARACTERSTICAS
|
+---------+-------------------+------------------------------------------------+
+---------+-------------------+------------------------------------------------+
|
==
|
Igual que
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
|
!=
|
Desigual que
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
|
<
|
Menor que
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
|
<=
| Menor o igual que |
Binario en infija
|
+---------+-------------------+------------------------------------------------+
|
>
|
Mayor que
|
Binario en infija
|
+---------+-------------------+------------------------------------------------+
|
>=
| Mayor o igual que |
Binario en infija
|
+---------+-------------------+------------------------------------------------+
Los operandos pueden ser int, double o char (tambin, boolean en el caso de la
igualdad o desigualdad). El resultado siempre es boolean.
Ejemplos:
double x, y, z;
int a, b, c;
char una, dos, tres;
boolean resultado, esDigito;
resultado = ((x > y) && (x > z)) || ((a != b) && (a != c));
esDigito = (tres >= '0') && (tres <= '9');
Tambin existen ciertas operaciones matemticas, pero estn definidas como
funciones y pertenecen a la clase Math. Los argumentos deben ser de tipo double.
El resultado tambin lo es. En la siguiente tabla se muestran las ms usuales.
+----------+-----------------------+-------------------------------------------+
| FUNCIN |
SIGNIFICADO
|
CARACTERSTICAS
|
+----------+-----------------------+-------------------------------------------+
+----------+-----------------------+-------------------------------------------+
| abs(x) |
Valor absoluto
|
Admite argumentos int
|
+----------+-----------------------+-------------------------------------------+
| exp(x) | Exponencial en base e |
Admite argumentos int
|
+----------+-----------------------+-------------------------------------------+
| log(x) | Logaritmo neperiano
|
Admite argumentos int
|
+----------+-----------------------+-------------------------------------------+
| pow(x,y) |
x elevado a y
|
Admite argumentos int
|
+----------+-----------------------+-------------------------------------------+
| sqrt(x) |
Raiz cuadrada
|
Admite argumentos int
|
+----------+-----------------------+-------------------------------------------+
| sin(x) |
Seno
|
Admite argumentos int, pero en radianes |
+----------+-----------------------+-------------------------------------------+
| tan(x) |
Tangente
|
Admite argumentos int, pero en radianes |
+----------+-----------------------+-------------------------------------------+
Ejemplos:
double z;

double a, b, c;
char una, dos, tres;
boolean resultado, esDigito;
z = (1.0 - Math.sin(a)) / 2.0;
z = (-b + Math.sqrt(Math.pow(b,2) - 4.0 * a * c)) / 2.0;

LA CLASE String
Bajo este nombre se caracterizan las secuencias de caracteres (las palabras).
Este tipo de datos no es realmente un tipo para Java y tampoco es un dato
bsico. Es un dato estructurado de tipo coleccin, implementado como una clase y
del que conviene saber, al principio, la manera de construirlo, pues nos
permitir clarificar los resultados de nuestros programas.
Los literales son secuencias de caracteres encerrados entre comillas.
Existe el operador + que permite la concatenacin de string's.
Ejemplos:
final String lenguaje = "Java";
String vacio = "";
String entornoProgramacion = "Doctor" + lenguaje;

CONVERSIN DE TIPOS
Java es un lenguaje fuertemente tipado donde los tipos son mundos estancos y el
lenguaje se cuida de que no puedan existir penetraciones ni objetos que jueguen
papeles distintos. Cada elemento de un tipo tiene una nica representacin en
cdigo binario y su mbito de operacin es el de la aritmtica prefijada para
ese tipo. Sin embargo y en el caso de los nmeros, ya sean int o double o sus
extensiones, se permite una cierta flexibilidad para comodidad del programador.
En concreto, se permite la mezcla de ellos en expresiones siempre y cuando haya
una manera posible de resolver dicha expresin.
Ejemplos:
double x, y, z;
int a, b, c;
z = y + a;
z = 1 + 2.0 + 3 + 4.0;
Lo que hace Java es convertir los int a double y evaluar todo a double. El que
se asigne los resultados a una variable double (z) no causa ningn conflicto.
Cosa que s ocurrira en el caso de que la asignacin fuese a una variable int.
Puesto que los char estn numerados, tampoco hay problema en permitir la mezcla
de caracteres con nmeros. El resultado de esas expresiones ser un nmero.
Tambin ocurre algo parecido con los string's. Se permite concatenar un String
con un int o con un double o con un char, puesto que Java convertir dicho
nmero o carcter a un String previamente a la concatenacin.
Ejemplos:
double x, y, z;
int a, b, c;
char una, dos, tres;
String vacio = "";
c = a + 'a' - una;
vacio = vacio + x + " " + a + " " + una;
Estamos viendo que Java busca la conversin que da consistencia a lo que le
propone la expresin, pero existe la manera de forzar la conversin a otros
propsitos no tan evidentes. Para ello basta con anteceder al valor que se
quiere convertir, el nombre del tipo elegido encerrado entre parntesis.
tres = (char)(a + 'a' - una);
Esto solo tendr sentido si el nmero que resulte en el parntesis de la derecha
est en el rango de los char, porque en otro caso no habra un carcter con
quien asociarlo y no se podra resolver la conversin.
En la conversin de un double a un int se produce el truncado de la parte
decimal.