Datos y Expresiones

Semestre 02, 2026

Cadenas (Strings)

Una cadena puede contener cualquier carácter válido, incluyendo números, signos de puntuación y otros símbolos. Se escribe entre comillas dobles.
Una cadena vacía es válida: "".
En Java, las cadenas pertenecen a la clase String.


"Hola, mundo!"
"10 de octubre de 2012"
""

Concatenación de cadenas


System.out.print("Hola");
System.out.println(" Mundo!");

System.out.print("Hola");

print() imprime sin avanzar de línea.

Concatenación de cadenas


System.out.print("Hola");
System.out.println(" Mundo!");

System.out.println(" Mundo!");

println() imprime y luego hace un salto de línea.

El operador +

El operador + se usa para concatenar cadenas.

Concatena de izq. a der.


System.out.println("24 and 45 concatenated: " + 24 + 45);
// 24 and 45 concatenated: 2445

Paréntesis suman primero


System.out.println("24 and 45 added: " + (24 + 45));
// 24 and 45 added: 69

Secuencias de escape

Java tiene secuencias de escape para representar caracteres especiales dentro de cadenas.

Secuencia	Significado
`\b`	backspace
`\t`	tabulación
`\n`	nueva línea
`\r`	retorno de carro
`\"`	comilla doble
`\'`	comilla simple
`\\`	barra invertida


System.out.println("Hola\nMundo");

Variables y tipos de datos

Una variable es un nombre para una ubicación en memoria que almacena datos.

Declaración


int total;
double precio;
char letra;

Asignación


total = 10;
int numero = 6;

Se pueden declarar múltiples variables del mismo tipo:


int x, y, z;

Constantes

Se declaran con la palabra clave final.
Por convención, se escriben en MAYÚSCULAS.


final int MAX_USERS = 100;

Tipos de datos primitivos

Son los tipos de datos más básicos en Java.
Representan valores simples: números, caracteres y valores lógicos.
No son objetos (aunque Java tiene clases wrapper como Integer, Double, etc.).
Son 8 tipos, agrupados en 4 categorías principales.

4 categorías

Categoría	Tipos incluidos
Enteros	`byte`, `short`, `int`, `long`
Punto flotante	`float`, `double`
Caracteres	`char`
Booleanos	`boolean`

Enteros

Tipo	Tamaño	Rango
`byte`	8 bits	-128 a 127
`short`	16 bits	-32,768 a 32,767
`int`	32 bits	-2,147,483,648 a 2,147,483,647
`long`	64 bits	-9×10¹⁸ a 9×10¹⁸ (aprox.)

Decimales

Tipo	Tamaño	Precisión
`float`	32 bits	~7 dígitos decimales
`double`	64 bits	~15 dígitos decimales

Caracteres

El tipo char representa un solo carácter Unicode (16 bits). Puede almacenar cualquier símbolo Unicode.


char letra = 'A';
char simbolo = '$';
char unicode = '\u0041'; // A

Booleanos

El tipo boolean solo puede tener dos valores: true y false.


boolean activo = true;
boolean terminado = false;

Características

Eficientes: se almacenan directamente en memoria sin la sobrecarga de los objetos.

Inmutables: el valor almacenado no puede cambiar de tipo.

Fuertemente tipados: no puedes asignar un double a un int sin casting explícito.

Operadores aritméticos

Operador	Descripción
`+`	Suma
`-`	Resta
`*`	Multiplicación
`/`	División
`%`	Residuo (módulo)

Precedencia (PEMDASA)


int result  = 14 + 8 / 2;          // 18
int result2 = 3 * ((18 - 4) / 2);  // 21

Incremento y decremento

Los operadores ++ y -- aumentan o disminuyen el valor de una variable en una unidad de forma más concisa.


count++;   // Postfijo: después de usar el valor actual
++count;   // Prefijo: antes de usar el valor actual

// Equivalente a:
count = count + 1;

int a = 5;
int b = a++;  // b = 5, luego a = 6
int c = ++a;  // a = 7, luego c = 7

Relacionales

Comparan dos valores y devuelven un resultado booleano (true o false).

