Apuntes_Java1.java

package inteligencia.operativa;

import java.io.*;
import java.util.*;
import java.time.*;
import java.util.regex.*;
import java.util.stream.*;
import java.net.*;

/**
 * PROTOCOLO DE ENTRENAMIENTO JAVA - DOCTRINA COMPLETA
 * ----------------------------------------------------
 * 1. Concepto: Implementación integral de todo el syllabus técnico operativo.
 * 2. Implementación: Estructura modular única con documentación incrustada.
 * 3. Utilidad: Despliegue inmediato de capacidades de ciberinteligencia.
 */
public class DoctrinaCompletaJava {

    // ========================================================================
    // SECCIÓN 1: FUNDAMENTOS (SYNTAX, OUTPUT, COMMENTS, VARIABLES, TYPES)
    // ========================================================================

    // 1.1 JAVA SYNTAX / OUTPUT / COMMENTS
    // 1. Concepto: Reglas estructurales y comunicación de salida.
    // 2. Implementación: Claves {}, punto y coma, System.out.println.
    // 3. Utilidad: Base estándar para cualquier script ejecutable.
    static void fundamentosSalida() {
        System.out.println("INICIANDO SISTEMA"); // Output estándar
        // Comentario de línea: Notas operativas temporales.
        /* Comentario bloque: Documentación persistente de misión. */
    }

    // 1.2 JAVA VARIABLES / DATA TYPES / TYPE CASTING
    // 1. Concepto: Almacenamiento tipado y conversión de memoria.
    // 2. Implementación: int, double, boolean, (tipo) variable.
    // 3. Utilidad: Gestión precisa de recursos numéricos y estados.
    static void gestionVariables() {
        int id = 101; double precision = 0.99; boolean activo = true;
        int convertido = (int) precision; // Casting explícito
    }

    // 1.3 JAVA OPERATORS / STRINGS / MATH / BOOLEANS
    // 1. Concepto: Lógica aritmética, textual y matemática.
    // 2. Implementación: +, -, *, /, %, String, Math.abs, Math.random.
    // 3. Utilidad: Cálculo de trayectorias y manipulación de textos.
    static void operadoresLogicos() {
        String msg = "OBJETIVO_" + 1; // Strings
        double raiz = Math.sqrt(16); // Math
        boolean estado = (5 > 3); // Booleans
    }

    // ========================================================================
    // SECCIÓN 2: CONTROL DE FLUJO (IF, SWITCH, LOOPS, ARRAYS)
    // ========================================================================

    // 2.1 JAVA IF...ELSE / SWITCH
    // 1. Concepto: Bifurcación condicional de ejecución.
    // 2. Implementación: if (cond), else, switch (var) case.
    // 3. Utilidad: Toma de decisiones automatizada basada en inteligencia.
    static void controlCondicional(int nivel) {
        if (nivel > 5) { System.out.println("ALTO"); }
        else { System.out.println("BAJO"); }
        switch (nivel) { case 1: System.out.println("UNO"); break; }
    }

    // 2.2 JAVA WHILE LOOP / FOR LOOP / BREAK/CONTINUE
    // 1. Concepto: Iteración y control de ciclos repetitivos.
    // 2. Implementación: while, for (init; cond; inc), break, continue.
    // 3. Utilidad: Procesamiento por lotes y salida de emergencia.
    static void buclesOperativos() {
        for (int i = 0; i < 5; i++) { if (i == 2) continue; }
        int j = 0; while (j < 5) { if (j == 3) break; j++; }
    }

    // 2.3 JAVA ARRAYS
    // 1. Concepto: Colección estática de datos homogeneos.
    // 2. Implementación: tipo[] nombre = {valores}; length.
    // 3. Utilidad: Almacenamiento rápido de IDs fijos.
    static void usarArrays() {
        int[] ids = {1, 2, 3};
        System.out.println(ids.length);
    }

    // ========================================================================
    // SECCIÓN 3: MÉTODOS (PARAMETERS, OVERLOADING, SCOPE, RECURSION)
    // ========================================================================

    // 3.1 JAVA METHODS / PARAMETERS / OVERLOADING
    // 1. Concepto: Funciones reutilizables con entradas variables.
    // 2. Implementación: void nombre(tipo param), misma nombre distintos params.
    // 3. Utilidad: Estandarización de procedimientos tácticos.
    static void ejecutar() { System.out.println("General"); }
    static void ejecutar(String tipo) { System.out.println(tipo); } // Overloading

