Curso Java desde 0. Leccion #3 Constantes, Operadores y tipos de errores

[OmarAM112]

• Curso Java desde 0. Leccion #1 Introduccion
• Curso Java desde 0. Leccion #2 Compilacion, variables y tipos de datos.

3. Constantes.

Una constante, al igual que una variable, es un espacio en la memoria del ordenador donde se almacenará un valor que NO podrá cambiar durante la ejecución del programa.

A la hora de programar, es frecuente que necesitemos almacenar datos que utilizaremos en el futuro en ese mismo programa, pero estos datos no deben ser modificados durante la ejecución del programa. Para facilitar la lectura del código y prevenir errores, declaramos estos datos como constantes.

Para declarar constantes la sintaxis es la siguiente:

final tipo nombre = valor;

Como vemos final es un modificador que sirve para crear constantes.

final double DOLAR_EURO = 1.28;

⚠️ Es obligatorio inicializar la constante en el momento de su declaración (también es el único lugar posible donde podemos hacer una asignación a la constante)

//Constante declarada e inicializada en la misma linea ✅
final double IVA = 1.21; ✅

//Constante mal declarada e inicializada en distintas lineas ❌
final double HABITANTES_ALBACETE;❌
HABITANTES_ALBACETE = 220000;❌

⚠️ Aunque no es obligatorio, por convención el nombre de las constantes debe ir en MAYÚSCULAS.

Las reglas relativas a la vida útil y el ámbito de las constantes son idénticas a las de las variables.

El valor de una constante también se puede calcular a partir de otra constante:

final int TOTAL = 100;
final int MEDIO = 100/2;

Muchas constantes ya están definidas a nivel del lenguaje Java. Se definen como miembros static de las muchas clases del lenguaje.

---

4. Operadores en Java.

Los operadores son palabras clave del lenguaje que permiten ejecutar operaciones en el contenido de ciertos elementos, generalmente en variables, constantes, valores literales o retornos de funciones.

La combinación de uno o varios operadores y elementos en los cuales los operadores van a apoyarse se llama expresión. Estas expresiones se evalúan en tiempo de ejecución en función de los operadores y de los valores asociados.

En Java disponemos de:

• Operadores aritméticos.
• Operadores lógicos, relacionales y booleanos, comparación.
• Operadores de incremento y decremento.
• Operadores de concatenación
• Operador de asignación

Operadores aritméticos:

+ Suma

- Resta

* Multiplicación

/ División

% Módulo

Operadores Lógicos, relacionales, booleanos, comparación:

> Mayor que

< Menor que

<> Mayor o menor que

!= Distinto que

== Igual que

&& y lógico (AND)

|| o lógico (OR)

! Negación lógica (NOT)

Operadores incremento y decremento:

++ Incremento

-- Decremento

+=nº Incremento nº veces

+=nº Decremento nº veces

Operadores de Concatenación:

+ Une o concatena.

Operador de asignación:

= Asigna un valor.

Los operadores habituales + – * / se utilizan en Java para denotar suma, resta, multiplicación y división.

El resto entero, llamado módulo, se denota mediante el signo %. Por ejemplo 15 % 2 = 1.

Existe una abreviatura para emplear operadores en la asignación. Por ejemplo, x+=4; que es equivalente a x = x + 4;

⚠️ La división por cero da lugar a una excepción (un error), mientras que la división de un coma flotante por cero produce un resultado infinito o NaN ( Not a Number ).

Vamos a explicar más detalladamente algunos de los operadores.

a. Operador incremento ++ y decremento - -.

En los operadores de incremento ++ y decremento -- la posición de los mismos determina cuando se aplica el operador a la variable. Si el operador se coloca como prefijo, se aplica el operador antes de que se use en la expresión, mientras que si el operador se aplica como sufijo el operador se aplica a la variable después de usarla en la expresión. Esta distinción puede influir en el resultado de una expresión.

int i;
i = 3;
System.out.println(i++);

En este caso, la ejecución del programa mostrará el valor 3 ya que el incremento se ejecuta después del uso de la variable por la instrucción println.

Pero si ponemos el incremento como prefijo de la variable:

int i = 3;
System.out.println(++i);

La ejecución del programa muestra 4 porque el incremento se ejecuta antes del uso de la variable por la instrucción println.

Si la variable no se usa en una expresión, ambas versiones dan el mismo resultado, ambas son equivalentes:

i++;
++i;

b. Operadores aritméticos.

Los operadores aritméticos permiten hacer cálculos en el contenido de las variables. El tipo del resultado de la operación se corresponde con el tipo más grande de los dos operandos.

Operador	Operación	Ejemplo	Resultado
+	Suma	5+9	14
-	Resta	12-6	6
*	Multiplicación	3*4	12
/	División	20/2	10
%	Módulo	25%3	1

En el caso de la división:

• Si los dos operandos son enteros, la división operada es entera. 25/3 = 8.
• Si al menos uno de los dos operandos es un número decimal, el resultado sera un decimal. 25/3 = 8.333

