<file_sep># Fundamentos-Java
Este Proyecto Contiene Conceptos Y Ejercicios De Aprendizaje Para El Lenguaje De Programación Java
<file_sep>package com._13_POO._02_AutomovilEjercicio;

public enum TipoMotor {
    DIESEL,
    BENCINA
}
<file_sep>package com._02_Variables._05_TiposReferenciaObjeto;

import java.lang.reflect.Method;

public class _09_WrapperGetClass {
    public static void MethodGetClass() {
        String text = "Hello!!!, How Are You?";
        Integer number = 23;

        Class strClass = text.getClass();
        Class numberClass = number.getClass();

        System.out.println("\n========== WRAPPERS METHOD GETCLASS ==========");
        System.out.println("WRAPPER STRING");
        System.out.println("strClass = " + strClass);
        System.out.println("strClass.getSuperclass() = " + strClass.getSuperclass());
        System.out.println("strClass.getName() = " + strClass.getName());
        System.out.println("strClass.getSimpleName() = " + strClass.getSimpleName());
        System.out.println("strClass.getPackageName() = " + strClass.getPackageName());

        System.out.println("\nWRAPPER INTEGER");
        System.out.println("numberClass = " + numberClass);
        System.out.println("numberClass.getSuperclass() = " + numberClass.getSuperclass());
        System.out.println("numberClass.getSuperclass().getSuperclass() = " + numberClass.getSuperclass().getSuperclass());
        System.out.println("numberClass.getName() = " + numberClass.getName());
        System.out.println("numberClass.getSimpleName() = " + numberClass.getSimpleName());
        System.out.println("numberClass.getPackageName() = " + numberClass.getPackageName());

        System.out.println("\nCICLO WRAPPER STRING");
        for (Method method: strClass.getMethods()) {
            System.out.println("method.getName() = " + method.getName());
        }

        System.out.println("\nCICLO WRAPPER INTEGER");
        for (Method method: numberClass.getMethods()) {
            System.out.println("method.getName() = " + method.getName());
        }
    }
}
<file_sep>package com._14_Generics.Metodos;

public class Main {
    public static void main(String[] args) {

        _01_GenericosParametros.genericosOgenerales();
        _02_GenericosLimites.genericosLimites();
        _03_GenericosComodines.genericosComodines();

        System.out.println("\nMAXIMO ENTRE 1, 9, 4: ");
        System.out.println(_04_GenericosEjercicio.maximo(1, 9, 4));

        System.out.println("MAXIMO ENTRE 3.9, 11.6, 7.78: ");
        System.out.println(_04_GenericosEjercicio.maximo(3.9, 11.6, 7.78));

        System.out.println("MAXIMO ENTRE Zanahoria, Arándanos, Manzana: ");
        System.out.println(_04_GenericosEjercicio.maximo("zanahoria", "arándanos", "manzana"));
    }
}
<file_sep>package com._02_Variables._01_TiposPrimitivos;

import com._02_Variables._01_TiposPrimitivos._01_Enteros._01_byte;
import com._02_Variables._01_TiposPrimitivos._01_Enteros._02_short;
import com._02_Variables._01_TiposPrimitivos._01_Enteros._03_int;
import com._02_Variables._01_TiposPrimitivos._01_Enteros._04_long;
import com._02_Variables._01_TiposPrimitivos._02_Decimales._05_float;
import com._02_Variables._01_TiposPrimitivos._02_Decimales._06_double;
import com._02_Variables._01_TiposPrimitivos._03_Character._07_char;
import com._02_Variables._01_TiposPrimitivos._04_Boolean._08_boolean;
import com._02_Variables._01_TiposPrimitivos._05_Dinamico._08_var;

public class Main {
    public static void main(String[] args) {

        _01_byte.ValoresByte();
        _02_short.ValoresShort();
        _03_int.ValoresInt();
        _04_long.ValoresLong();
        _05_float.ValoresFloat();
        _06_double.ValoresDouble();
        _07_char.ValoresChar();
        _08_boolean.ValoresBoolean();
        _08_var.ValoresVar();

    }
}
<file_sep>package com._02_Variables._03_ConversionDeTipos;

public class _01_CadenasAPrimitivos {
    public static void cadenasAprimitivos() {
        String numeroByteStr = "125";
        String numeroShortStr = "385";
        String numeroIntStr = "50";
        String numeroLongStr = "44678";
        String numeroFloarStr = "45.45e3F";
        String numeroDoubleStr = "324.56e3";
        String logicoBooleanStr1 = "true";
        String logicoBooleanStr2 = "false";

        byte numeroByte = Byte.parseByte(numeroByteStr);
        short numeroShort = Short.parseShort(numeroShortStr);
        int numeroInt = Integer.parseInt(numeroIntStr);
        long numeroLong = Long.parseLong(numeroLongStr);
        float numeroFloat = Float.parseFloat(numeroFloarStr);
        double numeroDouble = Double.parseDouble(numeroDoubleStr);
        boolean logicoBoolean1 = Boolean.parseBoolean(logicoBooleanStr1);
        boolean logicoBoolean2 = Boolean.parseBoolean(logicoBooleanStr2);

        System.out.println("\n********** \"Conversiòn De Cadenas A Primitivos\" **********");
        System.out.println("========== Conversion Primitivo \"byte\" ==========");
        System.out.println("numeroByteStr = " + numeroByteStr);
        System.out.println("numeroByte = " + numeroByte);

        System.out.println("\n========== Conversion Primitivo \"short\" ==========");
        System.out.println("numeroShortStr = " + numeroShortStr);
        System.out.println("numeroShort = " + numeroShort);

        System.out.println("\n========== Conversion Primitivo \"int\" ==========");
        System.out.println("numeroIntStr = " + numeroIntStr);
        System.out.println("numeroInt = " + numeroInt);

        System.out.println("\n========== Conversion Primitivo \"long\" ==========");
        System.out.println("numeroLongStr = " + numeroLongStr);
        System.out.println("numeroLong = " + numeroLong);

        System.out.println("\n========== Conversion Primitivo \"float\" ==========");
        System.out.println("numeroFloatStr = " + numeroFloarStr);
        System.out.println("numeroFloat = " + numeroFloat);

        System.out.println("\n========== Conversion Primitivo \"double\" ==========");
        System.out.println("numeroDoubleStr = " + numeroDoubleStr);
        System.out.println("numeroDouble = " + numeroDouble);

        System.out.println("\n========== Conversion Primitivo \"boolean\" ==========");
        System.out.println("logicoBooleanStr1 = " + logicoBooleanStr1);
        System.out.println("logicoBoolean1 = " + logicoBoolean1);
        System.out.println("\nlogicoBooleanStr2 = " + logicoBooleanStr2);
        System.out.println("logicoBoolean2 = " + logicoBoolean2);
    }
}
<file_sep>package com._13_POO._00_Conceptos._01_Clases;

public class Persona {
    /* Atributos De La Clase */
    String nombre;
    String apellido;

    /* Método De La Clase */
    public void desplegarInformacion() {
        System.out.println("Nombre: " + nombre);
        System.out.println("Apellido: " + apellido);
    }

    /* Es Posible Tener El Método Main Dentro De La Clase, Pero Lo Recomendado Es Tenerlo En Otro Archivo */
    /* public static void main(String[] args) {

    } */
}
<file_sep>package com._02_Variables._05_TiposReferenciaObjeto;

public class _05_WrapperFloat {
    public static void objetoFloat() {
        Float floatObject1 = Float.valueOf("13");
        Float floatObject2 = Float.valueOf(Float.MAX_VALUE);
        Float floatObject3 = 33F;

        /** Pasar De Primitvo A Objeto (AutoBoxing)
         * Esto Se Puede Hacer De Forma Implicita También */
        float floatPrimitivo1 = Float.MIN_VALUE;
        Float floatObject4 = Float.valueOf(floatPrimitivo1);

        /** Pasar De Objeto A Primitivo (AutoUnBoxing)
         * Esto Se Puede Hacer De Forma Implicita También */
        Float floatObject5 = Float.valueOf(floatObject1);
        float floatPrimitivo2 = floatObject5;
        float floatPrimitivo3 = floatObject1.floatValue();

        String valorTvLcd = "67000";
        Float valorTV = Float.valueOf(valorTvLcd);

        System.out.println("\n========== CLASE WRAPPER FLOAT ==========");
        System.out.println("floatObject1 = " + floatObject1);
        System.out.println("floatObject2 = " + floatObject2);
        System.out.println("floatObject3 = " + floatObject3);
        System.out.println("floatObject4 = " + floatObject4);
        System.out.println("floatPrimitivo2 = " + floatPrimitivo2);
        System.out.println("floatPrimitivo3 = " + floatPrimitivo3);
        System.out.println("valorTV = " + valorTV);
    }
}
<file_sep>package com._13_POO._09_CrudDAO.Repositorio;

import com._13_POO._09_CrudDAO.modelo.Cliente;

import java.util.List;

public interface IPaginable {
    List<Cliente> listar(int desde, int hasta);
}
<file_sep>package com._05_EstructurasAlgoritmicas._04_Switch;

import java.util.Scanner;

public class _03_EjercicioDiasMes {
    public static void numeroDiasMes() {
        int numeroDias = 0;
        Scanner teclado = new Scanner(System.in);

        System.out.println("\nIngrese El Nùmero Del Mes Del 1 - 12: ");
        int mes = teclado.nextInt();

        System.out.println("Ingrese El Número Del Año (YYYY): ");
        int anio = teclado.nextInt();

        switch (mes) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                numeroDias = 31;
                break;

            case 4:
            case 6:
            case 9:
            case 11:
                numeroDias = 30;
                break;

            case 2:
                if (anio % 400 == 0 || ( (anio % 4 == 0) && !(anio % 100 == 0) ) ) {
                    numeroDias = 29;
                } else {
                    numeroDias = 28;
                }
                break;

            default:
                numeroDias = 0;
                System.out.println("Error Ingresando La Información");
                break;
        }

        System.out.println("\nAño = " + anio);
        System.out.println("Numero De Dias = " + numeroDias);
    }
}
<file_sep>package com._05_EstructurasAlgoritmicas._05_For;

public class Main {
    public static void main(String[] args) {

        _01_SentenciaFor.forNormal();
        _02_ArraysFor.iterarArreglos();

    }
}
<file_sep>package com._13_POO._01_AutomovilExplicacion;

public class Automovil {

    private int idAuto;
    private String fabricante;
    private String modelo;
    private Color color = Color.GRIS;
    private double cilindrada;
    private int capacidadEstanque = 40;
    private TipoAutomovil tipo;

    private static Color colorPatente = Color.NARANJO;
    private static int capacidadEstanqueStatic = 30;
    private static int ultimoIdAuto;

    public static final Integer VELOCIDAD_MAX_CARRETERA = 120;
    public static final int VELOCIDAD_MAX_CIUDAD = 60;

    /*public static final String COLOR_ROJO = "Rojo";
    public static final String COLOR_AMARILLO = "Amarillo";
    public static final String COLOR_AZUL = "Azul";
    public static final String COLOR_BLANCO = "Blanco";
    public static final String COLOR_GRIS = "Gris";*/

    public Automovil() {
        this.idAuto = ++Automovil.ultimoIdAuto;
    }

    public Automovil(String fabricante, String modelo) {
        this();
        this.fabricante = fabricante;
        this.modelo = modelo;
    }

    public Automovil(String fabricante, String modelo, Color color) {
        this(fabricante, modelo);
        this.color = color;
    }

    public Automovil(String fabricante, String modelo, Color color, double cilindrada) {
        this(fabricante, modelo, color);
        this.cilindrada = cilindrada;
    }

    public Automovil(String fabricante, String modelo, Color color, double cilindrada, int capacidadEstanque) {
        this(fabricante, modelo, color, cilindrada);
        this.capacidadEstanque = capacidadEstanque;
    }

    public int getIdAuto() {
        return idAuto;
    }

    public void setIdAuto(int idAuto) {
        this.idAuto = idAuto;
    }

    public String getFabricante() {
        return fabricante;
    }

    public void setFabricante(String fabricante) {
        this.fabricante = fabricante;
    }

    public String getModelo() {
        return modelo;
    }

    public void setModelo(String modelo) {
        this.modelo = modelo;
    }

    public Color getColor() {
        return color;
    }

    public void setColor(Color color) {
        this.color = color;
    }

    public double getCilindrada() {
        return cilindrada;
    }

    public void setCilindrada(double cilindrada) {
        this.cilindrada = cilindrada;
    }

    public int getCapacidadEstanque() {
        return capacidadEstanque;
    }

    public void setCapacidadEstanque(int capacidadEstanque) {
        this.capacidadEstanque = capacidadEstanque;
    }

    public static Color getColorPatente() {
        return colorPatente;
    }

    public static void setColorPatente(Color colorPatente) {
        Automovil.colorPatente = colorPatente;
    }

    public static int getCapacidadEstanqueStatic() {
        return capacidadEstanqueStatic;
    }

    public TipoAutomovil getTipo() {
        return tipo;
    }

    public void setTipo(TipoAutomovil tipo) {
        this.tipo = tipo;
    }

    public static void setCapacidadEstanqueStatic(int capacidadEstanqueStatic) {
        Automovil.capacidadEstanqueStatic = capacidadEstanqueStatic;
    }

