Comandos del Sistéma Operativo

Comandos frecuentes en la línea de comandos:

# Cambiar unidad de disco
LetraUnidad: (ej: D:)
# Listar contenido del directorio actual
dir
# Navegar entre directorios
cd directorio (ej: cd ..) (ej: C:\Usuarios\hwj> cd /d E:\Junior)
# Limpiar pantalla
cls
# Cerrar terminal
exit
# Consultar configuración de red
ipconfig
# Ejecutar aplicaciones
calc
mspaint
notepad
# Comprobar conectividad
ping www.google.com
# Operaciones con archivos
mkdir nombre_directorio
rmdir nombre_directorio
echo. > nombre_archivo
del nombre_archivo

Configuración del JDK

Eliminación del JDK

1. Eliminar el directorio de instalación del JDK
2. Quitar la variable de entorno JAVA_HOME
3. Remover las referencias a Java de la variable PATH
4. Verificar en la terminal con: java -version

Instalación del JDK

1. Descargar e instalar desde la página oficial (recordar la ruta de instalación)
2. Configurar la variable de entorno JAVA_HOME
3. Configurar la variable PATH incluyendo los directorios bin y jre del JDK
4. Confirmar la instalación ejecutando: java -version

Elemantos Básicos de Java

Comentarios en el Código

// Comentario de una sola línea

/*
Comentario de múltiples líneas
Puede abarcar varias líneas
*/

/**
 * Documentación JavaDoc para clases y métodos.
 */

Identificadores y Palabras Clave

Las palabras clave de Java son términos reservados que no pueden usarse como identificadores.

Reglas para los identificadores: deben empezar con una letra, guion bajo o signo de dólar; no pueden empezar con un número; no pueden ser palabras clave; distinguen entre mayúsculas y minúsculas.

Tipos de Datos

Lenguaje de Tipado Fuerte

Java es un lenguaje de tipado fuerte, lo que significa que cada variable debe declararse con un tipo específico y solo puede contener valores de ese tipo.

Categorías de Tipos en Java

Tipos Primitivos (Ocho tipos fundamentales)

Tipos Numéricos Enteros

int enteroComun = 100;
byte enteroCorto = 127;
short enteroMedio = 32000;
long enteroLargo = 123456789L;

Tipos de Punto Flotante

float decimalSimple = 3.14f;
double decimalDoble = 3.14159265358979;

Tipo Carácter

char caracter = 'A';
String cadena = "String es una clase, no una palabra clave";

Tipo Booleano

boolean bandera = false;

Tipos de Referencia

Incluyen clases, interfaces y arreglos.

Conversión de Tipos

Conversión Explícita (Casting)

Conversión Implícita (Widening)

int valorGrande = 128;
byte valorPequeno = (byte)valorGrande; // Desbordamiento

System.out.println(valorGrande); // 128
System.out.println(valorPequeno); // -128

Consideraciones importantes:

1. No se puede convertir un booleano a otro tipo.
2. No se pueden convertir tipos incompatibles.
3. La conversión de un tipo mayor a uno menor requiere casting explícito.
4. Las conversiones pueden causar desbordamiento o pérdida de precisión.

// Ejemplo de desbordamiento con operaciones grandes
int capital = 1_000_000_000;
int periodo = 20;
long resultado = (long)capital * periodo;
System.out.println(resultado);

Conceptos Extendidos de Tipos de Datos

// Representación numérica en diferentes bases
int decimal = 10;
int octal = 010;    // Base 8
int hexadecimal = 0x10; // Base 16

System.out.println(decimal); // 10
System.out.println(octal);   // 8
System.out.println(hexadecimal); // 16

// Comparación de números de punto flotante (problemático)
float f = 0.1f;
double d = 1.0 / 10;
System.out.println(f == d); // false

// Los caracteres se almacenan como valores numéricos
char ch = 'a';
System.out.println((int)ch); // 97

// Secuencias de escape
System.out.println("Texto\tcon tabulador\ny salto de línea");