La precisión del resultado depende del tipo más grande en la operación.

c. Operador de asignación.

El único operador disponible en esta categoría es =. Permite asignar un valor a una variable. Se utiliza el mismo operador sea cual sea el tipo de la variable (numérico, cadena de caracteres…).

int x; // Declaración de la variable x de tipo entero
x = 5; // Asignación del valor 5 a la variable x

Se puede combinar este operador con otros operadores.

La sintaxis siguiente:

x = x+2;

Equivale a:

x += 2;

d. Operadores lógicos.

En Java, al igual que en otros lenguajes de programación, las operaciones lógicas son aquellas que se realizan con valores booleanos (true o false). Estas operaciones se utilizan para tomar decisiones en el código, controlar el flujo de ejecución y evaluar condiciones.

Las operaciones lógicas más comunes en Java son:

• AND (&&): Esta operación devuelve true si ambas condiciones son verdaderas, de lo contrario, devuelve false.

boolean condicion1 = true;
boolean condicion2 = false;

boolean resultado = condicion1 && condicion2; // resultado será false

• OR (||): Esta operación devuelve true si al menos una de las condiciones es verdadera, de lo contrario, devuelve false.

boolean condicion1 = true;
boolean condicion2 = false;

boolean resultado = condicion1 || condicion2; // resultado será true

• NOT (!): Esta operación invierte el valor booleano de una expresión. Si la expresión es true, devuelve false; si la expresión es false, devuelve true.

boolean condicion = true;

boolean resultado = !condicion; // resultado será false

Estas operaciones se utilizan para construir expresiones lógicas más complejas y para controlar el flujo del programa mediante estructuras condicionales como if, else, else if, y en bucles como while y for.

Operador	Descripción	Ejemplo	Resultado
&&	AND (y)	true && false	false
`		`	OR (o)
!	NOT (no)	!true	false

e. Operadores de comparación.

Se utilizan operadores de comparación en las estructuras de control de una aplicación. Devuelven un valor de tipo boolean en función del resultado de la comparación efectuada.

Operador	Prueba efectuada	Ejemplo	Resultado
==	Igualdad	2 == 5	false
!=	Desigualdad	2 != 5	true
<	Inferior a	2 < 5	true
>	Superior a	2 > 5	false
<=	Inferior o igual a	2 <= 5	true
>=	Superior o igual a	2 >= 5	false

f. El operador concatenación.

El operador + ya utilizado en la suma, se usa también para la concatenación de cadenas de caracteres. El funcionamiento del operador viene determinado por el tipo de los operandos. Si uno de los operandos es de tipo String, el operador + efectúa una concatenación con una conversión implícita del otro operando a cadena de caracteres.

String nombre = "Pepito";
String saludo = "Hola, " + nombre; // El operador + concatena las cadenas "Hola, " y el valor de la variable nombre
System.out.println(saludo); // Imprime: Hola, Pepito

Debemos tener en cuenta que el operador + en el contexto de la concatenación de cadenas realiza una operación diferente a la suma aritmética cuando se utiliza con operandos de tipo String.

1. Orden de evaluación de los operadores.

Cuando se combinan varios operadores en una expresión, se evalúan en un orden muy preciso. Los incrementos y decrementos se ejecutan en primer lugar, a continuación, las operaciones aritméticas, las operaciones de comparación, los operadores lógicos y por último las asignaciones.

Precedencia	Operadores
1º	()
2º	! (NOT)
3º	*, /, %
º4	+, -
5º	<, <=, >, >=
6º	==, !=
7º	&&
8º
9º	=

Como vemos en la tabla, lo primero son los paréntesis (), si necesitamos establecer un orden de evaluación diferente, tenemos que ubicar las expresiones con prioridad entre paréntesis, por ejemplo:

x = (z * 4) + (y * (a + 2))

En una expresión podremos utilizar tantos paréntesis como necesitemos, pero es importante asegurarnos que la expresión contiene tanto el paréntesis de apertura ( como el paréntesis de cierre ), pues si falta alguno el compilador nos mostrara un error.

2. Ejemplos sobre operadores.

public class UsoOperadores {

	public static void main(String[] args) {

		int num1 = 7; // Operador de asignación
		int num2 = 5;

		int resultado = num1 + num2; // Operadores de asignación y operador suma

		System.out.println("La suma de: " + num1 + " + " + num2 + " es = " + resultado);
		/* Aqui estamos utilizando el operador de concatenacion*/
		
		//Operador de incremento:
		System.out.println("El valor de num1 ANTES del incremento es: " + num1);
		
		num1++; //Operador incremento 7+1=8
		
		System.out.println("El valor de num1 DESPUES del incremento es: " + num1);
		
	}

}

La suma de: 7 + 5 es = 12
El valor de num1 ANTES del incremento es: 7
El valor de num1 DESPUES del incremento es: 8

