Está en la página 1de 10

TIPOS DE DATO PRIMITIVOS EN JAVA

A todo dato (constante, variable o expresión) le corresponde un tipo específico en Java. Un tipo de
dato determina los valores que pueden asignarse a un dato, el formato de representación
correspondiente y las operaciones que pueden realizarse con dicho dato.

Por otro lado, a partir de estos tipos primitivos de dato pueden construirse otros tipos de datos
compuestos, arrays, clases e interfaces. En la siguiente tabla se muestran los tipos de dato
primitivos de Java con el intervalo de representación de valores que puede tomar y el tamaño en
memoria correspondiente.

Los tipos nativos de Java, son los tipos de datos "fáciles de usar" es decir, no es necesario crear un
objeto de manera explícita para hacer uso de ellos. Los tipos primitivos como su nombre lo da a
entender, son los tipos de datos más básicos y simples del sistema de tipos de Java y por ello es
bastante fácil usarlos.

Java posee un total de ocho tipos primitivos, que cubren todo tipo de números (reales o decimales
y enteros) cada uno con una extensión o magnitud máxima, también cubre los valores lógicos
(falso y verdadero) e incluye caracteres.

Tipos de datos en java:

TIPO CARACTERISTICA PESO RANGO DE VALORES EJEMPLOS


(bits) PERMITIDOS
CHAR Caracteres Unicode de 16 '\u0000' - ‘a’ (su valor en
16 bits Los caracteres '\uffff' unicode:
alfa-numéricos son los ‘\u0061’)
mismos que los ASCII
con el bit alto puesto a
0. El intervalo de
valores va desde 0
hasta 65535 (valores
de 16-bits sin signo)
BOOLEAN Tiene dos valores true 8 TRUE/FALSE TRUE
o false. Para definir
condiciones
verdaderas o falsas en
un context
BYTE Como su propio 8 -128 a 127 86
nombre denota,
emplea un solo byte (8
bits) de
almacenamiento. Esto
permite almacenar
valores en el rango [-
128, 127].
SHORT Usa el doble de 16 -32768 a 32767 5685
almacenamiento que
el anterior, lo cual
hace posible
representar cualquier
valor en el rango [-
32.768, 32.767].
INT emplea 4 bytes de 32 -2147483648 a -2147483647 32325490
almacenamiento y es
el tipo de dato entero
más empleado
LONG es el tipo entero de 64 -9223372036854775808 a 7,000,356,843
9223372036854775807
mayor tamaño
FLOAT Numeros en coma 32 -3.402823^38 a 3.402823^38 3.14195369463
flotante de simple
precisión. Estandar
IEEE 754-1985 se usan
para guardar números
en memoria que
tienen parte entera y
parte decimal.
DOUBLE Numeros en coma 64 -1.79769313486232^308 a 0.265931348623
flotante de doble 1.79769313486232^308 2^26
precisión. Estandar
IEEE 754-1985. se usan
para guardar números
en memoria que
tienen parte entera y
parte decimal.

Tipos complejos o compuestos en java.

Dado que Java es un lenguaje de programación orientado a objetos no nos debe sorprender el
hecho de que una gran cantidad de los tipos que conforman su sistema de tipos de datos sean
tipos complejos (objetos que provienen de clases). La librería estándar de Java está conformada
por cientos (quizás miles) de clases que representan en última instancia un tipo de dato particular.

Una de las principales clases que conforman estos tipos complejos es la clase String, los String no
son un tipo primitivo (son objetos), sin embargo está conformado por una serie (una cadena) de
chars (los cuales sí son primitivos), al ser una clase como tal, posee una serie de atributos y
métodos que podemos usar para manipular nuestra cadena de caracteres.

String: Con ésta podemos crear cadenas de caracteres con gran facilidad (Strings), La clase String
posee una serie de métodos que nos permiten realizar tareas como determinar el tamaño de la
cadena (el número de caracteres), determinar la posición de un carácter en especifico, reemplazar
ciertas secciones de la cadena por otras, y muchas más.