// Comparación de cadenas
String s1 = new String("Hola");
String s2 = new String("Hola");
System.out.println(s1 == s2); // false (compara referencias)

String s3 = "Hola";
String s4 = "Hola";
System.out.println(s3 == s4); // true (misma referencia)

Variables

Ámbito de las Variables

Variables de Clace (Estáticas)

Variables de Instancia (No estáticas)

Variables Locales

// Variable de clase (estática)
static double salarioBase = 2500.0;

// Variable de instancia
String nombre;
int edad;

public static void main(String[] args) {
    // Variable local
    int contador = 0;
    
    // Uso de variable de instancia mediante un objeto
    EjemploVariables objeto = new EjemploVariables();
    System.out.println(objeto.nombre); // null
    System.out.println(objeto.edad);   // 0
    
    // Uso de variable de clase
    System.out.println(salarioBase);
}

Reglas de nombrado: usar camelCase para variables, nombres descriptivos, evitar palabras clave.

Constantes

// Definición de una constante
static final double PI = 3.1415926535;

public static void main(String[] args) {
    System.out.println(PI);
}

Operadores

Operadores de Incremento y Decremento

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

System.out.println(a); // 7
System.out.println(b); // 5
System.out.println(c); // 7

// Potenciación
double potencia = Math.pow(2, 8); // 256.0

Operadores Lógicos

boolean x = true;
boolean y = false;

System.out.println(x && y); // AND: false
System.out.println(x || y); // OR: true
System.out.println(!x);     // NOT: false

// Cortocircuito lógico
int valor = 5;
boolean resultado = (valor > 10) && (valor++ > 0);
System.out.println(resultado); // false
System.out.println(valor);     // 5 (no se incrementó)

Operadores a Nivel de Bits

// Operaciones bit a bit
System.out.println(2 << 4); // Desplazamiento a la izquierda (multiplicar por 2^4): 32

Operador Ternario

int edad = 20;
String categoria = (edad >= 18) ? "Adulto" : "Menor";
System.out.println(categoria); // Adulto

// Concatenación con cadenas
System.out.println("" + 10 + 20); // "1020"
System.out.println(10 + 20 + ""); // "30"

Paquetes

Se recomienda usar el dominio invertido de la empresa como nombre de paquete (ej: com.empresa.proyecto).

Documentación con JavaDoc

/**
 * Clase que demuestra la documentación JavaDoc.
 * @author Nombre del Autor
 * @version 1.0
 * @since 2023
 */
public class DocumentacionEjemplo {
    
    /**
     * Método que calcula la suma de dos números.
     * @param num1 Primer número entero
     * @param num2 Segundo número entero
     * @return La suma de los dos números
     */
    public int sumar(int num1, int num2) {
        return num1 + num2;
    }
}

Se puede generar la documentación usando el comando javadoc o herramientas del IDE.

Control de Flujo

Entrada de Usuario con Scanner

import java.util.Scanner;

// Ejemplo con next() - no lee espacios
Scanner lector = new Scanner(System.in);
System.out.print("Ingrese una palabra: ");
if (lector.hasNext()) {
    String palabra = lector.next();
    System.out.println("Palabra: " + palabra);
}
lector.close();

// Ejemplo con nextLine() - lee toda la línea
Scanner lectorLinea = new Scanner(System.in);
System.out.print("Ingrese una línea: ");
if (lectorLinea.hasNextLine()) {
    String linea = lectorLinea.nextLine();
    System.out.println("Línea: " + linea);
}
lectorLinea.close();

Entrada Avanzada con Validación

import java.util.Scanner;

Scanner lectorNumeros = new Scanner(System.in);
int entero = 0;
double decimal = 0.0;

System.out.print("Ingrese un entero: ");
if (lectorNumeros.hasNextInt()) {
    entero = lectorNumeros.nextInt();
    System.out.println("Entero: " + entero);
} else {
    System.out.println("No ingresó un entero válido.");
}

System.out.print("Ingrese un decimal: ");
if (lectorNumeros.hasNextDouble()) {
    decimal = lectorNumeros.nextDouble();
    System.out.println("Decimal: " + decimal);
} else {
    System.out.println("No ingresó un decimal válido.");
}
lectorNumeros.close();