    public String verDetalle() {
        StringBuilder sb = new StringBuilder();

        sb.append("\nthis.idAuto = " + this.idAuto);
        sb.append("\nthis.fabricante = " + this.fabricante);
        sb.append("\nthis.modelo = " + this.modelo);
        sb.append("\nthis.tipo = " + this.getTipo().getNombre());
        sb.append("\nthis.puertas = " + this.getTipo().getNumeroPuertas());
        sb.append("\nthis.color = " + this.color);
        sb.append("\nAutomovil.colorPatente = " + Automovil.colorPatente.getColor());
        sb.append("\nthis.cilindrada = " + this.cilindrada);

        return sb.toString();
    }

    public String acelerar(int revoluciones) {
        return "El Auto " + this.fabricante + " Acelerando A " + revoluciones + "rpm";
    }

    public String frenar() {
        return this.fabricante + " " + this.modelo + " Frenando Correctamente!";
    }

    public String acelerarFrenar(int rpm) {
        String acelerar = this.acelerar(rpm);
        String frenar = this.frenar();

        return acelerar + "\n" + frenar;
    }

    public float calcularConsumo(int km, float porcentajeBencina) {
        return km / (porcentajeBencina * this.capacidadEstanque);
    }

    public float calcularConsumo(int km, int porcentajeBencina) {
        return km / ((porcentajeBencina/100F) * this.capacidadEstanque);
    }

    public static float calcularConsumoEstatico(int km, int porcentajeBencina) {
        return km / ((porcentajeBencina/100F) * Automovil.capacidadEstanqueStatic);
    }

    @Override
    public boolean equals(Object obj) {
        if(this == obj) {
            return true;
        }

        if(!(obj instanceof Automovil)) {
            return false;
        }

        Automovil autoObject = (Automovil) obj;

        return (this.fabricante != null && this.modelo != null &&
                this.fabricante.equals(autoObject.getFabricante()) &&
                this.modelo.equals(autoObject.getModelo()));
    }

    @Override
    public String toString() {
        return "Automovil{" +
                "id='" + idAuto + '\'' +
                ", fabricante='" + fabricante + '\'' +
                ", modelo='" + modelo + '\'' +
                ", tipo='" + tipo.getNombre() + '\'' +
                ", puertas='" + tipo.getNumeroPuertas() + '\'' +
                ", color='" + color + '\'' +
                ", cilindrada=" + cilindrada +
                ", capacidadEstanque=" + capacidadEstanque +
                '}';
    }
}
<file_sep>package com._02_Variables._05_TiposReferenciaObjeto;

public class _06_WrapperDouble {
    public static void objetoDouble() {
        Double doubleObject1 = Double.valueOf("3");
        Double doubleObject2 = Double.valueOf(Double.MAX_VALUE);
        Double doubleObject3 = 3D;

        /** Pasar De Primitvo A Objeto (AutoBoxing)
         * Esto Se Puede Hacer De Forma Implicita También*/
        double doublePrimitivo1 = Double.MIN_VALUE;
        Double doubleObject4 = Double.valueOf(doublePrimitivo1);

        /** Pasar De Objeto A Primitivo (AutoUnBoxing)
         * Esto Se Puede Hacer De Forma Implicita También */
        Double doubleObject5 = Double.valueOf(doubleObject1);
        double doublePrimitivo2 = doubleObject5;
        double doublePrimitivo3 = doubleObject1.longValue();

        String valorTvLcd = "670";
        Long valorTV = Long.valueOf(valorTvLcd);

        System.out.println("\n========== CLASE WRAPPER DOUBLE ==========");
        System.out.println("doubleObject1 = " + doubleObject1);
        System.out.println("doubleObject2 = " + doubleObject2);
        System.out.println("doubleObject3 = " + doubleObject3);
        System.out.println("doubleObject4 = " + doubleObject4);
        System.out.println("doublePrimitivo2 = " + doublePrimitivo2);
        System.out.println("doublePrimitivo3 = " + doublePrimitivo3);
        System.out.println("valorTV = " + valorTV);
    }
}
<file_sep>package com._02_Variables._05_TiposReferenciaObjeto;

public class _08_WrapperBoolean {
    public static void comparandoObjetos() {
        Integer numberObject1, numberObject2;
        numberObject1 = 1;
        numberObject2 = 2;

        boolean primitiveBoolean1 = numberObject1 > numberObject2;
        Boolean objectBoolean1 = Boolean.valueOf(primitiveBoolean1);
        Boolean objectBoolean2 = Boolean.valueOf(false);
        Boolean objectBoolean3 = Boolean.valueOf("true");
        Boolean objectBoolean4 = true;
        boolean primitiveBoolean2 = objectBoolean1.booleanValue();

        System.out.println("\n========== WRAPPER BOOLEAN RELACIONALES ==========");
        System.out.println("primitiveBoolean1 = " + primitiveBoolean1);
        System.out.println("primitiveBoolean2 = " + primitiveBoolean2);
        System.out.println("objectBoolean1 = " + objectBoolean1);
        System.out.println("objectBoolean2 = " + objectBoolean2);
        System.out.println("objectBoolean3 = " + objectBoolean3);
        System.out.println("objectBoolean4 = " + objectBoolean4);

        System.out.println("\n(==) En El Caso De Los Wrapper Boolean Se Compara Por El Valor!!! (OJO!!!)");
        System.out.println("Comparando Boolean Wrapper Por El Valor Con El (==): " + (objectBoolean1 == objectBoolean2));
        System.out.println("Comparando Boolean Wrapper Por El Valor Con El (==): " + (objectBoolean1.equals(objectBoolean2)));
        System.out.println("Comparando Boolean Wrapper Por El Valor Con El (==): " + (objectBoolean1 == objectBoolean3));
        System.out.println("Comparando Boolean Wrapper Por El Valor Con El (==): " + (objectBoolean1.equals(objectBoolean4)));
    }
}
<file_sep>package com._13_POO._11_CrudDAOExceptions.Repositorio.Exceptions;

public class AccesoDato extends Exception {

    public AccesoDato(String message) {
        super(message);
    }

}
<file_sep>package com._14_Generics.Metodos;

import com._13_POO._09_CrudDAO.modelo.Cliente;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class _01_GenericosParametros {
    public static void genericosOgenerales() {
        System.out.println("========== GENERIC METHODS ==========");

        List<Cliente> clientes = new ArrayList<>();
        clientes.add(new Cliente("Daniel", "Fernando"));

        /** Obtener Un Clientes De La Lista */
        //Cliente andres = clientes.get(0);
        Cliente andres = clientes.iterator().next();

        Cliente[] clientesArreglo = { new Cliente("Luciano", "Fernando"), new Cliente("Andres", "Camilo")};
        Integer[] enterosArreglo = {1, 2, 3};

        /** Método Stático Generico fromArrayToList */
        List<Cliente> clientesLista = fromArrayToList(clientesArreglo);
        List<Integer> enterosLista = fromArrayToList(enterosArreglo);

        // Métodos De Referencia
        clientesLista.forEach(System.out::println);
        enterosLista.forEach(System.out::println);

        String[] nombresArreglo = {"Bea", "Max", "Luz", "Maxi"};
        List<String> nombres = fromArrayToList(nombresArreglo, enterosArreglo);
        
        nombres.forEach(System.out::println);
    }

    /* Definimos Un Método Estatico Con UN Tipo De Dato Generico (PUEDE RECIBIR Y RETORNAR CUALQUIER TIPO DE DATO) 
    Y Dicho Tipo De Dato Generico Viene Como Parametro */
    // OJO!! <T> => Tipo De Dato Generico Para El Primer Parametro Definido T[], Pero, Retorna Una Lista De Dicho Tipo De Dato Generico List<T>.
    public static <T> List<T> fromArrayToList(T[] general) {
        /** Recibe Un Arreglo Generico Y Lo Convierte En Una Lista */
        return Arrays.asList(general);
    }

    /* Definimos Un Método Estatico Con DOS Tipos De Datos Genericos (PUEDE RECIBIR Y RETORNAR CUALQUIER TIPO DE DATO)
    Y Dichos Tipos De Dato Genericos Vienen Como Parametros */
    // OJO!! <T> => Tipo De Dato Generico Para El Primer Parametro Definido T[], Pero, Retorna Una Lista De Dicho Tipo De Dato Generico List<T>.
    // OJO!! <G> => Tipo De Dato Generico Para El Segundo Parametro Definido G[], Pero, Retorna Una Lista Del Primer Tipo De Dato Generico List<T>.
    public static <T, G> List<T> fromArrayToList(T[] parametroGeneral, G[] parametroGeneral2) {
        System.out.println(" ");
        for (G elemento: parametroGeneral2) {
            System.out.println(elemento);
        }

        /** Recibe Un Arreglo Y Lo Convierte En Una Lista */
        return Arrays.asList(parametroGeneral);
    }
}
<file_sep>package com._05_EstructurasAlgoritmicas._03_IfElseIf;

import java.util.Scanner;

public class _02_EjercicioDiasMes {
    public static void numeroDiasMes() {
        int numeroDias = 0;
        Scanner teclado = new Scanner(System.in);

        System.out.println("Ingrese El Nùmero Del Mes Del 1 - 12: ");
        int mes = teclado.nextInt();

        System.out.println("Ingrese El Número Del Año (YYYY): ");
        int anio = teclado.nextInt();

        if(mes == 1 || mes == 3 || mes == 5 || mes == 7 || mes == 8 || mes == 10 || mes == 12) {
            numeroDias = 31;
        } else if (mes == 4 || mes == 6 || mes == 9 || mes == 11) {
            numeroDias = 30;

        } else if (mes == 2) {
            if (anio % 400 == 0 || ( (anio % 4 == 0) && !(anio % 100 == 0) ) ) {
                numeroDias = 29;
            } else {
                numeroDias = 28;
            }
        }

        System.out.println("\nAño = " + anio);
        System.out.println("Numero De Dias = " + numeroDias);
    }
}
<file_sep>package com._02_Variables._04_TipoDatoString;

public class _04_Metodos {
    public static void StringMethods() {
        String nombre = "<NAME>";

        System.out.println("\n========== MÈTODOS IMPORTANTES DE LOS STRING ==========");
        System.out.println("nombre.length() = " + nombre.length());
        System.out.println("nombre.toUpperCase() = " + nombre.toUpperCase());
        System.out.println("nombre.toLowerCase() = " + nombre.toLowerCase());
        System.out.println("nombre.equals(\"<NAME>\") = " + nombre.equals("<NAME>"));
        System.out.println("nombre.equalsIgnoreCase(\"daniel fernando yepez vèlez\") = " + nombre.equalsIgnoreCase("<NAME>ando yepez vèlez"));
        System.out.println("nombre.compareTo(\"<NAME>\") = " + nombre.compareTo("<NAME>"));
        System.out.println("nombre.compareToIgnoreCase(\"<NAME>ando yepez vèlez\") = " + nombre.compareToIgnoreCase("<NAME> yepez vèlez"));
        System.out.println("nombre.charAt(3) = " + nombre.charAt(3));
        System.out.println("nombre.charAt(nombre.length() - 1) = " + nombre.charAt(nombre.length() - 1));
        System.out.println("nombre.substring(4) = " + nombre.substring(4));
        System.out.println("nombre.substring(2,9) = " + nombre.substring(2,9));

        String trabalenguas = "trabalenguas";
        System.out.println("trabalenguas.replace(\"a\", \";\") = " + trabalenguas.replace("a", ";"));
        System.out.println("trabalenguas.indexOf(\"a\") = " + trabalenguas.indexOf("a"));
        System.out.println("trabalenguas.lastIndexOf(\"a\") = " + trabalenguas.lastIndexOf("a"));
        System.out.println("trabalenguas.contains(\"gua\") = " + trabalenguas.contains("gua"));
        System.out.println("trabalenguas.startsWith(\"lenguas\") = " + trabalenguas.startsWith("lenguas"));
        System.out.println("trabalenguas.endsWith(\"guas\") = " + trabalenguas.endsWith("guas"));
        System.out.println("        trabalenguas       ");
        System.out.println("        trabalenguas       ".trim());
    }
}
<file_sep>package com._07_ClaseSystem;

import java.io.IOException;

public class _06_EjecutarSO {
    public static void EjecutarSistemaOperativo() {

        Runtime rt = Runtime.getRuntime();
        Process proceso;

        System.out.println("\n========== EJECUTANDO LA CLASE RUNTIME ==========");
        try {

            if (System.getProperty("os.name").toLowerCase().startsWith("windows")) {
                proceso = rt.exec("notepad");

            } else if(System.getProperty("os.name").toLowerCase().startsWith("mac")) {
                proceso = rt.exec("textedit");

            } else if(System.getProperty("os.name").toLowerCase().startsWith("linux") ||
                    System.getProperty("os.name").toLowerCase().contains("nix")) {
                proceso = rt.exec("gedit");

            } else {
                proceso = rt.exec("gedit");
            }

            proceso.waitFor();

        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
            System.err.println("El Comando Es Desconocido: " + e.getMessage());
        }

        System.out.println("Se Ha Cerrado El Bloc De Notas");
    }
}
<file_sep>package com._13_POO._04_Factura.Modelo;

import java.text.SimpleDateFormat;
import java.util.Date;

public class Factura {

    private int idFolio;
    private Cliente cliente;
    private int indiceItems;
    private ItemFactura[] items;
    private String descripcion;
    private Date fecha;

    private static int ultimoFolio;
    public static final int MAX_ITEMS = 10;

