Tipos de Datos Primitivos, Variables, Constantes, Operadores y Paquetes en Java

Tipos de Datos Primitivos

En Java, los tipos de datos primitivos se dividen en categorías como enteros, flotantes, caracteres y booleanos.

Tipos Enteros: byte, short, int, long

Se pueden representar en diferentes bases numéricas usando prefijos: binario (0b), octal (0), decimal (sin prefijo) y hexadecimal (0x).


int decimal = 10; // Decimal
int octal = 010; // Octal, equivale a 8
int binario = 0b10; // Binario, equivale a 2
int hexadecimal = 0x10; // Hexadecimal, equivale a 16
System.out.println("decimal=" + decimal + ", octal=" + octal + ", binario=" + binario + ", hexadecimal=" + hexadecimal);
// Salida: decimal=10, octal=8, binario=2, hexadecimal=16

Tipos Flotantes: float, double

Estos tipos pueden generar errores de redondeo, por lo que se recomienda usar BigDecimal para comparaciones precisas.

Tipo Carácter: char

Los caracteres se almacenan como valores Unicode de 2 bytes y pueden convertirse a enteros. Las secuencias de escape incluyen tabulación ("\t") y salto de línea ("\n").


char caracter = 'A';
System.out.println((int)caracter); // Conversión forzada a entero
// Salida: 65

Tipo Booleano: boolean

Almacena valores verdadero o falso, y no permite conversiones implícitas a otros tipos.

Conversión de Tipos

Durante operaciones, los datos de diferentes tipos se convierten a un tipo común antes del cálculo. El orden de promoción es: byte, short, char → int → long → float → double.

La conversión forzada puede causar pérdida de datos o desbordamiento, mietnras que la conversión automática ocurre de tipos inferiores a superiores.


int valor = 10;
byte byteConvertido = (byte)valor; // Conversión forzada
double dobleConvertido = valor; // Conversión automática

Consideraciones clave:

No se permite convertir booleanos a otros tipos.
La conversión entre tipos incompatibles requeire casting explícito.
Al convertir de un tipo mayor a uno menor, puede haber desbordamiento o pérdida de precisión.
En cálculos con números, se debe convertir antes si hay riesgo de desbordamiento.


System.out.println((int)23.7); // Salida: 23
// En JDK7+, se pueden usar guiones bajos en números para mejorar la legibilidad
int cantidad = 1_000_000_000;
int años = 2;
long resultado = cantidad * ((int)años); // Conversión previa al cálculo

Variables

Las variables deben declararse con un tipo específico y un nombre válido. Existen tres tipos principales:

Variables de clase: Estáticas, pertenecen a la clase.
Variables de instancia: Definidas dentro de la clase pero fuera de métodos, se inicializan con valores predeterminados.
Variables locales: Declaradas e inicializadas dentro de métodos, con alcance limitado.


public class EjemploClase {
    int instanciaVar; // Variable de instancia
    static int claseVar = 1; // Variable de clase
    public void metodo() {
        int localVar = 5; // Variable local
        String texto = "Prueba";
    }
}

Constantes

Se definen con la palabra clave final y suelen nombrarse con mayúsculas y guiones bajos.


final static double PI = 3.14159;

Operadores

Java ofrece varios operadores, inclyuendo aritméticos (+, -, *, /, %, ++, --), de asignación (=), relacionales (>, <, ==, !=), lógicos (&&, ||, !), bit a bit (&, |, ^, ~, <<, >>, >>>), condicionales (? :), y de asignación compuesta (+=, -=).


public static void ejemploOperadores() {
    int num1 = 10;
    long num2 = 10;
    short num3 = 10;
    byte num4 = 10;
    int num5 = 10;
    int num6 = 23;
    // Resultado de operaciones depende de los tipos involucrados
    System.out.println(num1 + num1); // 20, tipo int
    System.out.println(num1 - num2); // 0, tipo long
    System.out.println(num1 * num3); // 100, tipo int
    System.out.println(num1 / num4); // 1, tipo int
    // Operadores relacionales
    System.out.println(num1 > num5); // false
    System.out.println(num1 == num5); // true
    // Operador módulo
    System.out.println(num6 % num1); // 3
    // Operadores de incremento/decremento
    int contador = 1;
    int postIncremento = contador++; // Asignación luego incremento
    int preIncremento = ++contador; // Incremento luego asignación
    System.out.println("contador=" + contador + ", post=" + postIncremento + ", pre=" + preIncremento);
    // Ejemplo con Math.pow para potencias
    double potencia = Math.pow(2, 3);
    System.out.println(potencia); // 8.0
}

Los operadores lógicos incluyen cortocircuito: en &&, si el primer operando es falso, el segundo no se evalúa; en ||, si el primero es verdadero, el segundo no se evalúa.

La conversión bit a bit permite manipular bits individuales, útil en operaciones de bajo nivel.

El operador condicional ? : selecciona entre dos valores basado en una condición.

Mecanismo de Paquetes

Los paquetes organizan clases y evitan conflictos de nombres. Se nombran típicamente siguiendo convenciones de dominio invertido. Se usa import para acceder a clases de otros paquetes.

Documentación con JavaDoc

JavaDoc genera documentación API a partir de comentarios en el código. Las etiquetas comunes incluyen:

@author para el autor.
@version para la versión.
@since para indicar la versión mínima de JDK.
@param para describir parámetros.
@return para describir valores de retorno.
@throws para excepciones lanzadas.

Para generar la documentación, se ejecuta el comando:


javadoc -encoding UTF-8 -charset UTF-8 NombreArchivo.java

Etiquetas: java Tipos de Datos Primitivos variables constantes operadores

Publicado el 7-10 03:13

Friki Work