Acumulación de Valores

import java.util.Scanner;

Scanner entrada = new Scanner(System.in);
double suma = 0;
int cantidad = 0;

System.out.println("Ingrese números (texto para terminar):");
while (entrada.hasNextDouble()) {
    double numero = entrada.nextDouble();
    cantidad++;
    suma += numero;
}
System.out.println("Total: " + suma);
System.out.println("Promedio: " + (suma / cantidad));
entrada.close();

Estructuras de Selección

Sentencia if-else

int calificacion = 85;
if (calificacion >= 90) {
    System.out.println("Excelente");
} else if (calificacion >= 80) {
    System.out.println("Bueno");
} else if (calificacion >= 70) {
    System.out.println("Aprobado");
} else {
    System.out.println("Reprobado");
}

Sentencia switch

String dia = "Lunes";
switch (dia) {
    case "Lunes":
    case "Martes":
    case "Miércoles":
    case "Jueves":
    case "Viernes":
        System.out.println("Día laboral");
        break;
    case "Sábado":
    case "Domingo":
        System.out.println("Fin de semana");
        break;
    default:
        System.out.println("Día no válido");
}

Estructuras de Repetición

Bucle while

// Suma de los primeros 100 números naturales
int suma = 0;
int contador = 1;
while (contador <= 100) {
    suma += contador;
    contador++;
}
System.out.println("Suma: " + suma);

Bucle do-while

int suma = 0;
int contador = 1;
do {
    suma += contador;
    contador++;
} while (contador <= 100);
System.out.println("Suma: " + suma);

Bucle for

// Ejemplo: Números divisibles por 5
int contadorLinea = 0;
for (int i = 1; i <= 500; i++) {
    if (i % 5 == 0) {
        System.out.printf("%4d", i);
        contadorLinea++;
        if (contadorLinea % 5 == 0) {
            System.out.println();
        }
    }
}

// Ejemplo: Tabla de multiplicar
for (int fila = 1; fila <= 9; fila++) {
    for (int columna = 1; columna <= fila; columna++) {
        System.out.printf("%d x %d = %2d\t", columna, fila, columna * fila);
    }
    System.out.println();
}

For-Each (Mejroado)

double[] precios = {19.99, 24.50, 7.99, 45.00};
for (double precio : precios) {
    System.out.printf("$%.2f%n", precio);
}

Control de Bucles: break y continue

// break: Sale del bucle
for (int i = 0; i < 100; i++) {
    if (i == 50) break;
    System.out.print(i + " ");
}

// continue: Salta a la siguiente iteración
for (int i = 0; i < 100; i++) {
    if (i % 10 == 0) {
        System.out.println();
        continue;
    }
    System.out.printf("%4d", i);
}

Métodos

Definición y Llamada

public class Calculadora {
    public static void main(String[] args) {
        double resultado = calcularAreaCirculo(5.0);
        System.out.println("Área: " + resultado);
    }
    
    public static double calcularAreaCirculo(double radio) {
        return Math.PI * radio * radio;
    }
    
    public static int encontrarMaximo(int a, int b) {
        return Math.max(a, b);
    }
}

Sobrecarga de Métodos

public class Calculadora {
    // Suma enteros
    public int sumar(int a, int b) {
        return a + b;
    }
    
    // Suma decimales
    public double sumar(double a, double b) {
        return a + b;
    }
    
    // Suma tres números
    public int sumar(int a, int b, int c) {
        return a + b + c;
    }
}

Parámetros Variables (Varargs)

public static double calcularPromedio(double... numeros) {
    if (numeros.length == 0) return 0;
    
    double suma = 0;
    for (double num : numeros) {
        suma += num;
    }
    return suma / numeros.length;
}

Recursividad

public static long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

Arreglos

Declaración e Inicialización

// Declaración e inicialización estática
int[] numeros = {10, 20, 30, 40, 50};