    public Factura(Cliente cliente, String descripcion) {
        this.idFolio = ++Factura.ultimoFolio;
        this.items = new ItemFactura[Factura.MAX_ITEMS];
        this.cliente = cliente;
        this.descripcion = descripcion;
        this.fecha = new Date();
    }

    public int getIdFolio() {
        return idFolio;
    }

    public Cliente getCliente() {
        return cliente;
    }

    public void setCliente(Cliente cliente) {
        this.cliente = cliente;
    }

    public ItemFactura[] getItems() {
        return items;
    }

    public String getDescripcion() {
        return descripcion;
    }

    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }

    public Date getFecha() {
        return fecha;
    }

    /* public void setFecha(Date fecha) {
        this.fecha = fecha;
    } */

    public void addItemFactura(ItemFactura item) {
        if(indiceItems < MAX_ITEMS) {
            this.items[this.indiceItems++] = item;
        }
    }

    public double calcularTotal() {
        double total = 0;

        for (ItemFactura item: this.items) {
            if(item == null) {
                continue;
            }

            total += item.calcularImporte();
        }

        return total;
    }

    public String verDetalle() {
        StringBuilder sb = new StringBuilder("Factura Nº: ");
        sb.append(this.idFolio)
                .append("\nCliente: ")
                .append(this.cliente.getNombre())
                .append("\t RUT: ")
                .append(this.cliente.getRut())
                .append("\nDescripcion: ")
                .append(this.descripcion)
                .append("\n");

        SimpleDateFormat df = new SimpleDateFormat("dd 'De' MMMM, YYYY");

        sb.append("Fecha Emisiòn: ")
                .append(df.format(this.fecha))
                .append("\n")
                .append("\n#\tNOMBRE\t$\tCANTIDAD\tTOTAL\n");

        for (ItemFactura item: this.items) {
            if(item == null) {
                continue;
            }

            sb.append(item)
                .append("\n");

            /*sb.append(item.getProducto().getIdProducto())
                    .append("\t")
                    .append(item.getProducto().getNombre())
                    .append("\t")
                    .append(item.getProducto().getPrecio())
                    .append("\t")
                    .append(item.getCantidad())
                    .append("\t")
                    .append(item.calcularImporte())
                    .append("\n");*/

        }

        sb.append("\nGran Total: ")
                .append(this.calcularTotal());

        return sb.toString();
    }

    @Override
    public String toString() {
        return this.verDetalle();
    }
}
<file_sep>package com._14_Generics.Clases;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class _01_Camion<T> implements Iterable<T> {

    private List<T> objetos;
    private int max;

    public _01_Camion(int max) {
        this.max = max;
        this.objetos = new ArrayList<>();
    }

    public void add(T objeto) {
        if(this.objetos.size() <= max) {
            this.objetos.add(objeto);
        } else {
            throw new RuntimeException("No Hay Màs Espacio");
        }
    }

    @Override
    public Iterator iterator() {
        return this.objetos.iterator();
    }
}
<file_sep>package com._14_Generics.Clases;

public class Main {
    public static void main(String[] args) {
        _01_Camion<_04_Animal> transporteCaballos = new _01_Camion<>(5);
        transporteCaballos.add(new _04_Animal("Peregrino", "Caballo"));
        transporteCaballos.add(new _04_Animal("grillo", "Caballo"));
        transporteCaballos.add(new _04_Animal("Tunquen", "Caballo"));
        transporteCaballos.add(new _04_Animal("Topocalma", "Caballo"));
        transporteCaballos.add(new _04_Animal("Longotoma", "Caballo"));

        imprimirCamion(transporteCaballos);

        _01_Camion<_03_Maquinaria> transporteMaquinas = new _01_Camion<>(3);
        transporteMaquinas.add(new _03_Maquinaria("Bulldozer"));
        transporteMaquinas.add(new _03_Maquinaria("Grúa Horquilla"));
        transporteMaquinas.add(new _03_Maquinaria("Perforadora"));

        System.out.println("-------");
        imprimirCamion(transporteMaquinas);

        _01_Camion<_02_Automovil> transporteAuto = new _01_Camion<>(3);
        transporteAuto.add(new _02_Automovil("Toyota"));
        transporteAuto.add(new _02_Automovil("Mitsubishi"));
        transporteAuto.add(new _02_Automovil("Chevrolet"));

        System.out.println("-------");
        imprimirCamion(transporteAuto);
    }

    public static <T> void imprimirCamion(_01_Camion<T> transporte) {
        for (T a: transporte) {
            if(a instanceof _04_Animal) {
                System.out.println(((_04_Animal) a).getNombre() + " Tipo: " + ((_04_Animal) a).getTipo());

            } else if (a instanceof _02_Automovil) {
                System.out.println(((_02_Automovil) a).getMarca());

            } else if (a instanceof _03_Maquinaria) {
                System.out.println(((_03_Maquinaria) a).getTipo());
            }
        }
    }
}
<file_sep>package com._13_POO._10_CrudDAOGenerics.Repositorio;

import java.util.List;

public interface IOrdenable<T> {
    List<T> listar(String campo, Direccion dir);

    /* OTRA FORMA DE IMPLEMENTAR EL MÈTODO ordenar
    default int ordenar(String campo, Cliente a, Cliente b) {
        int resultado = 0;

        switch (campo) {
            case "id":
                resultado = a.getId().compareTo(b.getId());
            case "nombre":
                resultado = a.getNombre().compareTo(b.getNombre());
            case "apellido":
                resultado = a.getApellido().compareTo(b.getApellido());
        }

        return resultado;
    } */
}
<file_sep>package com._13_POO._00_Conceptos._04_Sobrecarga;

public class Main {
    public static void main(String[] args) {
        Aritmetica aritmetica1 = new Aritmetica();
        System.out.println("aritmetica1.a = " + aritmetica1.a);
        System.out.println("aritmetica1.b = " + aritmetica1.b);

        System.out.println();
        Aritmetica aritmeticaArgs = new Aritmetica(5, 7);
        System.out.println("aritmeticaArgs.a = " + aritmeticaArgs.a);
        System.out.println("aritmeticaArgs.b = " + aritmeticaArgs.b);
    }
}
<file_sep>package com._13_POO._06_Herencia;

public class MainHerencia {
    public static void main(String[] args) {
        /** Ejemplo Casteo Mètodo De Alumno A Persona */
        Persona alumno2 = new Alumno();
        ((Alumno)alumno2).setInstitucion("<NAME>");
        System.out.println("((Alumno) alumno2).getInstitucion() = " + ((Alumno) alumno2).getInstitucion());
        
        Alumno alumno = new Alumno();
        alumno.setNombre("<NAME>");
        alumno.setApellido("<NAME>");
        alumno.setNotaCastellano(5.5);
        alumno.setNotaHistoria(6.3);
        alumno.setNotaMatematica(4.9);
        System.out.println("\nalumno.getNombre() + alumno.getApellido() = " + alumno.getNombre() + " " + alumno.getApellido());
        
        AlumnoInternacional alumnoI = new AlumnoInternacional();
        alumnoI.setNombre("Peter");
        alumnoI.setApellido("Goslin");
        alumnoI.setPais("Australia");
        alumnoI.setInstitucion("Instituto Nacional");
        alumnoI.setNotaIdiomas(6.8);
        alumnoI.setNotaCastellano(6.2);
        alumnoI.setNotaHistoria(5.8);
        alumnoI.setNotaMatematica(6.5);
        alumnoI.setEdad(15);
        System.out.println("\nalumnoI.getNombre() = " + alumnoI.getNombre());
        System.out.println("alumnoI.getApellido() = " + alumnoI.getApellido());
        System.out.println("alumnoI.getInstitucion() = " + alumnoI.getInstitucion());
        System.out.println("alumnoI.getPais() = " + alumnoI.getPais() + "\n");
        
        Class clase = alumnoI.getClass();
        
        while (clase.getSuperclass() != null) {
            String hija = clase.getName();
            String padre = clase.getSuperclass().getName();

            System.out.println("Yo Soy La Clase Hija Desde Donde Estoy Iniciando: " + hija);
            clase = clase.getSuperclass();
        }
        
        Profesor profesor = new Profesor();
        profesor.setNombre("<NAME>");
        profesor.setApellido("<NAME>");
        profesor.setAsignatura("Matemàticas");
        System.out.println("\nprofesor.getNombre() " + "+ profesor.getApellido() " + "+ profesor.getAsignatura() = " + profesor.getNombre() + " " + profesor.getApellido() + " " + profesor.getAsignatura());
    }
}
<file_sep>package com._04_Operadores;

public class _11_InstanceOf {
    public static void instancia() {
        Integer numero = 12;
        Double decimal = 45.54;
        Boolean booleano = false;
        String texto = "Creando Un Objeto De La Clase String.. Que Tal!!!";

        boolean b1 = texto instanceof Object;
        boolean b2 = numero instanceof Object;
        boolean b3 = texto instanceof String;
        boolean b4 = numero instanceof Integer;
        boolean b5 = numero instanceof Number;
        boolean b6 = decimal instanceof Number;
        boolean b7 = booleano instanceof Boolean;

        System.out.println("\n========== OPERADOR INSTANCEOF ==========");
        System.out.println("¿Texto Es Del Tipo Object? = " + b1);
        System.out.println("¿Numero Es Del Tipo Object? = " + b2);
        System.out.println("¿Texto Es Del Tipo String? = " + b3);
        System.out.println("¿Numero Es Del Tipo Integer? = " + b4);
        System.out.println("¿Numero Es Del Tipo Number? = " + b5);
        System.out.println("¿Decimal Es Del Tipo Number? = " + b6);
        System.out.println("¿Booleano Es Del Tipo Boolean? = " + b7);

    }
}
<file_sep>package com._09_LineaDeComando;

public class _02_Calculadora {
    public static void main(String[] args) {

        if(args.length != 3) {
            System.out.println("Por Favor Ingresar Una Operación (suma, resta, multi, div) Y Dos Números Enteros: ");
            System.exit(-1);
        }

        String operacion = args[0];
        int a = Integer.parseInt(args[1]);
        int b = Integer.parseInt(args[2]);
        double resultado = 0.00;

        switch (operacion) {
            case "suma":
                resultado = a + b;
                break;

            case "resta":
                resultado = a - b;
                break;

            case "multi":
                resultado = a * b;
                break;

            case "div":
                if(b == 0) {
                    System.out.println("No Se Puede Dividir Por Zero(0)!");
                    System.exit(-1);
                }

                resultado = (double) a / b;
                break;

            default:
                resultado = a + b;
                break;
        }

        System.out.println("Resultado De La Operaciòn " + operacion + " Es: " + resultado);
    }

}
<file_sep>package com._19_ExpresionesLambda._05_InterfazFuncional;

import java.util.function.BiFunction;

public class Calculadora {
    /* Con Las Expresiones Lambda No Funciona La Sobrecarga De Métodos */
    public double computer(double a, double b, Aritmetica lambda) {
        return lambda.operacion(a, b);
    }

    public double computarConBifunction(double a, double b, BiFunction<Double, Double, Double> lambda) {
        return lambda.apply(a, b);
    }
}<file_sep>package com._16_CollectionAPI._01_Set.TreeSet;

public class Main {
    public static void main(String[] args) {

        Agregar.EjemploTreeSet();
        Comparable.ejemploTreeSetComparable();

    }
}
<file_sep>package com._03_Constantes;

public class _01_Constantes {
    public static void ejemploConstantes() {
        final double PI = 3.1416;
        final double PULGADAS = 2.54;
        final String RESULTADO = "Hola Mundo";
        
        System.out.println("\n======== VALORES CONSTANTES =======");
        System.out.println("PI = " + PI);
        System.out.println("PULGADAS = " + PULGADAS);
        System.out.println("RESULTADO = " + RESULTADO);
    }
}
<file_sep>package com._13_POO._01_AutomovilExplicacion;

public enum TipoAutomovil {
    SEDAN("Sedan", "Auto Normal", 4),
    STATION_WAGON("Station Wagon", "Auto Grande", 4),
    HATCHBACK("Hatchback", "Auto Compacto", 4),
    PICKUP("Pickup", "Camioneta", 4),
    COUPE("Coupe", "Auto Pequeño", 2),
    CONVERTIBLE("Convertible", "Auto Deportivo", 2),
    FURGON("Furgon", "Auto Utilizario", 4);

    private final String nombre;
    private final String descripcion;
    private final int numeroPuertas;

    TipoAutomovil(String nombre, String descripcion, int numeroPuertas) {
        this.nombre = nombre;
        this.descripcion = descripcion;
        this.numeroPuertas = numeroPuertas;
    }

    public String getNombre() {
        return nombre;
    }

    public String getDescripcion() {
        return descripcion;
    }