Scanner: facilita mucho la tarea de leer la entrada de datos por teclado, es decir recibir valores
escritos por el usuario por medio del teclado.

Arraylist: La clase ArrayList permite crear una "colección" de elementos al interior de sí misma, es
similar a un Vector o arreglo, y posee una gran variedad de métodos y atributos que nos permiten
por ejemplo, buscar un elemento cualquiera, insertar un nuevo elemento, eliminarlo, entre otras.
Es básicamente un arreglo pero con una enorme cantidad de facilidades para gestionar los datos
que este contiene.

Declaración de variables en java.

Variables tipo primitivo:


byte b;
boolean myBooleanPrimitive;
int x, y, z; //Declara 3 enteros primitivos

Cada uno de ellos empieza por el tipo de dato, seguido del nombre
de la variable; el cual podemos utilizar el que deseemos.
//Declaración de la variable char;
char michar = 'a';//Los char se ponen entre comilla simple ' '

//Declaración de tipo booleano


boolean miboleano = true;

//Declaración de tipo byte


byte mibyte = 58; //No se debe exceder de 128

//Declaración de tipo short


short mishort = 500;

//Declaración de tipo int


int miint = 245474;

//Declaración de tipo float


float mifloat = 2436.2456f; //se pone una f para decir que es
float

//Declaración de tipo double


double midouble = 2436.2456;

Declaración de variables de tipo complejo en Java

Existe una enorme variedad de tipos complejos en la librería estándar de Java, y la sintaxis para
crear cada uno de estos es similar pero en este casi no solo varía según la naturaleza del tipo (en
este caso complejo) sino que también varía según el tipo de dato como tal (ArrayList, Scanner,
etc.), es decir en última instancia depende el constructor del tipo complejo. La sintaxis es la
siguiente

//Declaración de la variable
TipoComplejo nombreVariable;

//Se le inicializa por medio del constructor la variable


nombreVariable = new TipoComplejo(parametro);

//Se declara la variable y se le asigna un valor al mismo tiempo


TipoComplejo nombreVariable = new TipoComplejo(parametro);
Ahora , vemos como declarar estas variables.

//Declaración de un String notar la S mayúscula


String miString = "Cadena txt";//Los String se ponen entre comilla
doble ""

//Creación de un objeto tipo ArrayList


ArrayList miArray = new ArrayList();
//Un constructor de ArrayList no recibe parámetros.

//Creación de un objeto tipo Scanner


Scanner miScanner = new Scanner(System.in);
//El constructor de Scanner, recibe como parámetro la "entrada"
del sistema

Declaracion y uso de constantes java.

- Modificador FINAL fantasy

Indica que una variable, método o clase no se va a modificar, lo cuál puede ser útil para añadir más
semántica, por cuestiones de rendimiento, y para detectar errores.

– Si una variable se marca como final, no se podrá asignar un nuevo valor a la variable.

– Si una clase se marca como final, no se podrá extender la clase.

– Si es un método el que se declara como final, no se podrá sobreescribir.

Sintaxis:

final tipo_variable nombre_de_variable = valor;

Por ejemplo :
final int unaConstante = 10;

Si tratamos de modificar el valor de una variable con el modificador final, el compilador indicará
un error. Una vez definido el valor no se puede modificar.

Realmente, lo que permanece constante es la asignación de un objeto a esa variable, no los


atributos internos que pueda tener ese objeto. Por ejemplo, en el siguiente caso:

final Ciudadano juan = new Ciudadano();

habríamos creado al ciudadano 'juan' y ya nunca más se le podrá asignar a 'juan' otra instancia de
Ciudadano. Sin embargo, es posible cambiar los datos internos de ese ciudadano:

juan.setApellido("Pérez");

el objeto 'juan' ha cambiado internamente.

Con el modificador final evitaremos lo siguiente:

Ciudadano pepe = new Ciudadano();


juan = pepe;

La última línea no compilaría pues 'juan' fue declarado con final, así que no se le puede asignar
nada nuevo.

CLASES

-Definicion:

