• Síguenos en :

Aprende los Tipos de Datos Primitivos en Java

Guía completa sobre tipos de datos enteros, flotantes, caracteres y booleanos en Java. Conceptos básicos, declaración de variables primitivas y más.

Aprende los Tipos de Datos Primitivos en Java

Aprende los Tipos de Datos Primitivos en Java desde Cero

¡Hola! Bienvenido a esta nueva clase donde aprenderás sobre los tipos de datos primitivos en Java. Dominar este concepto es fundamental para poder programar en este lenguaje.

Los tipos de datos primitivos son los tipos de datos más básicos que existen en Java. Son los "ladrillos" con los que construiremos programas más complejos.

Índice

¿Qué son los tipos de datos primitivos en Java?

Un tipo de dato primitivo define el tamaño y tipo de valor que puede almacenar una variable. Java define 8 tipos de datos primitivos que se pueden usar para declarar variables y asignarles valores.

Estos son los 8 tipos de datos primitivos en Java:

  • - 4 tipos enteros: byte, short, int y long

  • - 2 tipos de punto flotante: float y double

  • - 1 tipo de caracter: char

  • - 1 tipo booleano: boolean

Características de los tipos de datos primitivos

Las principales características de los tipos de datos primitivos son:

  • - Tamaño fijo: cada tipo primitivo ocupa un espacio predefinido en memoria.

  • - Valor por defecto: cada tipo tiene un valor por defecto cuando se declara la variable pero no se inicializa.

  • - Rango de valores: cada tipo puede almacenar un rango limitado de valores.

  • - Rápido acceso: al estar en memoria el acceso es directo y rápido.

A diferencia de los objetos, los tipos de datos primitivos no son clases en Java. Veamos cada tipo en detalle:

Declaración de variables

Para declarar una variable en Java se especifica el tipo de dato y el nombre:

tipoDato nombreVariable = valor;

Por ejemplo:

int cantidad = 10;

Es buena práctica iniciar las variables primitivas con un valor asignado. También se pueden declarar múltiples variables del mismo tipo en la misma línea:

byte edad, cantidad;

Tipos de datos numéricos

Java tiene dos categorías de tipos de datos numéricos primitivos: enteros y de punto flotante.

Enteros (byte, short, int, long)

Los enteros son para representar números sin decimales. Existen 4 tamaños:

  • - byte: ocupa 1 byte y almacena entre -128 a 127.

  • - short: ocupa 2 bytes y almacena entre -32768 a 32767.

  • - int: ocupa 4 bytes y almacena entre -2147483648 a 2147483647. Es el entero más utilizado.

  • - long: ocupa 8 bytes y almacena entre -9223372036854775808 a 9223372036854775807. Para declarar un literal long se agrega "L" al final.

byte edad = 35;

short suma = 23 + 34;

int contador = 0;

long poblacion = 21474836470L;

Flotantes (float, double)

Los flotantes representan números con decimales. Existen 2 tipos:

  • - float: ocupa 4 bytes y tiene una precisión de 7 dígitos decimales. Para declarar un literal float se agrega "f" al final.

  • - double: ocupa 8 bytes y tiene una precisión de 15 dígitos decimales. Es el tipo float más utilizado.

float promedio =  4.95f;

double raiz = Math.sqrt(9.0);

Tipos de datos de caracteres

Java tiene dos tipos de datos para almacenar caracteres individuales y valores booleanos verdadero/falso.

char

El tipo char almacena un caracter Unicode de 16 bits. Se declara entre comillas simples:

char letra = 'A';

String

El tipo String no es técnicamente un tipo primitivo, es una clase en Java. Pero se utiliza para representar cadenas de texto con cualquier longitud. Se declara con comillas dobles:

String nombre = "Juan";

boolean

El tipo boolean solo puede tener los valores true o false. Es muy útil para almacenar resultados de evaluaciones lógicas:

int edad = 50;

// En este caso la variable esMayor almacenará true; esMayor = true
boolean esMayor = edad >= 18;

Literales y constantes

Un literal es un valor fijo que se escribe directamente en el código fuente.

Los literales en Java deben coincidir con el tipo de dato de la variable:

byte numBytes = 127;

int cuenta = 100;

long millas = 1_000_000_000L;

double precio = 9.99;

boolean encendido = true;

char letra = 'Z';

Las constantes son variables que su valor no cambia y se declaran con final. Por convención se escriben en mayúsculas:

final float PI = 3.1416f;

Operadores aritméticos

Los operadores aritméticos permiten realizar operaciones matemáticas con valores primitivos:

  • - Suma (+)

  • - Resta (-)

  • - Multiplicación (*)

  • - División (/)

  • - Módulo (%) obtiene el resto de una división

Por ejemplo:

int suma = 15 + 20;

double promedio = suma / 5.0;

int resto = 10 % 3; // resto = 1

Conversiones entre tipos

En Java se pueden convertir valores de un tipo primitivo a otro explícitamente con casting:

int numero = 10;
byte byte = (byte) numero;

