Curso de programación con java

    Autor: Luis Fernando Apáez Álvarez

    -Curso PyM-

    Clase 1: Primeros pasos

    Fecha: 02 de diciembre del 2022

Instalación y configuración de java en visual estudio code:

• Opción 1
• Opción 2: video1, video2

Contenido

• Hola mundo en java
• Variables
• Operadores
• Booleanos y condicionales

Una vez instalado y configurado java (en mi caso utilizo visual studio code), es preciso mencionar que todo dentro de java estará estructurado como clases y objetos.

Hola mundo

De tal manera, si queremos imprimir el famoso Hola mundo deberemos de crear un clase, la cual denominaremos HolaMundo. Dentro de dicha clase definiremos el método principal de dicha clase, denominado main , en el cual colocamos el tipo de dato del argumento que recibirá, en este caso el método principal recibirá una cadena de texto (tipo String). Finalmente, dentro de este método colocamos la instrucción System.out.println("Hola Mundo"); la cual nos imprimirá en consola el mensaje "Hola Mundo".

xxxxxxxxxx
// Esto es un comentario

public class HolaMundo{
    public static void main(String args[]) {
        System.out.println("Hola Mundo");
    }
}

De lo anterior podemos decir que:

• Dentro de java existen distintos tipos de clases, algunas de ellas son clases públicas o privadas, que tiene que ver con el acceso que permiten, ya sea que permiten ser accedidas a ellas por cualquier otra clase o no. Por ello colocamos inicialmente public class.
• Asimismo, el método main es un método estático, de ahí que se haya colocado public static, lo cual quiere decir además que el método es público. Luego, dado que el método no devolverá nada, entonces se coloca void. Si por ejemplo el método regresará un número entero, entonces colocaríamos en su lugar public static int.
• Finalmente, System.out.println("Hola Mundo"); es la instrucción que empleamos para imprimir, la cual es su correspondiente análogo de java a la función print() de python.

Variables

Dado que ya sabemos lo básico del lenguaje python, lo que haremos inicialmente será "espejear" los conceptos de python con los siguientes de java

xxxxxxxxxx
// Variable entera y de cadena
public class Variables_I {
    public static void main(String args[]) {
        // Declaracion de la variable
        int miVariableEntera = 10;
        System.out.println(miVariableEntera);
        
        // Declaramos una variable de tipo cadena
        String miVariableCadena = "Hola";
        System.out.println(miVariableCadena);
        
        // Cambiamos el valor de la variable
        miVariableCadena = "Adios";
        System.out.println(miVariableCadena);

        // var --> inferencia del tipo de dato
        var miVariableEntera2 = 5;
        System.out.println(miVariableEntera2);

        // concatenando
        System.out.println("miVariableEntera2= " + miVariableEntera2);
    }
}

Respecto a las concatenaciones y a las cadenas de texto:

xxxxxxxxxx
public class Variables_II {
    public static void main(String args[]) {
        // Definimos dos variables
        var usuario = "Juan";
        var titulo = "Mat";

        // Concatenamos
        var union = titulo + " " + usuario;
        System.out.println("union = " + union);

        // Salto de linea
        System.out.println("Nueva linea: \nSegunda linea");

        // Tabulador
        System.out.println("Tabulador: \tlo que sigue ");
    }
}

xxxxxxxxxx
union = Mat Juan
Nueva linea: 
Segunda linea
Tabulador:      lo que sigue

Más sobre variables

xxxxxxxxxx
public class variable_III {
    public static void main(String args[]) {
        /*Tipos de datos primitivos enteros: byte, short, 
        int, long
         */
        // Veamos cuantos los valores que puede tomar byte
        System.out.println("Valor minimo: " + Byte.MIN_VALUE);
        System.out.println("Valor maximo: " + Byte.MAX_VALUE);

        // Variable de tipo char (solo almacena un caracter)
        char miCaracter = 'a';
        System.out.println(miCaracter);

        // Caracter unicode
        char miCaracter2 = '\u0021';
        System.out.println(miCaracter2);

        // Otra alternativa
        char miCaracter3 = 33;
        System.out.println(miCaracter3);

        /*Podemos obtener el codigo unicode
         * de un caracter en especifico
         */
        int unicodeSimbolo = '!';
        System.out.println(unicodeSimbolo);
    }
}

xxxxxxxxxx
Valor minimo: -128
Valor maximo: 127
a
!
!
33

Operadores

Definimos una nueva clase con un método principal integrado. Para definir una variable en java debemos especificar primero el tipo de dato de la variable, después colocamos el nombre de la variable y finalmente su valor. Cada instrucción en java debe terminar por ;.