Operador	Significado	Ejemplo
`==`	Igual a	`a == b`
`!=`	Distinto de	`a != b`
`>`	Mayor que	`a > b`
`<`	Menor que	`a < b`
`>=`	Mayor o igual que	`a >= b`
`<=`	Menor o igual que	`a <= b`


int x = 10, y = 20;
boolean resultado = x < y; // true

Lógicos

Permiten combinar expresiones booleanas.

Operador	Nombre	Descripción
`&&`	AND	Verdadero si ambos operandos son `true`
`\|\|`	OR	Verdadero si al menos un operando es `true`
`!`	NOT	Invierte el valor lógico


boolean a = true, b = false;
System.out.println(a && b); // false
System.out.println(a || b); // true
System.out.println(!a);     // false

Asignación compuesta

Abrevia operaciones aritméticas combinadas con asignación.

Operador	Ejemplo	Equivalente
`+=`	`x += y;`	`x = x + y;`
`-=`	`x -= y;`	`x = x - y;`
`*=`	`x *= y;`	`x = x * y;`
`/=`	`x /= y;`	`x = x / y;`
`%=`	`x %= y;`	`x = x % y;`


int total = 10;
total += 5;  // total = 15
total *= 2;  // total = 30
total %= 7;  // total = 2

Código más limpio y conciso.

Reduce errores en cálculos repetitivos.

Conversión de tipos

En Java, las conversiones de tipo permiten transformar un valor de un tipo de dato primitivo a otro.

Widening (ampliación)

Conversión automática, de tipo pequeño a grande, sin pérdida. También llamada type promotion.


int num = 42;
double resultado = num; // int -> double

Narrowing (reducción)

Conversión explícita; requiere cast y puede perder datos. También llamada type casting.


double pi = 3.14;
int entero = (int) pi; // 3

⚠️ ¡Cuidado! La conversión puede truncar valores si el rango del tipo destino es menor.

Resumen

Conversión	Automática	Necesita cast	Posible pérdida
Widening	✅	❌	❌
Narrowing	❌	✅	✅

Scanner

La clase Scanner permite leer datos desde distintas fuentes, como la entrada estándar del teclado. Pertenece al paquete java.util y debe ser importada.


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Ingrese su nombre: ");
        String nombre = teclado.nextLine();
        System.out.print("Ingrese su edad: ");
        int edad = teclado.nextInt();
    }
}

Leer datos con Scanner


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Ingrese su nombre: ");
        String nombre = teclado.nextLine();
        System.out.print("Ingrese su edad: ");
        int edad = teclado.nextInt();
    }
}

import java.util.Scanner;

Importamos la clase Scanner desde el paquete java.util.

Leer datos con Scanner


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Ingrese su nombre: ");
        String nombre = teclado.nextLine();
        System.out.print("Ingrese su edad: ");
        int edad = teclado.nextInt();
    }
}

Scanner teclado = new Scanner(System.in);

Creamos un Scanner sobre System.in: la entrada estándar del teclado.

Leer datos con Scanner


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Ingrese su nombre: ");
        String nombre = teclado.nextLine();
        System.out.print("Ingrese su edad: ");
        int edad = teclado.nextInt();
    }
}

String nombre = teclado.nextLine();

Pedimos y leemos una línea de texto completa con nextLine().

Leer datos con Scanner


import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        System.out.print("Ingrese su nombre: ");
        String nombre = teclado.nextLine();
        System.out.print("Ingrese su edad: ");
        int edad = teclado.nextInt();
    }
}

int edad = teclado.nextInt();

Pedimos y leemos un número entero con nextInt().

Notas importantes

nextLine() → lee una línea completa (incluye espacios).

nextInt(), nextDouble() → leen valores numéricos (ignoran saltos de línea).

next() → lee una sola palabra (hasta un espacio).

Scanner usa espacios en blanco como delimitadores predeterminados.

Limpiar el buffer

Después de usar métodos como nextInt(), puede ser necesario limpiar el buffer con nextLine() para evitar errores de lectura.


System.out.print("Ingrese un número entero: ");
int numero = teclado.nextInt();

teclado.nextLine(); // Limpia el salto de línea pendiente

System.out.print("Ingrese su dirección: ");
String direccion = teclado.nextLine();