Expresiones en Java: tipos y ejemplos

Las expresiones nos sirven para hacer cálculos y manipular valores de forma que podamos transformar los datos a nuestra conveniencia.

Para que haya una expresión necesitamos uno o varios valores y uno o varios operadores (dependiendo siempre del tipo de operador y los operandos que necesite); a veces se hace necesario el uso de paréntesis.

Puedes copiar este código y pegarlo en un archivo que se llame h1_ExpresionesBasicas.java dentro del paquete A_Inicio para comprobar su funcionamiento.

/* Aprendiendo a programar en DAM con elProfesorEmilio*/
package A_Inicio;

/**
 * @author Emilio
 * Vemos las expresiones básicas: aritméticas, relacionales y lógicas
 */
public class h1_ExpresionesBasicas {

    public static void main(String[] args) {
        // Declaración múltiple de variables, para declarar varias
        // variables del mismo tipo
        int manzanas, bolsas, manzanasPorBolsa;
        bolsas = 5;
        manzanasPorBolsa = 12;
        // asignación con expresión aritmética --> multiplicación
        manzanas = bolsas * manzanasPorBolsa;
        System.out.println(manzanas);
        // Operadores aritméticos
        // + * / - por orden sumar, multiplicar, dividir y restar
        // Importante --> prohibido dividir por 0
        
        // Asignación dentro de la declaración de varias variables
        float total, precioPorManzana=0.3f;
        total = manzanas * precioPorManzana;
        
        float aCuantoTocamos;
        int numeroAlumnos = 19+2-1-1;
        
        aCuantoTocamos = total/numeroAlumnos;
        System.out.println(aCuantoTocamos);
        
        // Si queréis saber qué pasa al dividir por 0
        // descomentad la línea siguiente y lo sabréis
        // System.out.println(15/0);
        
        // Operador unario --> - para cambiar de signo
        System.out.println(-manzanas);
        
        // Comprueba que las siguientes operaciones no dan el mismo valor
        System.out.println(manzanas * 5 - 10);
        System.out.println(manzanas * (5 - 10));
        // Desde mi punto de vista, no está mal escribir paréntesis redundantes
        // (siempre sin que se nos vaya la cabeza)
        // El problema es escribir paréntesis de menos...
        
        
        // ¿Es el número divisible por 3? Si da resto 0 si
        System.out.println(1423421%3);
        System.out.println(334212%3);
        System.out.println("El resto de dividir 123 entre 7 es: " + (123%7));
        
        // Es difícil tener que guardar operaciones booleanas o relacionales,
        // aunque puede darse el caso
        
        // Expresiones relacionales
        boolean sieteMayorOIgualQueCinco, tresMayorQueSiete;
        sieteMayorOIgualQueCinco = 7 >= 5;
        System.out.println(sieteMayorOIgualQueCinco);
        tresMayorQueSiete = 7<3;
        
        // Expresión booleana
        System.out.println(sieteMayorOIgualQueCinco && tresMayorQueSiete); 
        // && es la operación and, el 'y' lógico. 
        // Para usar or --> || y para el no !
        
        System.out.println(7>=5 && !(7<3));
        
        // Operadores simplificados
        // ++    --
        int i=0;
        i++; // i = i+1
        i--; // i = i-1
        
        // Si está delante primero incrementa y luego devuelve valor
        // Si está detrás primero devuelve valor y luego incrementa
        System.out.println(++i); // escribirá 1
        System.out.println(i++); // escribirá 1, pero i al final vale 2
        
        // Operadores de asignación simplificados
        // += -= *= /= %=
        
        int x = 5;
        // Las dos instrucciones siguientes son equivalentes
        x = x + 3;
        x += 3; // x = x+3
        x %= 2; // x = x%2
        System.out.println(x);
    }
}