    public int getNumeroPuertas() {
        return numeroPuertas;
    }
}
<file_sep>package com._06_JavaUtil;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class _05_CompararFechas {
    public static void dateCompare() {
        System.out.println("\n========== COMPARAR FECHAS ==========");

        Scanner teclado = new Scanner(System.in);
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");

        System.out.println("Ingrese Una Fecha Con Formato 'yyyy-MM-dd': ");

        try {
            Date fecha = format.parse(teclado.nextLine());
            Date fecha2 = new Date();

            System.out.println("\nfecha = " + fecha);
            System.out.println("fecha2 = " + fecha2);
            System.out.println("format.format(fecha) = " + format.format(fecha));

            /** Primera Forma De Comparar FECHAS */
            System.out.println();
            if (fecha.after(fecha2)) {
                System.out.println("Fecha Del Usuario Es Mayor Que La Fecha Actual");
            } else if (fecha.before(fecha2)) {
                System.out.println("Fecha Del Usuario Es Menor Que La Fecha Actual");
            } else if (fecha.equals(fecha2)) {
                System.out.println("Las Fechas Son Iguales");
            }

            /** Segunda Forma De Comparar FECHAS */
            if (fecha.compareTo(fecha2) > 0) {
                System.out.println("Fecha Del Usuario Es Mayor Que La Fecha Actual");
            } else if (fecha.compareTo(fecha2) < 0) {
                System.out.println("Fecha Del Usuario Es Menor Que La Fecha Actual");
            } else if (fecha.compareTo(fecha2) == 0) {
                System.out.println("Las Fechas Son Iguales");
            }

        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}
<file_sep>package com._02_Variables._03_ConversionDeTipos;

public class _03_PrimitivosAPrimitivos {
    public static void primitivosAprimitivos() {

        /* En La Conversiòn De Primitivo A Primitivo Se Utiliza
         * El Concepto Del Cast O Casteo De Tipos */
        byte numeroByte = 125;
        short numeroShort = 3854;
        int numeroInt = 5056;
        long numeroLong = 44678L;
        float numeroFloat = 45.45e3F;
        double numeroDouble = 32444.56e10D;

        /* Si El Valor Existente Se Va A Almacenar En Un Tipo De Dato
         * Superior O Igual Al Que Se Le Definiò Inicialmente Al Valor
         * Ya Existente, No Hay Ningùn Problema Por Que No Se Pierde
         * Informaciòn */
        double numeroByteCastADouble = numeroByte;
        double numeroShortCastADouble = numeroShort;
        double numeroIntCastADouble = numeroInt;
        double numeroLongCastADouble = numeroLong;
        double numeroFloatCastADouble = numeroFloat;
        double numeroDoubleCastADouble = numeroDouble;

        /*(AMBIGUEDAD PELIGROSA) En El Casteo Se Puede Perder Informaciòn,
         * Si El Valor Existente Se Va A Almacenar En Un Tipo De Dato
         * Inferior Al Que Se Le Definiò Inicialmente Al Valor Ya Existente */
        byte numeroDoubleCastAByte = (byte) numeroDouble;
        short numeroDoubleCastAShort = (short) numeroDouble;
        int numeroDoubleCastAInt = (int) numeroDouble;
        long numeroDoubleCastALong =  (long) numeroDouble;
        float numeroDoubleCastAFloat = (float) numeroDouble;
        double numeroDoubleCast2ADouble = numeroDouble;

        System.out.println("\n********** \"Conversiòn De Primitivos A Primitivos\" **********");
        System.out.println("========== Conversion Primitivo \"byte\" ==========");
        System.out.println("numeroByte = " + numeroByte);
        System.out.println("numeroByteCastADouble = " + numeroByteCastADouble);
        System.out.println("numeroDoubleCastAByte = " + numeroDoubleCastAByte);

        System.out.println("\n========== Conversion Primitivo \"short\" ==========");
        System.out.println("numeroShort = " + numeroShort);
        System.out.println("numeroShortCastADouble = " + numeroShortCastADouble);
        System.out.println("numeroDoubleCastAShort = " + numeroDoubleCastAShort);

        System.out.println("\n========== Conversion Primitivo \"int\" ==========");
        System.out.println("numeroInt = " + numeroInt);
        System.out.println("numeroIntCastADouble = " + numeroIntCastADouble);
        System.out.println("numeroDoubleCastAInt = " + numeroDoubleCastAInt);

        System.out.println("\n========== Conversion Primitivo \"long\" ==========");
        System.out.println("numeroLong = " + numeroLong);
        System.out.println("numeroLongCastADouble = " + numeroLongCastADouble);
        System.out.println("numeroDoubleCastALong = " + numeroDoubleCastALong);

        System.out.println("\n========== Conversion Primitivo \"float\" ==========");
        System.out.println("numeroFloat = " + numeroFloat);
        System.out.println("numeroFloatCastADouble = " + numeroFloatCastADouble);
        System.out.println("numeroDoubleCastAFloat = " + numeroDoubleCastAFloat);

        System.out.println("\n========== Conversion Primitivo \"double\" ==========");
        System.out.println("numeroDouble = " + numeroDouble);
        System.out.println("numeroDoubleCastADouble = " + numeroDoubleCastADouble);
        System.out.println("numeroDoubleCast2ADouble = " + numeroDoubleCast2ADouble);
    }
}
<file_sep>package com._02_Variables._01_TiposPrimitivos._01_Enteros;

public class _02_short {
    public static void ValoresShort() {
        short valorNumeroShort = 32;

        /* Cuando Se Exceda El Valor O La Capacidad Máxima Del Tipo De Dato Definido
        Tendremos El Siguiente Error: */
        /* incompatible types: possible lossy conversion from int to short */
        /* short excederShort = 32768; */

        /* Casteo O Conversión De Tipos */
        /* El 32768 Es De Tipo Entero Y Lo Que Hacemos Es Castearlo O Convertirlo A Un Tipo short */
        /* El Resultado Que Obtendremos Es Que No Se Esta Almacenando El 32768 Como Lo Habiamos Indicado,
         * Por Que El Compilador Nos Dice Que Si Estamos Seguros De Lo Que Estamos Haciendo, Ya Que Si
         * Queremos Almacenar Un Valor Que Supera El Rango Del Tipo De Dato Del Indicador, Estamos Expuestos
         * A Tener Resultados Con Imprecisiones, Así, Sea Casteado O Convertido */
        short excederShort = (short) 32768;

        System.out.println("\n========= TIPO DE DATO PRIMITIVO \"short\" =========");
        System.out.println("Tipo short Corresponde En Bits A: " + Short.SIZE);
        System.out.println("Tipo short Corresponde En Bytes A: " + Short.BYTES);
        System.out.println("Nùmero Minimo Aceptado: " + Short.MIN_VALUE);
        System.out.println("Nùmero Maximo Aceptado: " + Short.MAX_VALUE);
        System.out.println("Variable valorNumeroShort = " + valorNumeroShort);
        System.out.println("El Valor Es Muy Grande Para Lo Que Soporta El Tipo SHORT excederShort = " + excederShort + " Obtenemos Valores Con Imprecisiones Por Que Perdemos Bits");
    }
}
<file_sep>package com._02_Variables._02_SistemasNumericos;

public class _04_SistemaHexadecimal {
    public static void SistemaHexadecimal() {
        int numeroDecimal1 = 500;
        int numeroDecimal2 = 302;

        int numeroHexadecimal1 = 0x1f4;
        int numeroHexadecimal2 = 0x12e;

        System.out.println("\n=========== SISTEMA HEXADECIMAL ==========");
        System.out.println("Numero Hexadecimal De " + numeroDecimal1 + " = " + Integer.toHexString(numeroDecimal1));
        System.out.println("Numero Hexadecimal De " + numeroDecimal2 + " = " + Integer.toHexString(numeroDecimal2));
        System.out.println("Numero Decimal De 0x1f4" + " = " + numeroHexadecimal1);
        System.out.println("Numero Decimal De 0x12e" + " = " + numeroHexadecimal2);
    }
}
<file_sep>package com._02_Variables._02_SistemasNumericos;

public class _02_SistemaBinario {
    public static void SistemaBinario() {
        int numeroDecimal1 = 500;
        int numeroDecimal2 = 302;

        int numeroBinario1 = 0b111110100;
        int numeroBinario2 = 0b100101110;

        System.out.println("\n=========== SISTEMA BINARIO ==========");
        System.out.println("Numero Binario De " + numeroDecimal1 + " = " + Integer.toBinaryString(numeroDecimal1));
        System.out.println("Numero Binario De " + numeroDecimal2 + " = " + Integer.toBinaryString(numeroDecimal2));
        System.out.println("Numero Decimal De 0b111110100" + " = " + numeroBinario1);
        System.out.println("Numero Decimal De 0b100101110" + " = " + numeroBinario2);
    }
}
<file_sep>package com._13_POO._10_CrudDAOGenerics.Repositorio;

import java.util.List;

public interface IPaginable<T> {
    List<T> listar(int desde, int hasta);
}
<file_sep>package com._01_HolaMundo;

public class Main {
    public static void main(String[] args) {
        _01_HolaMundo.Saludo();
    }
}
<file_sep>package com._02_Variables._05_TiposReferenciaObjeto;

public class _02_WrapperShort {
    public static void objetoShort() {
        Short shortObject1 = Short.valueOf("3");
        Short shortObject2 = Short.valueOf(Short.MAX_VALUE);
        Short shortObject3 = 3;

        /** Pasar De Primitvo A Objeto (AutoBoxing)
         * Esto Se Puede Hacer De Forma Implicita También*/
        short shortPrimitivo1 = Short.MIN_VALUE;
        Short shortObject4 = Short.valueOf(shortPrimitivo1);

        /** Pasar De Objeto A Primitivo (AutoUnBoxing)
         * Esto Se Puede Hacer De Forma Implicita También */
        Short shortObject5 = Short.valueOf(shortObject1);
        short shortPrimitivo2 = shortObject5;
        short shortPrimitivo3 = shortObject1.shortValue();

        String valorTvLcd = "670";
        Short valorTV = Short.valueOf(valorTvLcd);

        System.out.println("\n========== CLASE WRAPPER SHORT ==========");
        System.out.println("shortObject1 = " + shortObject1);
        System.out.println("shortObject2 = " + shortObject2);
        System.out.println("shortObject3 = " + shortObject3);
        System.out.println("shortObject4 = " + shortObject4);
        System.out.println("shortPrimitivo2 = " + shortPrimitivo2);
        System.out.println("shortPrimitivo3 = " + shortPrimitivo3);
        System.out.println("valorTV = " + valorTV);
    }
}
<file_sep>package com._13_POO._07_ClasesAbstractas.Elementos;

import com._13_POO._07_ClasesAbstractas.Validadores.LargoValidador;
import com._13_POO._07_ClasesAbstractas.Validadores.Validador;
import com._13_POO._07_ClasesAbstractas.Validadores.mensaje.IMensajeFormatiable;

import java.util.ArrayList;
import java.util.List;

abstract public class ElementoForm {

    protected String valor;
    protected String nombre;

    private List<Validador> validadores;
    private List<String> errores;

    public ElementoForm() {
        this.validadores = new ArrayList<Validador>();
        this.errores = new ArrayList<String>();
    }

    public ElementoForm(String nombre) {
        this();
        this.nombre = nombre;
    }

    public String getNombre() {
        return nombre;
    }

    public void setValor(String valor) {
        this.valor = valor;
    }

    public List<String> getErrores() {
        return errores;
    }

    public ElementoForm addValidador(Validador validador) {
        this.validadores.add(validador);
        return this;
    }

    public boolean esValido() {
        for (Validador valid: this.validadores) {

            if(!valid.esValido(this.valor)) {

                if(valid instanceof IMensajeFormatiable) {
                    this.errores.add(((LargoValidador) valid).getMensajeFormateado(this.nombre));

                } else {
                    this.errores.add(String.format(valid.getMensaje(), this.nombre));
                }
            }
        }

        return this.errores.isEmpty();
    }

    abstract public String dibujarHtml();
}
<file_sep>package com._13_POO._07_ClasesAbstractas.Elementos;

public class InputForm extends ElementoForm {

    private String tipo = "text";

    public InputForm(String nombre) {
        super(nombre);
    }

    public InputForm(String nombre, String tipo) {
        super(nombre);
        this.tipo = tipo;
    }

    public String getTipo() {
        return tipo;
    }

    public void setTipo(String tipo) {
        this.tipo = tipo;
    }

    @Override
    public String dibujarHtml() {
        return  "<input type='" + this.tipo +
                "' name='" + super.nombre +
                "' value='" + super.valor + "'>";
    }

}
<file_sep>package com._02_Variables._04_TipoDatoString;

public class Main {
    public static void main(String[] args) {

        _01_Explicacion.Explicacion();
        _02_Inmutabilidad.Inmutabilidad();
        _03_Test.Rendimiento();
        _04_Metodos.StringMethods();
        _05_MetodosArrays.StringMethodsArray();
        _06_EjercicioExtension.ExtencionArchivo();

    }
}
<file_sep>package com._04_Operadores;

public class _05_Decremento {
    public static void OperadoresDecrementales() {

        System.out.println("\n========== OPERADOR PRE-DECREMENTO ==========");
        int i = 3;
        int j = --i;

        System.out.println("i = " + i);
        System.out.println("j = " + j);

        System.out.println("\n========== OPERADOR POST-DECREMENTO ==========");
        int k = 3;
        int f = k--;

        System.out.println("k = " + k);
        System.out.println("f = " + f);

        System.out.println("\n========== EJEMPLO COMBINADO PRE Y POST DECREMENTO ==========");
        int d = 10;

        System.out.println("d = " + d);
        System.out.println("PRE-DECREMENTO (--d) = " + (--d));
        System.out.println("d = " + d);
        System.out.println("POST-DECREMENTO (d--) = " + (d--));
        System.out.println("d = " + d);
    }
}
<file_sep>package com._06_JavaUtil;

import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class _03_FechaPasadaFutura {
    public static void fechaCalendar() {
        System.out.println("\n========== CLASE CALENDAR, FECHA PASADA, ACTUAL, FUTURA ==========");

        /** Detras De Escena Crea Un Calendario Dependiendo De La Zona */
        Calendar calendario = Calendar.getInstance();

        /** Es Lo Mismo Que La Fecha Con La Clase Date */
        Date fechaActual = calendario.getTime();
        System.out.println("fechaActual = " + fechaActual);

        /** El Mes De Enero En Calendar Siempre Inicia Desde Cero(0) */
        calendario.set(2020, 0, 25);
        Date fechaPersonalizadaUno = calendario.getTime();
        System.out.println("fechaPersonalizadaUno = " + fechaPersonalizadaUno);

        calendario.set(1993, 3, 28, 22, 20, 10);
        Date fechaPersonalizadaDos = calendario.getTime();
        System.out.println("fechaPersonalizadaDos = " + fechaPersonalizadaDos);

        calendario.set(2025, Calendar.SEPTEMBER, 28, 22, 20, 10);
        Date fechaPersonalizadaTres = calendario.getTime();
        System.out.println("fechaPersonalizadaTres = " + fechaPersonalizadaTres);

        /** Ingresar Una Fecha Parte Por Parte O Fragmentada */
        calendario.set(Calendar.YEAR, 1970);
        calendario.set(Calendar.MONTH, Calendar.JULY);
        calendario.set(Calendar.DAY_OF_MONTH, 1);

        calendario.set(Calendar.HOUR_OF_DAY, 21);
        calendario.set(Calendar.MINUTE, 44);
        calendario.set(Calendar.SECOND, 8);
        calendario.set(Calendar.MILLISECOND, 125);

        Date fechaPersonalizadaCuatro = calendario.getTime();
        System.out.println("fechaPersonalizadaCuatro = " + fechaPersonalizadaCuatro);

        calendario.set(Calendar.YEAR, 1990);
        calendario.set(Calendar.MONTH, Calendar.OCTOBER);
        calendario.set(Calendar.DAY_OF_MONTH, 23);

        calendario.set(Calendar.HOUR, 7);
        calendario.set(Calendar.AM_PM, Calendar.PM);
        calendario.set(Calendar.MINUTE, 44);
        calendario.set(Calendar.SECOND, 8);
        calendario.set(Calendar.MILLISECOND, 10);

        Date fechaPersonalizadaQuinto = calendario.getTime();
        System.out.println("fechaPersonalizadaQuinto = " + fechaPersonalizadaQuinto);

        /** Aqui Le Doy Formato A La Fecha, Anteriormente Definida O Personalizada Con Calendar */
        SimpleDateFormat formato1 = new SimpleDateFormat("yyyy-MM-dd");
        SimpleDateFormat formato2 = new SimpleDateFormat("yyyy/MMM/dd");
        SimpleDateFormat formato3 = new SimpleDateFormat("yyyy, MMM, dd");
        SimpleDateFormat formato4 = new SimpleDateFormat("yyyy-MMMM-dd HH:mm:ss");
        SimpleDateFormat formato5 = new SimpleDateFormat("yyyy-MMMM-dd hh:mm:ss");
        SimpleDateFormat formato6 = new SimpleDateFormat("yyyy-MMMM-dd HH:mm:ss:SSS");
        SimpleDateFormat formato7 = new SimpleDateFormat("yyyy-MMMM-dd HH:mm:ss:SSS");
        SimpleDateFormat formato8 = new SimpleDateFormat("yyyy-MMMM-dd HH:mm:ss:SSS a");

        System.out.println("formato1.format(fechaPersonalizadaUno) = " + formato1.format(fechaPersonalizadaUno));
        System.out.println("formato2.format(fechaPersonalizadaDos) = " + formato2.format(fechaPersonalizadaDos));
        System.out.println("formato3.format(fechaPersonalizadaTres) = " + formato3.format(fechaPersonalizadaTres));
        System.out.println("formato4.format(fechaPersonalizadaCuatro) = " + formato4.format(fechaPersonalizadaCuatro));
        System.out.println("formato5.format(fechaPersonalizadaCuatro) = " + formato5.format(fechaPersonalizadaCuatro));
        System.out.println("formato6.format(fechaActual) = " + formato6.format(fechaActual));
        System.out.println("formato7.format(fechaPersonalizadaQuinto) = " + formato7.format(fechaPersonalizadaQuinto));
        System.out.println("formato8.format(fechaPersonalizadaQuinto) = " + formato8.format(fechaPersonalizadaQuinto));

        /** Espacio Para Comparar Fechas */
        Calendar calendario2 = Calendar.getInstance();
        Calendar calendario3 = Calendar.getInstance();

        calendario2.set(2020, 12, 18, 15, 33, 20);
        calendario3.set(2020, 12, 18, 15, 33, 20);

        /** Primera Forma De Comparar FECHAS */
        System.out.println();
        if (calendario2.after(calendario3)) {
            System.out.println("Fecha Del Usuario Es Mayor Que La Fecha Actual");
        } else if (calendario2.before(calendario3)) {
            System.out.println("Fecha Del Usuario Es Menor Que La Fecha Actual");
        } else if (calendario2.equals(calendario3)) {
            System.out.println("Las Fechas Son Iguales");
        }

        /** Segunda Forma De Comparar FECHAS */
        if (calendario2.compareTo(calendario3) > 0) {
            System.out.println("Fecha Del Usuario Es Mayor Que La Fecha Actual");
        } else if (calendario2.compareTo(calendario3) < 0) {
            System.out.println("Fecha Del Usuario Es Menor Que La Fecha Actual");
        } else if (calendario2.compareTo(calendario3) == 0) {
            System.out.println("Las Fechas Son Iguales");
        }
    }
}
<file_sep>package com._04_Operadores;

public class _12_InstanceOfGeneral {
    public static void tiposGlobales() {
        Object texto = "Creando Un Objeto De La Object De Tipo String";
        Number numeroEntero = 2345;
        Object numeroDecimal = 23.45F;

        boolean b1 = texto instanceof String;
        boolean b2 = texto instanceof Integer;
        boolean b3 = numeroEntero instanceof Integer;
        boolean b4 = numeroDecimal instanceof Float;

        System.out.println("\n========== OPERADOR INSTANCEOF GLOBAL ==========");
        System.out.println("¿Texto Es Del Tipo Object Con Un Valor String? = " + b1);
        System.out.println("¿Texto Es Del Tipo Object Con Un Valor String? = " + b2);
        System.out.println("¿Numero Entero Es Del Tipo Object Con Un Valor Númerico? = " + b3);
        System.out.println("¿Numero Decimal(Float) Es Del Tipo Object Con Un Valor Númerico? = " + b4);

    }
}
<file_sep>package com._13_POO._02_AutomovilEjercicio;

import com._13_POO._01_AutomovilExplicacion.Color;
import com._13_POO._01_AutomovilExplicacion.TipoAutomovil;

import java.util.Arrays;

public class MainAutomovilArreglo {
    public static void main(String[] args) {

        Persona conductorSubaru = new Persona("Luci", "Acevedo");
        Automovil subaru = new Automovil("Subaru", "Impreza", Color.AZUL);
        Motor motorSubaru = new Motor(2.0, TipoMotor.BENCINA);
        Estanque estanqueSubaru = new Estanque();

        subaru.setConductor(conductorSubaru);
        subaru.setMotor(motorSubaru);
        subaru.setEstanque(estanqueSubaru);
        subaru.setTipo(TipoAutomovil.CONVERTIBLE);

        Persona conductorMazda = new Persona("Pato", "Rodriguez");
        Automovil mazda = new Automovil("Mazda", "BT-50", Color.ROJO);
        Motor motorMazda = new Motor(3.0, TipoMotor.DIESEL);
        Estanque estanqueMazda = new Estanque();

        mazda.setConductor(conductorMazda);
        mazda.setMotor(motorMazda);
        mazda.setEstanque(estanqueMazda);
        mazda.setTipo(TipoAutomovil.COUPE);

        Automovil[] autos = new Automovil[2];
        autos[0] = subaru;
        autos[1] = mazda;

        /** Ordena Los Objetos Gracias A La Interface CompareTo De Automovil */
        Arrays.sort(autos);

        for (int i = 0; i < autos.length; i++) {
            System.out.println(autos[i].toString());
        }
    }
}
<file_sep>config.puerto.servidor=8090
otra=algun valor
config.texto.ambiente=Configurando ambiente de desarrollo
config.autor.nombre=<NAME>
config.autor.email=<EMAIL><file_sep>package com._13_POO._07_ClasesAbstractas;

import com._13_POO._07_ClasesAbstractas.Elementos.ElementoForm;
import com._13_POO._07_ClasesAbstractas.Elementos.InputForm;
import com._13_POO._07_ClasesAbstractas.Elementos.Select.Opcion;
import com._13_POO._07_ClasesAbstractas.Elementos.SelectForm;
import com._13_POO._07_ClasesAbstractas.Elementos.TextAreaForm;

import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        InputForm username = new InputForm("username");
        InputForm password = new InputForm("clave", "<PASSWORD>");
        InputForm email = new InputForm("email", "email");
        InputForm edad = new InputForm("edad", "number");

        TextAreaForm experiencia = new TextAreaForm("exp", 5, 9);

        SelectForm lenguaje = new SelectForm("lenguaje");
        Opcion java = new Opcion("1", "Java");
        lenguaje.addOpcion(java)
                .addOpcion(new Opcion("2", "Python"))
                .addOpcion(new Opcion("3", "JavaScript"))
                .addOpcion(new Opcion("4", "TypeScript"))
                .addOpcion(new Opcion("5", "PHP"));

        username.setValor("John.doe");
        password.setValor("<PASSWORD>");
        email.setValor("<EMAIL>");
        edad.setValor("28");

        experiencia.setValor("... Más De 10 Años De Experiencia ...");

        java.setSelected(true);

        /* List<ElementoForm> elementos = new ArrayList<>();
        elementos.add(username);
        elementos.add(password);
        elementos.add(email);
        elementos.add(edad);
        elementos.add(experiencia);
        elementos.add(lenguaje); */

        /** Forma Más Optimizada Del ArrayList() */
        List<ElementoForm> elementos = Arrays.asList(username,
                <PASSWORD>,
                email,
                edad,
                experiencia,
                lenguaje);

        /** for (ElementoForm elemento: elementos) {
            System.out.println(elemento.dibujarHtml());
        } */

        /** Api De Stream De Java 8 (Funciones De Flecha) */
        elementos.forEach(elemento -> {
            System.out.println(elemento.dibujarHtml());
            System.out.println("<br />");
        });
    }
}
<file_sep>package com._02_Variables._01_TiposPrimitivos._04_Boolean;