Las clases en Java son básicamente una plantilla que sirve para crear un objeto. Si imaginásemos
las clases en el mundo en el que vivimos, podríamos decir que la clase “persona” es una plantilla
sobre cómo debe ser un ser humano. Todos y cada uno de nosotros, los seres humanos, somos
objetos de la clase “persona“, ya que todos somos personas. La clase “persona” contiene la
definición de un ser humano, mientras que cada ser humano es una instancia u objeto de dicha
clase.
Vamos a empezar a construir la clase “persona”. Necesitamos establecer las propiedades de la
clase persona. Como personas, ¿qué propiedades poseemos?

Podríamos hablar de un nombre(s), apellido(s), una fecha en la que nacimos, nuestra edad y
género. Hay muchas otras propiedades que podríamos mencionar, pero por ahora solamente
tomaremos en cuenta las que hemos listado. Son simplemente características que posee todo ser
humano, al menos en la mayoría de los casos.

private String name;


private String lastName;
private String birthDate;
private int age;
private String gender;

Elementos de una clase


Las palabras private, protected y public son atributos de un campo o un método y su
significado es el siguiente:

private: El campo o método sólo es visible dentro de la clase donde se define.

protected: El campo o método es visible en la clase en donde se define y en cualquiera de


sus subclases.

public: El campo o método es visible en cualquier clase.

Ninguna de las anteriores: El campo o método es visible en cualquiera de las clases


pertenecientes al paquete en donde se define.

Objetos

Objeto: entidad existente en la memoria del ordenador que tiene unas propiedades (atributos o
datos sobre sí mismo almacenados por el objeto) y unas operaciones disponibles específicas
(métodos).

Para declarar y crear un objeto de la clase Persona se puede escribir:

Persona p1; // Declaración de la variable p1 de tipo Persona


p1 = new Persona(); // Creación de un objeto de la clase Persona

Nota: con la declaración Persona p1, se está reservando un espacio de memoria para almacenar
una referencia (dirección de memoria) a un objeto de la clase Persona. Al respecto, es importante
comprender que p1 no es un objeto, sino una variable que almacenará la referencia a un objeto
(de la clase Persona) que todavía no existe. Seguidamente, mediante la sentecia p1 = new
Persona(), el operador new creará un objeto de la clase Persona, reservando memoria para
guardar sus atributos (nombre y edad en este caso). Finalmente, con el operador de asignación (=),
la dirección de memoria donde esté creado el objeto, es asignada a p1.

También, se puede indicar lo mismo en una sola línea:

Persona p1 = new Persona();

-Manejo de excepciones:
Una excepción en Java (así como en otros muchos lenguajes de programación) es un error o
situación excepcional que se produce durante la ejecución de un programa. Algunos ejemplos de
errores y situaciones excepcionales son:

Leer un fichero que no existe

Acceder al valor N de una colección que contiene menos de N elementos

Enviar/recibir información por red mientras se produce una perdida de conectividad

El lenguaje Java diferencia claramente entre tres tipos de excepciones: errores, comprobadas (en
adelante checked) y no comprobadas (en adelante unchecked). El gráfico que se muestra a
continuación muestra el árbol de herencia de las excepciones en Java (se omite el paquete de
todas las que aparecen, que es java.lang):

La clase principal de la cual heredan todas las excepciones Java es Throwable. De ella nacen dos
ramas: Error y Exception. La primera representa errores de una magnitud tal que una aplicación
nunca debería intentar realizar nada con ellos (como errores de la JVM, desbordamientos de
buffer, etc) y que por tanto no tienen cabida en este artículo. La segunda rama, encabezada por
Exception, representa aquellos errores que normalmente si solemos gestionar, y a los que
comunmente solemos llamar excepciones.

De Exception nacen múltiples ramas: ClassNotFoundException, IOException, ParseException,


SQLException y otras muchas, todas ellas de tipo checked. La única excepción (valga la
redundancia) es RuntimeException que es de tipo unchecked y encabeza todas las de este tipo.

A pesar de que la diferencia entre las excepciones de tipo checked y unchecked es muy
importante, es también a menudo uno de los aspectos menos entendidos dentro del tratamiento
de excepciones

También podría gustarte