xxxxxxxxxx
/*
Esto es un
comentario multilinea
*/
public class operadores_I {
    public static void main(String args[]) {
        // Definimos dos variables enteras
        int a=2, b=3;
        // Definimos una variable que almacene el resultado
        // de la suma entre las variables anteriores
        int result = a + b;
        // o alternativamente podemos definir la siguiente variable
        var suma = a + b;
        // imprimimos los resultados en consola
        System.out.println(suma);
        System.out.println(result);
        /*
        .
        .
        .
        */

donde al colocar var al inicio de la variable suma=a+b hacemos que java infiera de manera automática el tipo de dato resultante de efectuar a+b. continuando

xxxxxxxxxx
        /*
        .
        .
        .
        El siguiente resultado sera cero pues estamos
        trabajando con dos enteros, de modo que el
        resultado debe ser entero tambien
        */
        var division = a / b;
        System.out.println(division);

        // La solucion del problema es crear otra variable
        var division2 = 2.0 / b;
        System.out.println(division2);
        /*
        .
        .
        .
        */

donde ahora como el 2.0 es flotante, por coerción de tipos tendremos que el resultado de 2.0/b será un flotante.

Podemos definir también variables booleanas, además de utilizar operadores booleanos.

xxxxxxxxxx
        /*
        .
        .
        .
        Operador de autoincremento
        */
        a += 1;
        System.out.println(a); 
        // Operadores unarios:
        // Negacion: !
        var c = true;
        // debera tener asociado el valor booleano
        // de false 
        var d = !c;
        System.out.println(d);
        /*
        .
        .
        .
        */

Recordamos que en python el operador de autoincremento era el mismo que en java, esto es, si queremos realizar un autoincremento de uno a una variable, en python escribíamos:

xxxxxxxxxx
x = 0
# ahora x valdra uno
x += 1

Por otro lado, en java tenemos dos operadores que no conocíamos hasta ahora: el operador de preincremento y el operador de posincremento.

xxxxxxxxxx
        /*
        .
        .
        .
        Preincremento
        */
        var x = 2;
        var y = ++x;
        System.out.println(x + "," + y);

        // Pos incremento
        var n = 5;
        var m = n++;
        System.out.println(n + "," + m);
    }
}

donde el operador de posincremento incrementa el valor de la variable después de ser utilizado y el operador de preincremento incrementa el valor de la variable antes de ser utilizado.

Para el caso en que hemos escrito

xxxxxxxxxx
        // Preincremento
        var x = 2;
        var y = ++x;
        System.out.println(x + " , " + y);

xxxxxxxxxx
3 , 3

el valor inicial de x es de 2, luego, dado que el operador de preincremento incrementa la variable antes de ser utilizada y como y está "utilizando" la variable, entonces el valor de y será de 3, pero además de que en el instante var y = ++x el valor de ++x es de 3, el incremento hecho se ve reflejado en la propia variable x, de donde el valor final de x será de 3 también.

De tal manera, podemos decir que ++x no actúa de manera aislada únicamente en la asignación de la variable y, más bien, actúa en el incremento de todas las variables que involucren a la x.

Por otro lado

xxxxxxxxxx
        // Pos incremento
        var n = 5;
        var m = n++;
        System.out.println(n + " , " + m);

xxxxxxxxxx
6 , 5

el valor inicial de n es de 5 y el valor de m será también de 5. Lo que ocurre es que primero se hizo la asignación de var m = n (donde n vale 5), y después de dicha asignación se ha incrementado el valor de la n, esto es, el valor final de la n es de 6.

Más de operadores

xxxxxxxxxx
public class operadores_II {
    public static void main(String args[]) {
        // Operaciones relacionales:
        // Operador de igualdad ==
        var b = 4;
        var c = 5;
        //       |false|
        var d =  b == c;
        System.out.println(d);

        // Distinto !=
        //       |true|
        var e =  b != c;
        System.out.println(e);

        // Comparar el contenido de cadenas
        var saludo = "Hola";
        var despedida = "adios";
        var f = saludo.equals(despedida);
        System.out.println(f);

        var g = saludo.equals(saludo);
        System.out.println(g);

        // And: && (&)
        // Or: || (|)

        // Operador ternario
        var resultado = (3>2) ? "Éxito" : "Sentencia falsa";
        System.out.println(resultado);
    }
}

xxxxxxxxxx
false
true
false
true
Éxito

Tal vez lo nuevo del código anterior es el operador ternario. Considerando (3>2) ? "Éxito" : "Sentencia falsa"

tenemos que inicialmente hemos colocado la condición, si dicha condición es verdadera entonces se arrojará la cadena "Éxito", caso contrario se arrojará la cadena "Sentencia falsa".

Booleanos y condicionales

Finalizamos con variables booleanas y con el condicional if

xxxxxxxxxx
public class Variable_IV {
    public static void main(String args[]) {
        // Variables booleanas
        boolean varBooleana = true;
        System.out.println(varBooleana);

        // condicional if
        if (varBooleana){
            System.out.println("La variable es verdadera");
        }
        else{
            System.out.println("La variable es falsa");
        }

        // Utilizaremos de otra forma las variables booleanas
        var edad = 25;
        var esAdulto = edad >= 18;
        System.out.println(esAdulto);

        // O alternativamente
        if (edad >= 18){
            System.out.println("Eres mayor de edad");
        }
        else{
            System.out.println("Eres menor de edad");
        }
    }
}

xxxxxxxxxx
true
La variable es verdadera
true
Eres mayor de edad

y donde vemos que la estructura básica del condicional if dentro de java es de la forma

xxxxxxxxxx
// condicional if
if (<condicion a validar>){
    <instruccion que se ejecuta en caso de que
        la condicion sea verdadera>
}
else{
    <instruccion que se ejecuta en caso de que
        la condicion sea falsa>
}