public class _08_boolean {
    public static void ValoresBoolean() {
        boolean valorBooleanTrue = true;
        boolean valorNumericoBooleanTrue = 12 < 15;
        boolean valorBooleanFalse = false;
        boolean valorNumericoBooleanFalse = 12 > 15;

        System.out.println("\n========= TIPO DE DATO PRIMITIVO \"boolean\" =========");
        System.out.println("Variable valorBooleanTrue = " + valorBooleanTrue);
        System.out.println("Variable valorNumericoBooleanTrue = " + valorNumericoBooleanTrue);
        System.out.println("Variable valorBooleanFalse = " + valorBooleanFalse);
        System.out.println("Variable valorNumericoBooleanFalse = " + valorNumericoBooleanFalse);
    }
}
<file_sep>package com._05_EstructurasAlgoritmicas._04_Switch;

public class _01_SwitchCase {
    public static void sentenciaSwitchCase() {
        Character numeroCaracter = '2';

        switch (numeroCaracter) {
            case '0':
                System.out.println("El Número Es Cero.");
                break;

            case '1':
                System.out.println("El Número Es Uno");
                break;

            case '2':
                System.out.println("El Número Es Dos");
                break;

            case '3':
                System.out.println("El Nùmero Es Tres");
                break;

            default:
                System.out.println("El Valor Ingresado No Es Vàlido");
                break;
        }
    }
}
<file_sep>package com._15_Exceptions;

import javax.swing.*;

public class _01_ExcepcionesUnchecked {
    public static void excepcionesNoComprobadas() {

        String valor = JOptionPane.showInputDialog("Ingrese Un Número Entero: ");

        try {

            int divisor = Integer.parseInt(valor);
            int division = 10 / divisor;
            System.out.println("division = " + division);

        } catch (NumberFormatException e) {
            System.out.println("Capturamos El Error En Tiempo De Ejecución Por Un Valor NO Númerico." + e.getMessage());

        } catch (ArithmeticException e) {
            System.out.println("Capturamos El Error En Tiempo De Ejecución Por Un Valor Cero." + e.getMessage());

        } finally {
            System.out.println("Es Opcional, Pero Se Ejecuta Siempre Con Excepción o Sin Ella!");
        }

        System.out.println("Continuamos Con El Flujo De La Aplicación Y Está" +
                " Puede Seguir Ejecutando Las Tareas Definidas.");
    }
}
<file_sep>package com._10_Arreglos;

public class _01_Explicacion {
    public static void CreateArrays() {
        int[] numbers = new int[4];

        numbers[0] = 134;
        numbers[1] = Integer.valueOf("2");
        numbers[2] = 34;
        numbers[3] = 10;

        int i = numbers[0];
        int j = numbers[1];
        int k = numbers[2];
        //int l = numbers[3];
        int l = numbers[numbers.length - 1];

        System.out.println("========== EXPLICACIÒN ARREGLOS ==========");
        System.out.println("i = " + i);
        System.out.println("j = " + j);
        System.out.println("k = " + k);
        System.out.println("l = " + l);
    }
}
<file_sep>package com._10_Arreglos;