    // 3.2 JAVA SCOPE / RECURSION / METHOD CHALLENGE
    // 1. Concepto: Visibilidad de variables y autollamada funcional.
    // 2. Implementación: Bloques {}, método que se llama a sí mismo.
    // 3. Utilidad: Gestión de memoria y resolución jerárquica.
    static int factorial(int n) { return (n == 1) ? 1 : n * factorial(n - 1); }
    static void desafioMetodo() { if (true) ejecutar("Desafio"); }

    // ========================================================================
    // SECCIÓN 4: CLASES Y OOP (OBJECTS, ATTRIBUTES, CONSTRUCTORS, THIS)
    // ========================================================================

    // 4.1 JAVA CLASSES / OBJECTS / ATTRIBUTES / METHODS
    // 1. Concepto: Plantillas y entidades con estado y comportamiento.
    // 2. Implementación: class, new, variables instancia, funciones.
    // 3. Utilidad: Modelado de unidades operativas.
    static class Unidad {
        private String codigo; // Atributo
        public Unidad(String c) { this.codigo = c; } // Constructor
        public void reportar() { System.out.println(this.codigo); } // Método
    }

    // 4.2 JAVA CONSTRUCTORS / THIS KEYWORD / MODIFIERS
    // 1. Concepto: Inicialización, referencia propia y control de acceso.
    // 2. Implementación: Nombre clase, this., public/private/protected.
    // 3. Utilidad: Configuración segura y encapsulamiento.
    // (Ver clase Unidad arriba para implementación conjunta)

    // 4.3 JAVA ENCAPSULATION / PACKAGES / API
    // 1. Concepto: Protección de datos y organización modular.
    // 2. Implementación: Getters/Setters, package, import.
    // 3. Utilidad: Seguridad de inteligencia y estructura.
    public String getCodigo() { return this.codigo; }

    // ========================================================================
    // SECCIÓN 5: OOP AVANZADO (INHERITANCE, POLYMORPHISM, SUPER, INNER)
    // ========================================================================

    // 5.1 JAVA INHERITANCE / POLYMORPHISM / SUPER KEYWORD
    // 1. Concepto: Herencia de propiedades y múltiples formas.
    // 2. Implementación: extends, @Override, super().
    // 3. Utilidad: Especialización manteniendo base común.
    static class Elite extends Unidad {
        public Elite(String c) { super(c); } // Super
        @Override public void reportar() { System.out.println("ELITE: " + this.codigo); }
    }

    // 5.2 JAVA INNER CLASSES / ABSTRACTION / INTERFACE / ANONYMOUS
    // 1. Concepto: Clases anidadas, contratos y ocultamiento.
    // 2. Implementación: class dentro class, abstract, interface, new().
    // 3. Utilidad: Organización lógica y estándares obligatorios.
    abstract class Operacion { abstract void iniciar(); }
    interface Orden { void cumplir(); }
    void usarAnonimo() { Orden o = new Orden() { public void cumplir() {} }; }

    // 5.3 JAVA ENUM / USER INPUT / DATE
    // 1. Concepto: Constantes, interacción y tiempo.
    // 2. Implementación: enum, Scanner, LocalDate/LocalDateTime.
    // 3. Utilidad: Estados fijos, entrada datos y marcas tiempo.
    enum Estado { ACTIVO, INACTIVO }
    static void interaccion() {
        Scanner sc = new Scanner(System.in); // Input
        LocalDate hoy = LocalDate.now(); // Date
    }

    // ========================================================================
    // SECCIÓN 6: ERRORES Y ARCHIVOS (EXCEPTIONS, FILES, IO STREAMS)
    // ========================================================================

    // 6.1 JAVA ERRORS / DEBUGGING / EXCEPTIONS
    // 1. Concepto: Fallos críticos y manejo controlado.
    // 2. Implementación: try, catch, throw, logs.
    // 3. Utilidad: Estabilidad y diagnóstico de fallos.
    static void manejarErrores() {
        try { int x = 1/0; } catch (Exception e) { System.out.println("ERROR"); }
    }

