Tipos de datos y variables en Java

TIPOS DE DATOS PRIMITIVOS

Datos simples ordinales (enteros)

Representan los datos enteros sin decimales

Tipo	Tamaño (bytes)	Descripción	Rango
byte	1	byte	-128 a 127
short	2	entero corto	-32768 a 32767
int	4	entero	-231 a 231-1
long	8	entero largo	263 a 263-1

Ej: 1, 27, 5948272, 435623L

Los datos long deben incluir una L al final

Datos simples reales

Representan los datos con decimales o de punto flotante.

Tipo	Tamaño (bytes)	Descripción	Rango
float	4	real simple precisión	+-3.4X1038  a +-1.4x1045
double	8	real doble precisión	+-1.8x10308 a +-4.9x10-324

Ej: 30.0, 5678.345

La coma decimal se representa con un punto ( . ), si se emplea una coma ( , ) no funcionará ya que la coma tiene otra funcionalidad que ser verá más adelante.

Para poder distinguir un float de un double hay que incluir las letras F o D al final del numero representado:

Double: 15.05D

Float: 15.05F

Por defecto en Java se emplea double por lo que la D no sería obligatoria.

Los datos reales también se pueden expresar en notación científica puesto que soportan rangos muy grandes de valores:

1234500000 -> 123.45E+7

O lo que es lo mismo: 123.45 x 10⁷

Datos de tipo carácter

Representan caracteres con formato unicode. Se representan entre comillas simples ( ‘ ).

Tipo	Tamaño (bytes)	Descripción	Rango
char	2	carácter	codificación Unicode

Ej: ‘a’, ‘5’ , ‘-‘, ‘@’

Existen unos caracteres especiales, o caracteres de control, no imprimibles que requieren una secuencia de escape representada con una barra inclinada ( \ ) . Igualmente se escriben entre comillas simples:

Carácter especial	Descripción
‘\n’	Salto de línea
‘\t’	Tabulador
‘\b’	Retroceso
‘\r’	Retorno de carro
‘\’’	Comilla simple
‘\\’	Barra inclinada
‘\”’	Comilla doble
‘\0’	Carácter nulo

Datos de tipo lógico

Representan valores lógicos. Estos valores cumplen el algebra de Bool, de ahí su nombre, y solo pueden tomar valores verdadero (true) o falso (false).

Tipo	Tamaño (bytes)	Descripción	Rango
boolean	1	booleano	true o false

VARIABLES

Un programa escrito en cualquier lenguaje maneja datos que son almacenados en memoria e identificados a través de un nombre simbólico.  A estos datos se les llama variables o constantes, dependiendo de si su contenido es variante o fijo. Los datos almacenados en estas posiciones de memoria pueden ser de cualquiera de los tipos especificados anteriormente.

Identificadores validos

El nombre con el que se identifica una variable se llama identificador y debe cumplir una serie de normas para que sea valido:

- Debe empezar por una letra (a-z A-Z) ó por el carácter subrayado ( _ ) ó por el carácter $.

- No puede contener espacios.

- No se pueden usar las palabras reservadas como identificador:

abstract	continue	float	native	super	void
boolean	default	for	new	switch	volatile
break	do	goto	null	synchronized	while
byte	double	if	package	this
byteevalue	else	implements	private	threadsafe
case	enum	import	protected	throw
catch	extends	instanceof	public	throws
char	false	int	return	transient
class	final	interface	short	true
const	finally	long	static	try

Ej:

Identificador	Correcto
numero	si
$numero	si
índice	si *
nombre propio	no (no se pueden usar espacios)
nombre_propio	si
numero&letra	no (el & no es un carácter valido)
miIdentificador	si
MiIdentificador	si *

* El uso de tildes y mayúsculas está permitido, pero se desaconseja. Las tildes pueden dar problemas en algunos sistemas operativos. El uso de mayúsculas se recomienda para las clases y las constantes. Lo veremos más adelante.

NOTA: Java es un lenguaje casesensitive por lo que distingue identificadores escritos en mayúscula de los que están escritos en minúscula. No es lo mismo casa que Casa.

Declaración de una variable

Para poder usar las variables primero hay que declararlas. Cada variable se declara una única vez.

La declaración sigue la siguiente sintaxis:

tipo_de_dato identificador_valido[=inicialización];

El tipo de dato puede ser cualquiera de los existentes en Java.

El identificador estará definido cumpliendo las reglas expuestas anteriormente para que sea un identificador valido.

La declaración terminará en punto y coma ( ; ).

La inicialización no siempre es obligatoria. En el caso de inicializar la variable se usará el operador de asignación ( = ) seguido del valor con el que se desea inicializar la variable. Esta practica no se recomienda, salvo excepciones.

CONSTANTES

Las constantes representan variables que tienen un valor fijo que no puede modificarse.

Para representar una constante basta con incluir la palabra final antes de la declaración.

El identificador, por convenio, se escribe en mayúsculas.

El valor de la constante se suele incluir también en la declaración ya que no se podrá modificar posteriormente:

final tipo_de_dato IDENTIFICADOR_VALIDO = inicialización;

CADENAS DE CARACTERES (STRING)

Las cadenas de caracteres son conjuntos de caracteres unicode que se escriben de forma consecutiva entre comillas dobles ( “ ). Al ser objetos poseen funcionalidades propias para su manejo.

La sintaxis es la siguiente:

String identificador[=”inicialización”];

Las explicaré en profundidad más adelante.

OBJETOS DE CLASES ENVOLTORIO (WRAPPERS)

Todos los tipos de datos primitivos tienen una clase envoltorio asociada que les confiere funcionalidades más avanzadas.

Tipo de dato primitivo	Clase envoltorio
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

La sintaxis para definir un objeto de clase de envoltorio es la siguiente:

Nombre_de_wrapper identificador_valido[=inicialización];

VARIABLES DE REFERENCIAS

Contienen la dirección de memoria de un objeto.

Un objeto es un bloque de sentencias y datos generado a partir de una clase.

Estos términos, junto con las cadenas de caracteres y los wrappers, los explicaré con mayor detalle en otro post.