public class Main {
    public static void main(String[] args) {

        _01_Explicacion.CreateArrays();
        _02_Ordenar.ordenarArreglo();
        _03_IterandoFor.recorriendoArreglosFor();
        _04_IterandoForEach.recorriendoArreglosForEach();
        _05_IterandoWhile.recorriendoArreglosWhile();
        _06_IterandoDoWhile.recorriendoArreglosDoWhile();
        _07_IterandoOrdenInverso.ordenInverso();
        _08_ModificandoOrdenReverso.modificandoArreglo();

    }
}
<file_sep>package com._02_Variables._05_TiposReferenciaObjeto;

public class Main {
    public static void main(String[] args) {

        _01_WrapperByte.objetoByte();
        _02_WrapperShort.objetoShort();
        _03_WrapperInteger.objetoInteger();
        _04_WrapperLong.objetoLong();
        _05_WrapperFloat.objetoFloat();
        _06_WrapperDouble.objetoDouble();
        _07_WrapperRelacionales.comparandoObjetos();
        _08_WrapperBoolean.comparandoObjetos();
        _09_WrapperGetClass.MethodGetClass();

    }
}
<file_sep>package com._05_ParametrosArgumentos;

public class _01_PorValor {
    public static void parametrosValor() {
        int i = 10;

        System.out.println("========== PASANDO ARGUMENTOS A LOS PARAMETROS DEFINIDOS ANTERIORMENTE POR VALOR ==========");
        System.out.println("Iniciando El Método Main Con i = " + i);
        test(i);

        System.out.println("Finaliza El Mètodo Main Con El Mismo Valor De i = " + i);
    }

    public static void test(int numeroI) {
        System.out.println("Iniciando El Mètodo test Con i = " + numeroI);

        numeroI = 35;
        test2(numeroI);
        System.out.println("Finaliza El Mètodo test Con El Nuevo Valor De i = " + numeroI);
    }

    public static void test2(Integer numeroI) {
        System.out.println("Iniciando El Mètodo test2 Con i = " + numeroI);

        numeroI = 35;
        System.out.println("Finaliza El Mètodo test2 Con El Nuevo Valor De i = " + numeroI);
    }
}
<file_sep>package com._02_Variables._01_TiposPrimitivos._01_Enteros;

public class _01_byte {
    public static void ValoresByte() {
        byte valorNumeroByte = 54;

        /* Cuando Se Exceda El Valor O La Capacidad Máxima Del Tipo De Dato Definido
        Tendremos El Siguiente Error: */
        /* incompatible types: possible lossy conversion from int to byte */
        /* byte excederByte = 129; */

        /* Casteo O Conversión De Tipos */
        /* El 129 Es De Tipo Entero Y Lo Que Hacemos Es Castearlo O Convertirlo A Un Tipo Byte */
        /* El Resultado Que Obtendremos Es Que No Se Esta Almacenando El 129 Como Lo Habiamos Indicado,
            * Por Que El Compilador Nos Dice Que Si Estamos Seguros De Lo Que Estamos Haciendo, Ya Que Si
            * Queremos Almacenar Un Valor Que Supera El Rango Del Tipo De Dato Del Indicador, Estamos Expuestos
            * A Tener Resultados Con Imprecisiones, Así, Sea Casteado O Convertido */
        byte excederByte = (byte) 129;

        System.out.println("\n========= TIPO DE DATO PRIMITIVO \"byte\" =========");
        System.out.println("Tipo byte Corresponde En Bits A: " + Byte.SIZE);
        System.out.println("Tipo byte Corresponde En Bytes A: " + Byte.BYTES);
        System.out.println("Nùmero Minimo Aceptado: " + Byte.MIN_VALUE);
        System.out.println("Nùmero Maximo Aceptado: " + Byte.MAX_VALUE);
        System.out.println("Variable valorNumeroByte = " + valorNumeroByte);
        System.out.println("El Valor Es Muy Grande Para Lo Que Soporta El Tipo BYTE excederByte = " + excederByte + " Obtenemos Valores Con Imprecisiones Por Que Perdemos Bits");
    }
}
<file_sep>package com._04_Operadores;

public class _02_Asignacion {
    public static void OperadoresAsignacion() {
        int i = 5;

        System.out.println("\n========== OPERADORES DE ASIGNACIÒN ==========");
        System.out.println("i = " + i);
        
        var isTrue = i == 5;
        System.out.println("i == 5 " + isTrue);

        i += 4;
        System.out.println("i += " + i);

        i -= 2;
        System.out.println("i -= " + i);

        i *= 3;
        System.out.println("i *= " + i);

        i /= 4;
        System.out.println("i /= " + i);

        i %= 2;
        System.out.println("i %= " + i);

        String sqlString = "SELECT * FROM clietes AS c";
        sqlString += " WHERE c.nombre = 'Daniel'";
        sqlString += " AND c.activo = 1";

        System.out.println("sqlString += " + sqlString);
    }
}
<file_sep>package com._05_ParametrosArgumentos;

import javax.swing.text.EditorKit;

public class _02_PorReferencia {
    public static void parametrosReferencia() {
        int[] edad = {10, 11, 12};

        System.out.println("\n========== PASANDO ARGUMENTOS A LOS PARAMETROS DEFINIDOS ANTERIORMENTE POR REFERENCIA ==========");
        System.out.println("Iniciamos El Método Main");

        for (int i = 0; i < edad.length ; i++) {
            System.out.println("edad = " + edad[i]);
        }

        System.out.println("Antes De LLamar El Mètodo Test");

        test(edad);

        System.out.println("Después De LLamar El Método Test");

        for (int i = 0; i < edad.length ; i++) {
            System.out.println("edad = " + edad[i]);
        }

        System.out.println("Finaliza El Mètodo Main Con Los Datos Del Arreglo Modificados");
    }

    public static void test(int[] edadArray) {
        System.out.println("\nIniciamos El Método Test");

        for (int i = 0; i < edadArray.length ; i++) {
            edadArray[i] += 20;
        }
    }
}
<file_sep>package com._16_CollectionAPI._03_Map.HashMap;

import java.util.HashMap;
import java.util.Map;

public class MapAnidados {
    public static void ejemploMapsAnidados() {
        System.out.println("\n========== RELACIONES DE OBJETOS MAP<kEY, VALUE> ==========");
        System.out.println("Las Relaciones De Objetos Es Similar A Cuando Un Atributo De Una Clase Puede Ser Del Tipo De Dato De Otra Clase");
        System.out.println("Un HashMap Puede Ser Del Tipo De Dato De Otra Clase, Pero También Puede Ser Del Tipo De Dato De Otro HashMap\n");

        Map<String, Object> persona = new HashMap<>();
        persona.put("edad", "30");
        persona.put(null, "12345");
        persona.put("nombre", "Daniel");
        persona.put("apellido", "yepez");
        persona.put("apellidoPaterno", "yepez");
        persona.put("email", "<EMAIL>");

        Map<String, String> direccion = new HashMap<>();
        direccion.put("calle", "78");
        direccion.put("numero", "122");
        direccion.put("pais", "Colombia");
        direccion.put("ciudad", "Medellin");
        direccion.put("departamento", "Antioquia");

        /** RELACIONAR LOS MAPS */
        persona.put("direccion", direccion);

        System.out.println("persona = " + persona);

        /** OBTENER UN MAP QUE ESTA DENTRO DE OTRO MAP */
        Map<String, String> direccionPersona = (Map<String, String>) persona.get("direccion");

        String pais = direccionPersona.get("pais");
        String ciudad = direccionPersona.get("ciudad");
        String departamento = direccionPersona.get("departamento");
        String barrio = direccionPersona.getOrDefault("barrio", "Por Defecto");

        System.out.println("El Pais Es = " + pais);
        System.out.println("El Departamento Es = " + departamento);
        System.out.println("La Ciudad Es = " + ciudad);
        System.out.println("El Barrio Es = " + barrio);
    }
}
<file_sep>package com._04_Operadores;

import java.util.Scanner;

public class _08_EjercicioLogicosLogin {
    public static void Login() {
        Scanner teclado = new Scanner(System.in);

        String username = "<NAME>";
        String password = "<PASSWORD>";

        String[] users = new String[3];
        String[] pass = new String[3];

        boolean isAuthenticate = false;

        for (int i = 0; (i < users.length && i < pass.length); i++) {

            System.out.println("Ingrese El Username Del Usuario #" + (i+1) + ":");
            users[i] = teclado.nextLine();

            System.out.println("Ingrese El Password Del Usuario #" + (i+1) + ":");
            pass[i] = teclado.nextLine();
        }

        System.out.println();
        for (int i = 0; (i < users.length && i < pass.length); i++) {

            if (users[i].equalsIgnoreCase(username) && pass[i].equalsIgnoreCase(password)) {
                isAuthenticate = true;
            } else {
                System.out.println("Username O Contraseña Incorrecto Del Usuario #" + (i+1) + " " + users[i]);
            }

            if(isAuthenticate) {
                System.out.println("Bienvenido Usuario ".concat(users[i]).concat("!"));
                isAuthenticate = false;
            }
        }
    }
}
<file_sep>package com._13_POO._09_CrudDAO;

import com._13_POO._09_CrudDAO.Repositorio.*;
import com._13_POO._09_CrudDAO.modelo.Cliente;

import java.util.List;

public class Main {
    public static void main(String[] args) {
        IAllInterfaces repositorio = new ClienteList();
        repositorio.crear(new Cliente("Daniel", "Yepez"));
        repositorio.crear(new Cliente("Fernando", "Vèlez"));
        repositorio.crear(new Cliente("Luci", "Martinez"));
        repositorio.crear(new Cliente("Andres", "Gùzman"));

        System.out.println("===== CREAR CLIENTES =====");
        List<Cliente> clientes = repositorio.listar();
        //clientes.forEach(c -> System.out.println(c));
        clientes.forEach(System.out::println);

        System.out.println("\n===== PAGINACIÒN DE CLIENTES =====");
        List<Cliente> paginable = repositorio.listar(1,3);
        paginable.forEach(System.out::println);

        System.out.println("\n===== ORDENAR CLIENTES ASC =====");
        List<Cliente> clientesOrdenAsc = repositorio.listar("nombre", Direccion.ASC);
        List<Cliente> clientesOrdenDesc = ((IOrdenable) repositorio).listar("nombre", Direccion.DESC);

        for (Cliente cli: clientesOrdenAsc) {
            System.out.println(cli);
        }

        System.out.println("\n===== ORDENAR CLIENTES DESC =====");
        for (Cliente cli: clientesOrdenDesc) {
            System.out.println(cli);
        }

        System.out.println("\n===== ACTUALIZAR CLIENTE =====");
        Cliente updateClient = new Cliente("<NAME>", "<NAME>");
        updateClient.setId(2);

        repositorio.editar(updateClient);
        System.out.println(updateClient);

        System.out.println("-----------------");
        repositorio.listar("nombre", Direccion.ASC).forEach(System.out::println);

        System.out.println("\n===== ELIMINAR CLIENTE =====");
        repositorio.eliminar(2);
        repositorio.listar().forEach(System.out::println);

        System.out.println("-----------");
        System.out.println("Total Registros: " + repositorio.total());
    }
}
<file_sep>package com._16_CollectionAPI._01_Set.HashSet;

import java.util.HashSet;
import java.util.Set;

public class Agregar {
    public static void EjemploHashSetAgregar() {

        Set<String> hs = new HashSet<>();

        System.out.println(hs.add("uno"));
        System.out.println(hs.add("dos"));
        System.out.println(hs.add("tres"));
        System.out.println(hs.add("cuatro"));
        System.out.println(hs.add("cinco"));
        System.out.println(hs);

        boolean b = hs.add("tres");

        System.out.println("Permite Elementos Duplicados: " + b);
        System.out.println(hs);
    }
}
<file_sep>package com._07_ClaseSystem;

import java.io.FileInputStream;
import java.util.Properties;

public class _02_AsignarPropiedadesDeSistema {
    public static void asignarPropiedades() {

        System.out.println("\n======== ASIGNANDO EL ARCHIVO DE PROPIEDADES =========");
        try {
            FileInputStream archivo = new FileInputStream("src/com/_07_ClaseSystem/_03_config.properties");

            Properties p = new Properties(System.getProperties());

            /** Definido Una Sola Propiedad */
            p.setProperty("mi.propiedad.personalizada","Mi Valor Guardado En La Propiedad Personalizada");

            /** Paso El Archivo De La Propiedades */
            p.load(archivo);

            System.setProperties(p);
            /** Forma Uno */
            // System.getProperties().list(System.out);

            /** Forma Dos */
            Properties ps = System.getProperties();
            ps.list(System.out);
        } catch (Exception e) {
            System.out.println("No Existe El Archivo: " + e);
        }
    }
}
<file_sep>package com._13_POO._03_Paquetes.hogar;

import com._13_POO._03_Paquetes.jardin.Perro;

/** Imports Staticos */
import static com._13_POO._03_Paquetes.hogar.Persona.saludar;

public class Main {
    public static void main(String[] args) {
        Persona persona = new Persona();
        String saludo = saludar();
        System.out.println("saludo = " + saludo);
        
        Perro perro = new Perro();
    }
}
<file_sep>package com._13_POO._03_Paquetes.jardin;