// Declaración e inicialización dinámica
double[] precios = new double[5];
precios[0] = 19.99;
precios[1] = 24.50;

Arreglos Bidimensionales

int[][] matriz = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

for (int fila = 0; fila < matriz.length; fila++) {
    for (int col = 0; col < matriz[fila].length; col++) {
        System.out.printf("%4d", matriz[fila][col]);
    }
    System.out.println();
}

Clase Arrays

import java.util.Arrays;

int[] datos = {5, 2, 9, 1, 7};
System.out.println(Arrays.toString(datos));

Arrays.sort(datos);
System.out.println("Ordenado: " + Arrays.toString(datos));

Arrays.fill(datos, 0);
System.out.println("Llenado con ceros: " + Arrays.toString(datos));

Ordenamiento por Burbuja

public static void burbujaMejorada(int[] arr) {
    boolean intercambiado;
    for (int i = 0; i < arr.length - 1; i++) {
        intercambiado = false;
        for (int j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                intercambiado = true;
            }
        }
        if (!intercambiado) break;
    }
}

Arreglo Disperso (Ejemplo)

// Ejemplo de conversión a arreglo disperso (para matrices con muchos ceros)

Programación Orientada a Objetos

Clases y Objetos

public class Persona {
    // Atributos
    private String nombre;
    private int edad;
    
    // Constructor
    public Persona(String nombre, int edad) {
        this.nombre = nombre;
        this.edad = edad;
    }
    
    // Métodos
    public void saludar() {
        System.out.println("Hola, soy " + nombre);
    }
    
    // Getters y Setters
    public String getNombre() {
        return nombre;
    }
    
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
}

Encapsulamiento

Los atributos se declaran como privados y se acceden mediante métodos públicos (getters/setters).

Herencia

public class Estudiante extends Persona {
    private String carrera;
    
    public Estudiante(String nombre, int edad, String carrera) {
        super(nombre, edad);
        this.carrera = carrera;
    }
    
    @Override
    public void saludar() {
        super.saludar();
        System.out.println("Estudio " + carrera);
    }
}

Polimorfismo

Persona persona = new Persona("Ana", 25);
Persona estudiante = new Estudiante("Luis", 20, "Ingeniería");

persona.saludar();   // Llama al método de Persona
estudiante.saludar(); // Llama al método sobrescrito de Estudiante

Abstracción

public abstract class Figura {
    public abstract double calcularArea();
    
    public void mostrarInfo() {
        System.out.println("Área: " + calcularArea());
    }
}

public class Circulo extends Figura {
    private double radio;
    
    public Circulo(double radio) {
        this.radio = radio;
    }
    
    @Override
    public double calcularArea() {
        return Math.PI * radio * radio;
    }
}

Interfaces

public interface Dibujable {
    void dibujar();
    default void mostrarBorde() {
        System.out.println("Mostrando borde");
    }
}

public class CirculoDibujable extends Circulo implements Dibujable {
    public CirculoDibujable(double radio) {
        super(radio);
    }
    
    @Override
    public void dibujar() {
        System.out.println("Dibujando círculo");
    }
}

Manejo de Excepciones

Tipo de Excepciones

Las excepciones se dividen en: excepciones verificadas (checked) y no verificadas (unchecked).

Bloques try-catch-finally

try {
    int resultado = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Error aritmético: " + e.getMessage());
} catch (Exception e) {
    System.out.println("Error general: " + e.getMessage());
} finally {
    System.out.println("Este bloque siempre se ejecuta");
}

Excepciones Personalizadas

public class EdadInvalidaException extends Exception {
    private int edad;
    
    public EdadInvalidaException(int edad) {
        super("Edad no válida: " + edad);
        this.edad = edad;
    }
    
    public int getEdad() {
        return edad;
    }
}

// Uso
public void validarEdad(int edad) throws EdadInvalidaException {
    if (edad < 0 || edad > 150) {
        throw new EdadInvalidaException(edad);
    }
}

Buenas prácticas: usar excepciones específicas, cerrar recursos en finally, no usar excepciones para flujo de control normal.