Clase01

package clase01;

// Clase
/**
 * Clase principal del proyecto 05/09/2018
 * @author EducaciónIT
 */
public class Clase01 {
    /**
     * Modificaciones: se documentan en JavaDOC
     * Punto de entrada del proyecto
     * Ejecutar -> Generar JavaDOC (para relevar todos los comentarios JavaDOC)
     *  Específico de NetBeans
     * @param args Entrada de parámetros de consola
     */
    // Método
    public static void main(String[] args) {
        /*
        Curso: Java Standard Programming 8.X
        Días: Lunes y Miércoles 10:00 a 13:00
        Profesor: Carlos P. Ríos carlos.rios@educacionit.com
        Materiales: alumni.educacionit.com
            user: email (con el que estoy registrado)
            pass: dni
        Software: JDK 8.X o superior    oracle.com
                    netbeans ide        netbeans.org

        JDK: Java Development Kit -> herramienta del lenguaje
            Java Compiler. El Java es libre (!= C#), pero el
            JDK es privativo (!= Open JDK [alternativo])

            Versiones JDK
            LTS: Long Time Support (8 years) [en otras 6 meses]
                Para desarrollo prolongado. En producción hay que usar lo que
                tenga soporte (LTS).
            Compatibilidad de atrás hacia adelante (un script en Java 1
            puede compilarse en Java 11, va a ser obsoleto e inseguro,
            pero funciona). Compatibilidad asegurada.

            JDK 8 LTS Se liberó en marzo 2014 y tiene soporte hasta marzo
            2022
            JDK 9 (NO LTS) Se liberó en septiembre 2017 hasta marzo 2018
            Cada 6 meses una versión nueva. Cada 18 meses un LTS nuevo.
            JDK 10         Se liberó en marzo 2018 hasta septiembre 2018
            JDK 11 LTS     Se libera en septiembre 2018 hasta septiembre 2026
            JDK 12 (no LTS) Se libera en marzo 2019. Versiones experimentales.
                            Hasta septiembre 2019
            JDK 13 (no LTS) Se libera en septiembre 2019 hasta marzo 2020.
            JDK 14 LTS      Se libera en marzo 2020 hasta marzo 2028.

        IDE (Integrated Development Environment)
        NetBeans 8.X    Funciona con JDK 8 o inferior
            Instalar NetBeans 8.X   y   JDK 8
        NetBeans 9 Beta Funciona con JDK 9 o superior

        IDEs Alternativos: Eclipse JDeveloper IntelliJ
        */

        // Linea
        /* Bloque */

        /**
         * Comentario JavaDOC
         * Se debe colocar antes de la declaración de clases o de métodos
         * No conviene modificar la documentación si no concuerdan los tipos
         * de datos, por ejemplo (que es lo que dicen en las facultades).
         * La documentaciòn es para una etapa de diseño, no para el ciclo de vida.
         *
         * Al escribir Clase01. aparece el JavaDOC. Lo mismo String. o System.
         *
         *
         * El programador con experiencia está siendo un recurso caro
         * (!= analistas de sist.)
         *
         *
         */

        /* Tipo de datos primitivos. Java es un lenguaje tipado
        Tipo de datos boolean    0 1 = ocupa un byte (=8 bits)

        byte = 010101010         El SO labura la memoria byte a byte
                                    bool = desperdicia bits. Usar los
                                    desperdiciados es más costoso
                                    que desperdiciarlos
        Atajo sout + TAB = System.out.println("");
        */

        boolean bo=true;
        System.out.println(bo);
        bo = false;
        System.out.println(bo);

        // Los tipos de datos enteros son signed ùnicamente
                                    // signed = negativo o positivo
        // Tipo de dato byte        1 byte signed (-128 a 127)
        byte by =100;
        System.out.println(by);

        // C# admite byteU Unsigned     1 byte Unsigned (0 a 255).
        // En Java solo es signed. Es un pequeño desperdicio de memoria

        // Tipo de datos entero short 2 bytes
        // 2^16
        short sh = 3000;
        System.out.println( sh );

        //Tipo de datos int 4 bytes
        // 2^32
        // 2 mil millones
        int in=2000000000;
        System.out.println(in);
        // Tipo de datos long  8 bytes (64 bits)
        // 16 cifras
        // 3000000000 da error. Hay que aclarar que la literal es long
        // por defacto Java lo toma como int
        // Hay que agregar la L (mayúscula) porque en minùscula parece un uno
        long lo=3000000000L;
        System.out.println(lo);

        // No hay un tipo de datos en 128 bit. En otros lenguajes puede haber

        // Tipos de datos char (unsigned, único) 2 bytes
        // Entero de 2 byte 0 a 65535
        // La tabla ASCII usa un byte, 255 valores (0 a 254)
        // Después siguen otras tablas para alfabetos no latinos
        char ch =65; // Guarda el 65 pero imprime A mayúscula
        System.out.println(ch);
        ch+=32; // sumé 32. Misma letra en minúscula
        System.out.println(ch);

        // Tipos de datos float 32 bits
        // Hay que agregar la f, por default = double
        float fl = 9.25f;
        System.out.println(fl);

        // Tipo de datos double 64 bits
        double dl=9.25;
        System.out.println(dl);

        fl=10;
        dl=10;

        // Ejecutar F6
        // El último dígito en float es muy impreciso. C# no lo muestra.
        // El punto "flota" en toda la longitud del número. Depende del
        // tamaño de la parte entera.
        System.out.println(fl/3);
        System.out.println(dl/3);

        fl=100;
        dl=100;

        System.out.println(fl/3);
        System.out.println(dl/3);

        // Clase String
        // Empieza con mayúscula. Es una clase. No lo muestra en azul
        // porque no es un tipo de datos, es una clase
        // Vector char = 4 posiciones, 4 variables char por letra
        // Apretar Ctrl y mover el mouse por encima de String
        // private final char value[];
        String st= "Texto";
        System.out.println(st);

        // hasta Java 9 String almacena en un array de char
        // 4 letras 8 bytes
        // Java 10 o superior el vector es byte no char.
        // private final byte value[];

        // Tipo de datos que solo funciona a partir Java 10
        // var = toma cualquier tipo de datos. No es mutable
        // var var1=20; // int
        // var1=534;
        // var1=3.14;   // Error. Fue inicializado en int y así se queda
        // var var2= 3.14; // Double
        // var var3=3.14f; // Float
        // var var4=true; // Bool
        // var var5="Hola"; // String
        // var var6=1000L; // Long

        // Es un atributo (en paradigma), no puedo accederlo directamente.
        // Está encapsulado. Leer sobre paradigmas.
        // private final char value[];
        String cadena = "Esto es una cadena de texto";
        // No puedo acceder a value como cadena.value; Es privado.
        System.out.println("Longitud: " +cadena.length());

        //Imprimir cadena en mayúsculas
        // Para recorrer el vector desde  hasta lenght

        for (int a=0; a<cadena.length(); a++) {
                        // Método. Me lo devuelve como char aunque sea byte
                        // el vector (array)

            // Preferentemente afuera del for para la performance
            // Las versiones más modernas de toda formas lo pasan
            // al for al lado del int.
            // Se hace para legibilidad y mantenimiento
            char car = cadena.charAt( a );

            if ( car>=97 && car<=122) car -=32; // Fuente -> Formato para identear

            System.out.print(car); // println uno abajo del otro. Solo print
        }

        System.out.println(); // Salto de línea

        // Operador ternario ?
        // Tiene tres términos
        for (int a=0; a <cadena.length(); a++){
            char car=cadena.charAt(a);

            //a++ = operador unario. Un solo término
            //a+=32; operador y dos términos = binario

            // Pasé de estructura a funciòn
            System.out.println( ( car>=97 && car<=122 ) ? car -=32 : car );
        }

        System.out.println(); // Ejecuto y da el mismo resultado

        // Imprimir cadena en minúsculas
        for (int a=0; a <cadena.length(); a++){
            char car=cadena.charAt(a);

            //a++ = operador unario. Un solo término
            //a+=32; operador y dos términos = binario

            // Pasé de estructura a funcion                 YES     NO
            System.out.println( ( car>=65 && car<=90 ) ? car +=32 : car );
        }

        // Programación orientada a aspectos (!= objetos). Apareció en 2001

        System.out.println();

        // Método que ya recorre el vector por dentro
        // Quita la responsabilidad de usar if, else, while, do while, for
        System.out.println(cadena.toLowerCase());
        System.out.println(cadena.toUpperCase());

        // No hay que hacer guardar como porque se duplica el archivo pero se
        // ejecuta el primero
    }
}