import com._13_POO._03_Paquetes.hogar.*;
//import com._04_POO._03_Paquetes.hogar.Gato;
//import com._04_POO._03_Paquetes.hogar.Persona;

/** Imports Staticos Asi No Tengo Que Poner El Nombre De La Clase */
import static com._13_POO._03_Paquetes.hogar.Persona.*;
//import static com._04_POO._03_Paquetes.hogar.Persona.saludar;
//import static com._04_POO._03_Paquetes.hogar.Persona.GENERO_FEMENINO;
//import static com._04_POO._03_Paquetes.hogar.Persona.GENERO_MASCULINO;

/** Imports Staticos De Un Enum Asi No Tengo Que Poner El Nombre Del Mismo */
import static com._13_POO._03_Paquetes.hogar.ColorPelo.*;
//import static com._04_POO._03_Paquetes.hogar.ColorPelo.NEGRO;
//import static com._04_POO._03_Paquetes.hogar.ColorPelo.CAFE;
//import static com._04_POO._03_Paquetes.hogar.ColorPelo.RUBIO;

public class Main {
    public static void main(String[] args) {
        /** FORMA #1 DE IMPORTAR UNA CLASE DE OTRO PAQUETE */
        //com._04_POO._03_Paquetes.Hogar.Persona persona = new com._04_POO._03_Paquetes.Hogar.Persona();

        /** FORMA #2 DE IMPORTAR UNA CLASE DE OTRO PAQUETE */
        Persona persona = new Persona();
        persona.setNombre("<NAME>");
        persona.setApellido("<NAME>");
        //persona.setColorPelo(ColorPelo.NEGRO);
        persona.setColorPelo(NEGRO);

        String saludando = saludar();
        String generoMujer = GENERO_FEMENINO;
        String generoMasculino = GENERO_MASCULINO;

        System.out.println("saludando Estatico = " + saludando);
        System.out.println("generoMujer = " + generoMujer);
        System.out.println("generoMasculino = " + generoMasculino);
        System.out.println("persona.getColorPelo() = " + persona.getColorPelo());
        System.out.println("persona.getNombre() + persona.getApellido() = " + persona.getNombre() + " " + persona.getApellido());
        
        Perro perro = new Perro();
        perro.nombre = "Tobby";
        perro.raza = "Pomeran";
        String jugando = perro.jugar(persona);
        System.out.println("jugando = " + jugando);
    }
}
<file_sep>package com._06_JavaUtil;

public class Main {
    public static void main(String[] args) {

        _01_Date.classDate();
        _02_GetTimeMilisegundos.getTime();
        _03_FechaPasadaFutura.fechaCalendar();
        _04_StringDateParse.StringAdate();
        _05_CompararFechas.dateCompare();
        _06_ClaseScanner.scanner();

    }
}
<file_sep>package com._05_EstructurasAlgoritmicas._08_DoWhile;

public class _01_SentenciaDoWhile {
    public static void iterandorDoWhile() {
        int i = 0;
        boolean test = false;

        System.out.println("========== ITERADOR DO WHILE PRUEBA ==========");
        do {
            if (i == 7) {
                test = false;
            }

            System.out.println("Se Ejecuta Como Minímo Una Sola Vez");
            System.out.println(i);
        } while (test);

        boolean test2 = true;

        System.out.println("\n========== ITERADOR DO WHILE ==========");
        do {
            if (i == 7) {
                test2 = false;
            }

            System.out.println(i);
            i++;
        } while (test2);
    }
}
<file_sep>package com._16_CollectionAPI._01_Set.TreeSet;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class Agregar {
    public static void EjemploTreeSet() {

        System.out.println("========== ORDENADOS DE FORMA NATURAL ==========");
        Set<String> ts = new TreeSet<>((a, b) -> b.compareTo(a));
        ts.add("uno");
        ts.add("dos");
        ts.add("tres");
        ts.add("tres");
        ts.add("cuatro");
        ts.add("cinco");

        System.out.println("TreeSet String: " + ts);

        Set<Integer> numeros = new TreeSet<>(Comparator.reverseOrder());
        numeros.add(1);
        numeros.add(5);
        numeros.add(3);
        numeros.add(4);
        numeros.add(2);
        numeros.add(6);
        numeros.add(10);

        System.out.println("TreeSet Números: " + numeros);
    }
}
<file_sep>package com._05_EstructurasAlgoritmicas._01_If;

public class Main {
    public static void main(String[] args) {
        _01_CondicionSimple.ifSimple();
    }
}
<file_sep>package com._05_EstructurasAlgoritmicas._09_EtiquetasCiclos;

public class _02_EjercicioBuscar {
    public static void iteradoresCombinados() {
        char letra = 'g';
        int cantidad = 0;
        String palabra = "Trigo";
        String frase = "Trigo Trigo Tres Tristes Tigres Tragan Trigo En Un TrigalTrigo";

        int countPalabra = palabra.length();
        int count = frase.length() - countPalabra + 1;

        System.out.println("\n========== EJERCICIO BUSCAR FRASE ==========");
        buscar:
        for (int i = 0; i < count; i++) {
            int k = i;

            for (int j = 0; j < countPalabra; j++) {

                if (frase.charAt(k++) != palabra.charAt(j)) {
                    continue buscar;
                }
            }
            cantidad++;
        }

        System.out.println("Encontrado = " + cantidad + " Veces La Palabra " + "\'" + palabra + "\'" + " En La Frase");
    }
}
<file_sep>package com._04_Operadores;

import java.util.Scanner;

public class _10_EjercicioMayorTernario {
    public static void numeroMayor() {
        Scanner teclado = new Scanner(System.in);

        int max = 0;

        System.out.println("Ingrese Un Valor Númerico: ");
        int num1 = teclado.nextInt();

        System.out.println("Ingrese Un Segundo Valor Númerico: ");
        int num2 = teclado.nextInt();

        System.out.println("Ingrese Un Tercer Valor Númerico: ");
        int num3 = teclado.nextInt();

        System.out.println("Ingrese Un Cuarto Valor Númerico: ");
        int num4 = teclado.nextInt();

        /** Lògica Nùmero Mayor */
        max = (num1 > num2) ? num1 : num2;
        max = (max > num3) ? max : num3;
        max = (max > num4) ? max : num4;

        System.out.println("num1 = " + num1);
        System.out.println("num2 = " + num2);
        System.out.println("num3 = " + num3);
        System.out.println("num4 = " + num4);
        System.out.println("El Nùmero Mayor Es max = " + max);
    }
}
<file_sep>package com._13_POO._09_CrudDAO.Repositorio;

public interface IAllInterfaces extends ICrud, IOrdenable, IPaginable, IContable {
}
<file_sep>package com._02_Variables._02_SistemasNumericos;

public class _01_SistemaDecimal {
    public static void SistemaDecimal() {
        int numeroDecimal1 = 500;
        int numeroDecimal2 = 302;

        System.out.println("=========== SISTEMA DECIMAL POR DEFECTO ==========");
        System.out.println("Numero Decimal De " + numeroDecimal1 + " = " + numeroDecimal1);
        System.out.println("Numero Decimal De " + numeroDecimal2 + " = " + numeroDecimal2);
    }
}
<file_sep>package com._13_POO._08_Interfaces.Imprenta;

import com._13_POO._08_Interfaces.Modelo.*;

public class Main {
    public static void main(String[] args) {
        Curriculo cv = new Curriculo(new Persona("<NAME>", "<NAME>"),
                                            "Desarrollador", "Resumen Laboral...");
        cv.addExperiencia("Java")
            .addExperiencia("Angular")
            .addExperiencia("Oracle DBA")
            .addExperiencia("Spring Framework")
            .addExperiencia("Desarrollador FullStack");

        Libro libro = new Libro(new Persona("Erich", "Gama"),
                                    "Patrones De Diseños: Elementos Reusables POO",
                                        Genero.PROGRAMACION);

        libro.addPagina(new Pagina("Patròn Singleton"))
                .addPagina(new Pagina("Patròn Observador"))
                .addPagina(new Pagina("Patròn Fabrica"))
                .addPagina(new Pagina("Patròn Compositor"));

        Informe info = new Informe(new Persona("Martin", "Fowler"),
                                    new Persona("James", "Gosling"),
                                        "Estudio Sobre MicroServicios");

        Imprimible.imprimir(cv);
        Imprimible.imprimir(info);
        Imprimible.imprimir(libro);

        /** Ejemplo De Una Clase Anonima Que Implementa La Interface Imprimible */
        Imprimible.imprimir(new Imprimible() {
            @Override
            public String imprimir() {
                return "Hola Que Tal!!! Imprimiendo Una Clase Genérico De Una Clase Anònima";
            }
        });

        System.out.println(Imprimible.TEXTO_DEFECTO);
    }

    /* public static void imprimir(Imprimible imprimible) {
        System.out.println(imprimible.imprimir());
    } */
}
<file_sep>package com._04_Operadores;

public class _13_CaracteresEspeciales {
    public static void especiales() {
        String nombre = "<NAME>";

        System.out.println("\n========== CARACTERES ESPECIALES ==========");
        System.out.println("Nueva Linea: \n" + nombre);
        System.out.println("Tabulador: \t" + nombre);
        System.out.println("Retroceso(Sin Espacios): \b\b" + nombre);
        System.out.println("Escapar Comilla Simple: \'" + nombre + "\'");
        System.out.println("Escapar Comilla Doble: \"" + nombre + "\"");

        char espacio = '\u0020';
        char retroceso = '\b';

        System.out.println("\n========= CARACTERES ESPECIALES \"char\" =========");
        System.out.println("Espacio => "  + espacio);
        System.out.println("Retroceso => " + retroceso);
        System.out.println("Tabulaciòn => \t");
        System.out.println("Salto De Linea => \n");
        System.out.println("Retorno Al Inicio => \r");
    }
}
<file_sep>package com._14_Generics.Clases;

public class _03_Maquinaria {

    private String tipo;

    public _03_Maquinaria(String tipo) {
        this.tipo = tipo;
    }

    public String getTipo() {
        return tipo;
    }

}
<file_sep>package com._05_EstructurasAlgoritmicas._03_IfElseIf;

public class Main {
    public static void main(String[] args) {

        _01_CondicionAnidada.ifAnidado();
        _02_EjercicioDiasMes.numeroDiasMes();

    }
}
<file_sep>package com._16_CollectionAPI._02_List.LinkedList;

import com._16_CollectionAPI._02_List.modelo.Alumno;

import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;

public class ComparableComparator {
    public static void ejemploLinkedList() {
        List<Alumno> sa = new LinkedList<>();

        sa.add(new Alumno("Pato", 20));
        sa.add(new Alumno("Camilo", 18));
        sa.add(new Alumno("Andres", 17));
        sa.add(new Alumno("Maria", 16));
        sa.add(new Alumno("Carmela", 15));
        sa.add(new Alumno("Roberto", 14));
        sa.add(new Alumno("Rosa", 11));
        sa.add(new Alumno("Rosa", 11));
        sa.add(new Alumno("Valencia", 12));
        sa.add(new Alumno("Valencia", 12));
        System.out.println(sa);

        System.out.println("\n========== LINKEDLIST COMPARABLE COMPARATOR ==========");
        // Forma Manual
        //Collections.sort(sa, (a, b) -> a.getNombre().compareTo(b.getNombre()));
        //sa.sort((a, b) -> b.getNombre().compareTo(a.getNombre()));

        // Utilizando Java 8 (Se Ordena Según El Atributo)
        //sa.sort(Comparator.comparing((Alumno a) -> a.getEdad()));
        //sa.sort(Comparator.comparing((Alumno a) -> a.getEdad()).reversed());

        // Optimizando Aún Más Con El Método De Referencia
        sa.sort(Comparator.comparing(Alumno::getEdad).reversed());

        System.out.println("\n========== Iterando LinkedList Usando While E Iterator ==========");
        sa.forEach(System.out::println);
    }
}
<file_sep>package com._13_POO._06_Herencia;

public class MainHerenciaConstructores {
    public static void main(String[] args) {
        Alumno alumno = new Alumno("<NAME>", "<NAME>", 27, "Instituto Nacional");
        alumno.setNotaCastellano(5.5);
        alumno.setNotaHistoria(6.3);
        alumno.setNotaMatematica(4.9);
        alumno.setEmail("<EMAIL>");

        AlumnoInternacional alumnoInternacional = new AlumnoInternacional("<NAME>", "<NAME>", "Colombia");
        alumnoInternacional.setEdad(22);
        alumnoInternacional.setInstitucion("Enrique Olaya Herrera");
        alumnoInternacional.setNotaIdiomas(6.8);
        alumnoInternacional.setNotaCastellano(6.2);
        alumnoInternacional.setNotaHistoria(5.8);
        alumnoInternacional.setNotaMatematica(6.5);
        alumnoInternacional.setEmail("<EMAIL>");

        Profesor profesor = new Profesor("<NAME>", "<NAME>", "Matematicas");
        profesor.setEdad(37);
        profesor.setEmail("<EMAIL>");

        MainHerenciaConstructores.imprimir(alumno);
        MainHerenciaConstructores.imprimir(alumnoInternacional);
        MainHerenciaConstructores.imprimir(profesor);
    }