    // 6.2 JAVA MULTIPLE EXCEPTIONS / TRY-WITH-RESOURCES
    // 1. Concepto: Múltiples fallos y gestión automática.
    // 2. Implementación: catch (A | B), try (Resource r).
    // 3. Utilidad: Robustez y limpieza de memoria.
    static void recursos() {
        try (Scanner sc = new Scanner(System.in)) {}
        catch (Exception | Error e) {}
    }

    // 6.3 JAVA FILE HANDLING (FILES, CREATE, WRITE, READ, DELETE)
    // 1. Concepto: Manipulación persistente del sistema.
    // 2. Implementación: File, createNewFile, FileWriter, FileReader, delete.
    // 3. Utilidad: Logs, informes y eliminación de rastros.
    static void archivos() throws IOException {
        File f = new File("log.txt");
        f.createNewFile(); f.delete();
        // Write/Read se hacen con Streams
    }

    // 6.4 JAVA I/O STREAMS (FILEINPUT/OUTPUT, BUFFERED READER/WRITER)
    // 1. Concepto: Flujo de datos binarios y texto con buffer.
    // 2. Implementación: FileInputStream, FileOutputStream, BufferedReader.
    // 3. Utilidad: Eficiencia en grandes volúmenes de datos.
    static void streams() throws IOException {
        FileInputStream fis = new FileInputStream("bin.dat");
        FileOutputStream fos = new FileOutputStream("bin.dat");
        BufferedReader br = new BufferedReader(new FileReader("txt.txt"));
        BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"));
    }

    // ========================================================================
    // SECCIÓN 7: ESTRUCTURAS DE DATOS (COLLECTIONS, LIST, SET, MAP)
    // ========================================================================

    // 7.1 JAVA COLLECTIONS / LIST (ARRAYLIST, LINKEDLIST, SORTING)
    // 1. Concepto: Colecciones dinámicas ordenadas.
    // 2. Implementación: List, ArrayList, LinkedList, Collections.sort.
    // 3. Utilidad: Gestión de listas y colas de tareas.
    static void usarListas() {
        List<String> l1 = new ArrayList<>();
        List<String> l2 = new LinkedList<>();
        Collections.sort(l1);
    }

    // 7.2 JAVA SET (HASHSET, TREESET, LINKEDHASHSET)
    // 1. Concepto: Colecciones de elementos únicos.
    // 2. Implementación: Set, HashSet, TreeSet, LinkedHashSet.
    // 3. Utilidad: Eliminación de duplicados y ordenamiento.
    static void usarSets() {
        Set<String> s1 = new HashSet<>();
        Set<String> s2 = new TreeSet<>();
        Set<String> s3 = new LinkedHashSet<>();
    }

    // 7.3 JAVA MAP (HASHMAP, TREEMAP, LINKEDHASHMAP)
    // 1. Concepto: Pares clave-valor para búsqueda rápida.
    // 2. Implementación: Map, HashMap, TreeMap, LinkedHashMap.
    // 3. Utilidad: Diccionarios de códigos y asociación.
    static void usarMapas() {
        Map<String, Integer> m1 = new HashMap<>();
        Map<String, Integer> m2 = new TreeMap<>();
        Map<String, Integer> m3 = new LinkedHashMap<>();
    }

    // 7.4 JAVA ITERATOR / ALGORITHMS
    // 1. Concepto: Recorrido uniforme y algoritmos predefinidos.
    // 2. Implementación: Iterator, Collections methods.
    // 3. Utilidad: Iteración segura y operaciones complejas.
    static void iterar(Collection<?> c) {
        Iterator<?> it = c.iterator();
        while(it.hasNext()) { it.next(); }
    }

    // ========================================================================
    // SECCIÓN 8: AVANZADO (WRAPPERS, GENERICS, ANNOTATIONS, REGEX, THREADS)
    // ========================================================================

    // 8.1 JAVA WRAPPER CLASSES / GENERICS
    // 1. Concepto: Objetos para primitivos y tipado parametrizado.
    // 2. Implementación: Integer, Double, <T>.
    // 3. Utilidad: Flexibilidad y uso en colecciones.
    static <T> void procesar(T item) { /* Logica */ }