Esto puede provocar pérdida de precisión o error en tiempo de ejecución si el valor está fuera de rango.

También existen los wrappers que son clases equivalentes a los primitivos como Integer, Long, Double, etc. Permiten convertir a objetos cuando sea necesario.

Buenas prácticas

Algunas buenas prácticas al trabajar con tipos de datos primitivos:

  • - Elegir siempre el tipo de dato más pequeño posible que admita el rango de valores necesario. Esto optimiza memoria.

  • - Realizar conversiones explícitas con casting cuando sea necesario para prevenir errores.

  • - Inicializar las variables primitivas al declararlas.

  • - Utilizar nombres auto-explicativos para las variables.

  • - Para números largos utilizar el guión bajo "_" como separador de miles para mayor legibilidad.

Conclusión

Y con esto terminamos la clase de hoy. ¡Ahora ya sabes cómo trabajar con los distintos tipos de datos primitivos en Java! Los conceptos vistos aquí son fundamentales para continuar con tu aprendizaje, si tienes alguna duda no olvides dejarla en los comentarios.

A continuación te dejo 5 ejercicios resueltos para que practiques estos conceptos.

IMPORTANTE:

Puedes ver todo el código utilizado en el apartado en el siguiente enlace

Qué es Java y para qué sirve
Anterior Clase

Qué es Java y para qué sirve
Variables y constantes en Java
Siguiente Clase

Variables y constantes en Java

Ejercicios Resueltos

  • Ejercicio 1

    Declara variables para almacenar los siguientes datos e imprímelos:

    • - Nombre de una persona

    • - Edad de la persona

    • - Si tiene mascota o no

    public class Ejercicio1 {

    public static void main(String[] args) {

        // Declaramos las variables con estos tipos básicos
        String nombre = "Juan";
        int edad = 25;
        boolean tieneMascota = true;

        // Mostramos por terminal las variables declaradas
        System.out.println("Nombre: " + nombre);
        System.out.println("Edad: " + edad);
        System.out.println("¿Tiene mascota?: " + tieneMascota);

    }

}

  • Ejercicio 2

    Declara 3 constantes para almacenar tu nombre completo y muéstralas en pantalla.

    public class Ejercicio2 {

    public static void main(String[] args) {

        // Declaramos las CONSTANTES con estos tipos básicos
        final String NOMBRE = "Carlos";
        final String APELLIDO_PATERNO = "Gomez";
        final String APELLIDO_MATERNO = "Perez";

        // Mostramos por terminal las CONSTANTES declaradas
        System.out.println(NOMBRE);
        System.out.println(APELLIDO_PATERNO);
        System.out.println(APELLIDO_MATERNO);

    }

}

  • Ejercicio 3

    Declara variables para las siguientes conversiones e imprime los resultados:

    • - Un float de 10.5 a int

    • - Un double de 125.8 a long

    • - Un int de 100 a byte

    public class Ejercicio3 {

    public static void main(String[] args) {

        float flotante = 10.5f;
        int entero = (int) flotante;

        double doble = 125.8;
        long largo = (long) doble;

        int numero = 100;
        byte numero_byte = (byte) numero;

        System.out.println(entero);
        System.out.println(largo);
        System.out.println(numero_byte);

    }

}

  • Ejercicio 4

    Realiza las siguientes operaciones entre variables enteras y doubles:

    • - Suma de dos int

    • - Resta de un double menos un int

    • - Un double multiplicado por un int

    • - Un int dividido entre un double

    public class Ejercicio4 {

    public static void main(String[] args) {

        int num1 = 15;
        int num2 = 30;
        double num3 = 18.5;

        int suma = num1 + num2;
        double resta = num3 - num1;
        double producto = num3 * num2;
        double division = num2 / num3;

        System.out.println("Suma: " + suma);
        System.out.println("Resta: " + resta);
        System.out.println("Producto: " + producto);
        System.out.println("Division: " + division);

    }

}

  • Ejercicio 5

    Realiza un programa que calcule el área y perímetro de un rectángulo con base de 5.6 y altura de 8.2. Usa variables double.

    public class Ejercicio5 {

    public static void main(String[] args) {

        // Declaramos las variables que contienen el area y la altura
        double base = 5.6;
        double altura = 8.2;

        // Hacemos los cálculos del area y del perímetro
        double area = base * altura;
        double perimetro = (base + altura) * 2;

        // Mostramos los resultados de los cálculos
        System.out.println("Area: " + area);
        System.out.println("Perimetro: " + perimetro);
    }

}

Preguntas Frecuentes

Si, pero no es recomendable. Lo mejor es siempre inicializar las variables primitivas.

Ocurrirá un desbordamiento y se asignará un valor incorrecto.

Para optimizar memoria cuando sepamos que no necesitamos valores tan amplios.

Deja un Comentario

¡Bienvenido a nuestro sitio web!

Este sitio utiliza cookies para mejorar tu experiencia de navegación y proporcionar funciones adicionales relacionadas con el análisis de tráfico y el rendimiento del sitio. Política de cookies.