    public static void imprimir(Persona persona) {
        System.out.println("\nImprimiendo Datos Del Tipo Persona General =>");
        System.out.println("Nombre: " + persona.getNombre()
                + "\nApellido: " + persona.getApellido()
                + "\nEdad: " + persona.getEdad()
                + "\nEmail: " + persona.getEmail());

        if (persona instanceof Alumno) {
            System.out.println("\nImprimiendo Datos Del Tipo Alumno =>");
            System.out.println("Instituciòn: " + ((Alumno) persona).getInstitucion());
            System.out.println("Nota Matemàticas: " + ((Alumno) persona).getNotaMatematica());
            System.out.println("Nota Historia: " + ((Alumno) persona).getNotaHistoria());
            System.out.println("Nota Castelllano: " + ((Alumno) persona).getNotaCastellano());

            if (persona instanceof AlumnoInternacional) {
                System.out.println("\nImprimiendo Datos Del Tipo Alumno Internacional =>");
                System.out.println("Nota Idioma: " + ((AlumnoInternacional) persona).getNotaIdiomas());
                System.out.println("Pais: " + ((AlumnoInternacional) persona).getPais());
            }

            System.out.println("\n=============== SOBRE ESCRITURA PROMEDIO =====================");
            System.out.println("Promedio: " + ((Alumno) persona).calcularPromedio());
            System.out.println("=============== SOBRE ESCRITURA PROMEDIO =====================");
        }

        if (persona instanceof Profesor) {
            System.out.println("\nImprimiendo Datos Del Tipo Profesor =>");
            System.out.println("Asignatura: " + ((Profesor) persona).getAsignatura());
        }

        System.out.println("\n=============== SOBRE ESCRITURA SALUDAR =====================");
        System.out.println(persona.saludar());
        System.out.println("=============== SOBRE ESCRITURA SALUDAR =====================");
    }
}
<file_sep>package com._05_EstructurasAlgoritmicas._07_While;

public class _01_SentenciaWhile {
    public static void iteradorWhile() {
        int i = 0;

        System.out.println("========== ITERADOR WHILE NUMBER ==========");
        while (i < 5) {
            System.out.println("i = " + i);
            i++;
        }

        boolean prueba = true;

        System.out.println("\n========== ITERADOR WHILE BOOLEAN ==========");
        while (prueba) {
            if (i == 7) {
                prueba = false;
            }

            System.out.println("i = " + i);
            i++;
        }

    }
}
<file_sep>package com._02_Variables._01_TiposPrimitivos._05_Dinamico;

public class _08_var {
    public static void ValoresVar() {
        /* var => Solo Funciona Para Variables Locales, Para Variables De Clase (Atributos) O
        Para Definir Parametros No Es Posible */

        // Tipo De Dato Inferencial
        var valorVar = 555f;
        var valorUnicode = '\u0040'; // Valor Unicode
        var valorInt = 64; // Ojo Se Infiere Como Un Valor Entero(INT) Y No Como Un Valor Decimal(CHAR)

        System.out.println("\n========= TIPO DE DATO PRIMITIVO \"var\" =========");
        System.out.println("Es Un Tipo De Dato Variable O Dinàmico, Por Que Dependiendo De Su Valor Define O Infiere El Tipo De Dato");
        System.out.println("valorVar = " + valorVar);
        System.out.println("valorVar = " + valorUnicode);
        System.out.println("valorVar = " + valorInt);
    }
}
<file_sep>package com._16_CollectionAPI._01_Set.HashSet;

import java.util.HashSet;
import java.util.Set;

public class DuplicadosSegmentados {
    public static void EjemploHashSetBuscarDuplicadoSegmentado() {
        System.out.println("\n========== EJEMPLO DUPLICADOS SEGMENTADOS ===========");
        String[] peces = {"Corvina", "Lenguado", "Pejerrey", "Corvina", "Robalo", "Atún", "Lenguado"};

        Set<String> unicos = new HashSet<>();
        Set<String> duplicados = new HashSet<>();

        for (String pez: peces) {
            if (!unicos.add(pez)) {
                duplicados.add(pez);
            }
        }

        unicos.removeAll(duplicados);

        System.out.println("Unicos: " + unicos);
        System.out.println("Duplicados: " + duplicados);
    }
}
<file_sep>package com._06_JavaUtil;

import java.util.Date;

public class _02_GetTimeMilisegundos {
    public static void getTime() {
        /** TRABAJANDO CON LA FECHA ACTUAL DEL SISTEMA */
        System.out.println("\n========== MÈTODO GETTIME MILISEGUNDOS POR DEFECTO ==========");

        long j = 0;
        Date fecha = new Date();

        for (int i = 0; i < 1000000; i++) {
            j += i;
        }

        System.out.println("j = " + j);

        Date fecha2 = new Date();
        long tiempoFinalMilisegundos = fecha2.getTime() - fecha.getTime();

        System.out.println("Tiempo Transcurrido En El for = " + tiempoFinalMilisegundos);
    }
}
<file_sep>package com._13_POO._05_Sobrecarga;

import static com._13_POO._05_Sobrecarga.Calculadora.*;

public class Main {
    public static void main(String[] args) {
        Calculadora calculadora = new Calculadora();

        System.out.println("Sumar Int: " + sumar(10,5));
        System.out.println("Sumar Float: " + sumar(10.0F, 5F));
        System.out.println("Sumar Float - Int: " + sumar(10F, 5));
        System.out.println("Sumar Int - Float: " + sumar(10, 5.0F));
        System.out.println("Sumar Double: " + calculadora.sumar(10D, 5D));
        System.out.println("Sumar String: " + calculadora.sumar("10", "5"));
        System.out.println("Sumar Tres Int: " + calculadora.sumar(10, 5, 3));
        System.out.println("Sumar Long: " + calculadora.sumar(10L, 5L));
        System.out.println("Sumar Int: " + calculadora.sumar(10, '@'));
        System.out.println("Sumar Float - Int: " + calculadora.sumar(10F, '@'));
        System.out.println("Sumar Int Argumentos Variables: " + calculadora.sumar(10, '@', 3, 4, 5));
        System.out.println("Sumar Float - Int Argumentos Variables: " + calculadora.sumar(12F, 34, 10, '@', 3, 4, 5));
        System.out.println("Sumar Double Argumentos Variables: " + calculadora.sumar(10_5D, 10_0, 123e6D, 11F));
    }
}
<file_sep>package com._02_Variables._01_TiposPrimitivos._02_Decimales;

public class _05_float {
    public static void ValoresFloat() {
        float valorNumeroFloat = 9223372036e7F;
        float valorNumeroFloat2 = 1.5e-10f; // 0.00000000015f

        /* Cuando Se Exceda El Valor O La Capacidad Máxima Del Tipo De Dato Definido
        Tendremos El Siguiente Error: */
        /* floating point number too large */
        /* int excederFloat = 3.4028236E38F; */

        /* Casteo O Conversión De Tipos */
        /* El 3.4028236E38F Es De Tipo Punto Flotante, Especificamente float Y Lo Que Hacemos Es Definir
         * El Valor De Ese Float Como Double Y Luego Lo Casteamos A Float */
        /* El Resultado Que Obtendremos Es Que No Se Esta Almacenando El 3.4028236E38F Como Lo Habiamos Indicado,
         * Por Que El Compilador Nos Dice Que Si Estamos Seguros De Lo Que Estamos Haciendo, Ya Que Si
         * Queremos Almacenar Un Valor Que Supera El Rango Del Tipo De Dato Del Indicador, Estamos Expuestos
         * A Tener Resultados Con Imprecisiones, Así, Sea Casteado O Convertido */
        float excederFloat = (float) 3.4028236E38;

        System.out.println("\n========= TIPO DE DATO PRIMITIVO \"float\" =========");
        System.out.println("Tipo float Corresponde En Bits A: " + Float.SIZE);
        System.out.println("Tipo float Corresponde En Bytes A: " + Float.BYTES);
        System.out.println("Nùmero Minimo Aceptado: " + Float.MIN_VALUE); // Valor Minimo Tenemos -45 Posiciones A La Izquierda
        System.out.println("Nùmero Maximo Aceptado: " + Float.MAX_VALUE); // Valor Maximo Tenemos 38 Posiciones A La Derecha
        System.out.println("Variable valorNumeroFloat = " + valorNumeroFloat);
        System.out.println("Variable valorNumeroFloat2 = " + valorNumeroFloat2);
        System.out.println("El Valor Es Muy Grande Para Lo Que Soporta El Tipo FLOAT excederFloat = " + excederFloat + " Obtenemos Valores Con Imprecisiones Por Que Perdemos Bits");
    }
}
<file_sep>package com._14_Generics.Metodos;

import com._13_POO._09_CrudDAO.modelo.Cliente;
import com._13_POO._09_CrudDAO.modelo.ClientePremium;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class _03_GenericosComodines {
    public static void genericosComodines() {
        System.out.println("\n========== WILDCARDS GENERICS(Comodin '?') ==========");

        List<Cliente> clientes = new ArrayList<>();
        clientes.add(new Cliente("Daniel", "Fernando"));

        Cliente[] clientesArreglo = {new Cliente("Luciano", "Fernando"),
                new Cliente("Andres", "Camilo")};
        Integer[] enterosArreglo = {1, 2, 3};

        /** Método Stático fromArrayToList */
        List<Cliente> clientesLista = fromArrayToList(clientesArreglo);
        List<Integer> enterosLista = fromArrayToList(enterosArreglo);

        clientesLista.forEach(System.out::println);
        enterosLista.forEach(System.out::println);

        List<ClientePremium> clientesPremiumList = fromArrayToList(
                new ClientePremium[]{new ClientePremium("Paco", "Fernando Premium")});
        clientesPremiumList.forEach(System.out::println);

        List<String> nombres = fromArrayToList(new String[]{"Bea", "Max", "Luz", "Maxi"}, enterosArreglo);
        nombres.forEach(System.out::println);

        imprimirClientes(clientes);
        imprimirClientes(clientesLista);

        imprimirClientesComodin(clientes);
        imprimirClientesComodin(clientesPremiumList);
    }

    public static <T> List<T> fromArrayToList(T[] general) {
        /** Recibe Un Arreglo Y Lo Convierte En Una Lista */
        return Arrays.asList(general);
    }

    public static <T extends Number> List<T> fromArrayToList(T[] general) {
        /** Recibe Un Arreglo Y Lo Convierte En Una Lista */
        return Arrays.asList(general);
    }

    /** Trabaja Con Clientes O Con Sus Subclases(Clase Hijas) Màs Cercanas */
    public static <T extends Cliente & Comparable<T>> List<T> fromArrayToList(T[] general) {
        /** Recibe Un Arreglo Y Lo Convierte En Una Lista */
        return Arrays.asList(general);
    }

    public static <T, G> List<T> fromArrayToList(T[] parametroGeneral, G[] parametroGeneral2) {

        System.out.println(" ");
        for (G elemento: parametroGeneral2) {
            System.out.println(elemento);
        }

        /** Recibe Un Arreglo Y Lo Convierte En Una Lista */
        return Arrays.asList(parametroGeneral);
    }

    /** Los Comodines Solo Se Pueden Utilizar En Las Listas */
    /** No Recibe ClientesPremium Por Que Solo Es Una Lista De Tipo
     * Cliente, En Conclusión, Aqui No Recibe Sub-clases O Descendencia
     * Del Tipo Cliente, Como Es El Caso De clientesPremium,
     * ¿POR QUÉ? Porque Estamos Hablando De Listas En Los
     * Parametros, Mas No, De Objetos, Entonces, Una Lista De
     * Clientes Es Totalmente Diferente De Una Lista De
     * Clientes Premium */
    public static void imprimirClientes(List<Cliente> clientes) {
        clientes.forEach(System.out::println);
    }

    /** Para Que Reciba Clientes De Cualquier Tipo
     * Incluyendo Sub-clases O Descendencia Debe Utilizar El Comodin "?" */
    public static void imprimirClientesComodin(List<? extends Cliente> clientes) {
        clientes.forEach(System.out::println);
    }
}
<file_sep>package com._02_Variables._03_ConversionDeTipos;

public class Main {
    public static void main(String[] args) {

        _01_CadenasAPrimitivos.cadenasAprimitivos();
        _02_PrimitivosACadenas.primitivosACadenas();
        _03_PrimitivosAPrimitivos.primitivosAprimitivos();
        _04_PrimitivosAObjetos.primitivosAobjetos();
        _05_ObjetosAPrimitivos.objetosAprimitivos();
        _06_CadenasAObjetos.cadenasAobjetos();

    }
}
<file_sep>package com._16_CollectionAPI._03_Map.HashMap;

import java.util.HashMap;
import java.util.Map;

public class Concepto {
    public static void ejemploHashMap() {
        System.out.println("========== DEFINICIÓN DEL CONCEPTO MAP<kEY, VALUE> ==========");

        Map<String, String> persona = new HashMap<>();

        /** Guardar En El Map (Las LLaves Son Unicas, Solo Deja La Ultima LLave Leída) */
        persona.put(null, "12345");
        persona.put("nombre", "Daniel");
        persona.put("apellido", "yepez");
        persona.put("apellidoPaterno", "yepez");
        persona.put("email", "<EMAIL>");
        persona.put("edad", "30");

        System.out.println("persona = " + persona);

        /** OBTENER VALORES DEL MAP */
        String nombre = persona.get("nombre");
        System.out.println("nombre = " + nombre);

        String apellido = persona.get("apellido");
        System.out.println("apellido = " + apellido);
    }
}