1. Declaración de Variables:

   int num1 = 7; // Operador de asignación
   int num2 = 5;
   

   • Se declaran dos variables enteras (num1 y num2) y se les asignan los valores 7 y 5, respectivamente. El operador de asignación (=) se utiliza para asignar un valor a una variable.

2. Operación de Suma:

   int resultado = num1 + num2; // Operadores de asignación y operador suma
   

   • Se realiza una operación de suma entre num1 y num2, y el resultado se almacena en la variable resultado. Aquí, el operador de suma (+) realiza la operación aritmética.

3. Mostramos el resultado por pantalla:

   System.out.println("La suma de: " + num1 + " + " + num2 + " es = " + resultado);
   /* Aquí estamos utilizando el operador de concatenación */
   

   • Se imprime en la consola el mensaje "La suma de: " seguido de los valores de num1 y num2 y, finalmente, el resultado de la suma. Aquí, el operador de concatenación (+) se utiliza para unir cadenas y valores numéricos en una cadena de texto.

4. Operación de Incremento:

   System.out.println("El valor de num1 ANTES del incremento es: " + num1);
   
   num1++; // Operador incremento: 7 + 1 = 8
   
   System.out.println("El valor de num1 DESPUÉS del incremento es: " + num1);
   
   

   • Se imprime el valor actual de num1 antes de la operación de incremento y luego se incrementa su valor en 1 utilizando el operador de incremento (++). Después, se imprime el nuevo valor de num1.

Otro ejemplo en el uso del operador de concatenación es:

public class ConcatenacionStrings {

	public static void main(String[] args) {

		double salario = 1850.55;

		System.out.println("El salario es: " + salario + " Euros");
		System.out.println("El salario es: " + salario * 1.20 + " Dolares");
		System.out.println("El salario con complemento es: " + (salario+300) + " Euros");

	}

}

El salario es: 1850.55 Euros
El salario es: 2220.66 Dolares
El salario con complemento es: 2150.55 Euros

1. Declaración de la Variable:
   Se declara una variable llamada salario de tipo double con un valor inicial de 1850.55.
2. Concatenación con Texto Fijo:
   La primera línea dentro del método main utiliza el operador de concatenación (+) para unir el texto fijo “El salario es: " con el valor de la variable salario y la cadena " Euros”. Esto crea un mensaje completo que se imprime en la consola.
3. Concatenación con Expresión Matemática:
   En la segunda línea, se muestra cómo la concatenación puede incluir una expresión matemática. Aquí, se multiplica el salario por 1.20 para convertirlo a dólares, y el resultado se concatena con el texto correspondiente.
4. Concatenación con Expresión Compleja:
   En la tercera línea, se demuestra cómo manejar expresiones más complejas al utilizar paréntesis. Se añade un complemento de 300 al salario antes de concatenarlo con el texto restante.

3. Ejercicios operadores.

Multiplica 8 por 6, y pinta el resultado en pantalla

System.out.println(8 * 6);

Divide 8 entre 6, y pinta el resultado en pantalla

System.out.println(8 / 6);

Usa el operador correcto para incrementar el valor de la variable x en una unidad.

int x = 10;
++x;

Usa el operador que incrementa una variable x número de veces.

int x = 10;
x += 5;

---

5. Tipos de errores en Java.

En java tenemos principalmente dos tipos de errores:

• Errores en tiempo de compilación
• Errores en tiempo de ejecución

a. Errores en tiempo de compilación:

Se tratan de errores de sintaxis, es decir alguna instrucción esta mal escrita y no permite que el programa compile.

system.out.println("MAL"); // La sintaxis del System esta mal escrita
System.out.println("BIEN");
System.out.println("MAL") // Falta el ;

b. Errores en tiempo de ejecución:

Estos errores surgen durante la ejecución de programa.

Por ejemplo (El código expuesto no se va a comprender de momento, en las siguientes lecciones se comprenderá):

import java.util.Scanner;

public class ConcatenacionStrings {

	public static void main(String[] args) {

		int edad;

		Scanner entrada = new Scanner(System.in);

		System.out.println("Introduce tu edad: ");

		edad = entrada.nextInt();

		System.out.println("La edad introducida es: " + edad);

	}

}

El programa nos pedirá que pongamos un valor entero para la edad:

Introduce tu edad: 
18
La edad introducida es: 18

Como vemos hemos introducido el valor 18 y el programa ha funcionado correctamente.

Pero por ejemplo si intentamos introducir un valor en coma flotante como 18.5:

Introduce tu edad: 
18.5
Exception in thread "main" java.util.InputMismatchException
	at java.base/java.util.Scanner.throwFor(Scanner.java:939)
	at java.base/java.util.Scanner.next(Scanner.java:1594)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
	at ConcatenacionStrings.main(ConcatenacionStrings.java:21)

Vemos como nos ha saltado una Exception, lo que es lo mismo a un error en tiempo de ejecución.

Mas adelante se trabajara con las excepciones para poder controlarlas en nuestros programas.