    // 8.2 JAVA ANNOTATIONS / REGEX
    // 1. Concepto: Metadatos y expresiones regulares.
    // 2. Implementación: @Override, Pattern, Matcher.
    // 3. Utilidad: Configuración y validación de patrones.
    static void validar(String txt) { Pattern p = Pattern.compile("\\d+"); }

    // 8.3 JAVA THREADS / LAMBDA / ADVANCED SORTING
    // 1. Concepto: Concurrencia, funciones anónimas y ordenación.
    // 2. Implementación: Thread, (args) -> expr, Comparators.
    // 3. Utilidad: Multitarea, código conciso y criterios personalizados.
    static void concurrencia() { new Thread(() -> System.out.println("Hilo")).start(); }

    // ========================================================================
    // SECCIÓN 9: META (PROJECTS, HOW TO'S)
    // ========================================================================

    // 9.1 JAVA PROJECTS / HOW TO'S
    // 1. Concepto: Material práctico y guías de implementación.
    // 2. Implementación: Constantes y mapas de recursos.
    // 3. Utilidad: Biblioteca de consulta rápida.
    static final Map<String, String> PROYECTOS = new HashMap<>();
    static final List<String> HOWTOS = Arrays.asList("Seguridad", "Redes");
    static { PROYECTOS.put("Seguridad", "src/sec"); }

    // ========================================================================
    // SECCIÓN 10: REFERENCIA (KEYWORDS, METHODS LISTS, ERRORS)
    // ========================================================================
    
    /* 
       BASE DE DATOS DE REFERENCIA TÉCNICA (INTEL STORED)
       --------------------------------------------------
       1. JAVA KEYWORDS: public, class, static, void, int, return, etc.
       2. JAVA STRING METHODS: length(), toUpperCase(), substring(), etc.
       3. JAVA MATH METHODS: abs(), max(), min(), sqrt(), random(), etc.
       4. JAVA OUTPUT METHODS: println(), print(), printf(), etc.
       5. JAVA ARRAYS METHODS: sort(), binarySearch(), toString(), etc.
       6. JAVA ARRAYLIST METHODS: add(), get(), remove(), size(), etc.
       7. JAVA LINKEDLIST METHODS: addFirst(), removeLast(), etc.
       8. JAVA HASHMAP METHODS: put(), get(), keySet(), values(), etc.
       9. JAVA SCANNER METHODS: next(), nextInt(), nextLine(), etc.
       10. JAVA FILE METHODS: exists(), canRead(), canWrite(), etc.
       11. JAVA FILEINPUTSTREAM: read(), close(), etc.
       12. JAVA FILEOUTPUTSTREAM: write(), close(), etc.
       13. JAVA BUFFEREDREADER: readLine(), close(), etc.
       14. JAVA BUFFEREDWRITER: write(), newLine(), close(), etc.
       15. JAVA ITERATOR METHODS: hasNext(), next(), remove(), etc.
       16. JAVA COLLECTIONS METHODS: sort(), reverse(), shuffle(), etc.
       17. JAVA SYSTEM METHODS: out, in, err, currentTimeMillis(), etc.
       18. JAVA ERRORS & EXCEPTIONS: Exception, Error, Throwable, etc.
    */

    // ========================================================================
    // PUNTO DE ENTRADA PRINCIPAL (MAIN)
    // ========================================================================
    public static void main(String[] args) {
        // 1. Concepto: Inicio de la ejecución del programa.
        // 2. Implementación: Método public static void main.
        // 3. Utilidad: Despliegue de todos los módulos de entrenamiento.
        
        System.out.println("INICIANDO PROTOCOLO JAVA INTEGRAL");
        fundamentosSalida(); gestionVariables(); operadoresLogicos();
        controlCondicional(5); buclesOperativos(); usarArrays();
        ejecutar(); ejecutar("TEST"); desafioMetodo(); factorial(5);
        Unidad u = new Unidad("001"); u.reportar();
        Elite e = new Elite("002"); e.reportar();
        try { manejarErrores(); recursos(); archivos(); streams(); } 
        catch (Exception ex) { System.out.println("Fallo Crítico"); }
        usarListas(); usarSets(); usarMapas();
        procesar("Texto"); validar("123"); concurrencia();
        interaccion();
        System.out.println("ENTRENAMIENTO COMPLETADO. ESPERANDO ORDENES.");
    }
}