Hola
En este módulo no centraremos sobre los arreglos en una y dos dimensiones,
para eso seguiremos el siguiente plan de temas:
revisaremos las expresiones booleanas, las instrucciones condicionales,
los arreglos en una dimensión de tamaño fijo, las instrucciones repetitivas,
los patrones de recorrido, los arreglos en una dimensión de tamaño variable,
las búsquedas sobre esos arreglos, y revisaremos un primer caso estudio.
Posteriormente revisaremos los arreglos en dos dimensiones,
y revisaremos un segundo caso estudio relacionado con ese tipo de arreglos.
Para iniciar revisemos el tema de expresiones booleanas.
Una expresión booleana es una expresión que solo puede tomar el valor verdadero
o el valor de falso, es decir, que nos permite responder a preguntas de sí o no.
Pensemos en nuestro ejemplo de las pizzas,
digamos algunas preguntas de este tipo, por ejemplo,
quisiéramos saber si el nombre de la pizza es hawaiana o no,
quisiéramos saber si el costo de la pizza mayor a $20.000,
y quisiéramos saber si se ha producido a menos 10 unidades de la pizza.
Veamos cómo construir en Java las expresiones que evalúan estas preguntas.
Iniciemos con la pregunta de saber si el costo de producción es mayor a $20.000
para esto creamos una variable booleana;
boolean es el tipo de dato que nos permite guardar
las expresiones booleanas, es decir, que pueden tomar valores de true,
o verdadero, y de false, o falso.
Para poder responder a esta pregunta lo que hacemos es comparar
el atributo costoDeProducción
con el valor 20.000, usando el operador mayor que.
Ahora veamos la pregunta de si se han producido al menos
10 unidades de la pizza.
Para esta pregunta compararemos el atributo, cantidadProducida con el valor 10,
usando el operador mayor o igual que.
Y finalmente,
la pregunta de si el nombre de la pizza es hawaiana,
para este caso compararemos el atributo nombre
con la cadena hawaiana, utilizando el método equals de la clase string.
Esto se debe a que no estamos comparando tipos básicos de datos,
sino que estamos comparando objetos,
y por lo tanto debemos usar métodos que sepan comparar estos objetos.
Veamos qué operadores podemos usar para comparar tipos numéricos.
Podemos usar el operador mayor que, el operador mayor o igual que,
es importante notar que los dos elementos se escriben separado,
si por una parte es mayor y por otra parte el igual
el operador menor que, el operador menor o igual que,
el operador igual, que se marca escribiendo dos "=",
y de operador diferente, que se indica escribiendo un signo de admiración y un "=".
Todos estos operadores los podemos utilizar como tipo char,
y los operadores igual y diferente los podemos usar con los elementos de tipo boolean.
Ahora veamos qué métodos podemos usar con la clase string para realizar comparaciones
conocemos el método equals,
el cual nos indica siempre que dos cadenas de caracteres,
o dos textos son exactamente iguales.
Por ejemplo, si tenemos la variable casa y la comparamos con la cadena hola,
tendremos el resultado falso,
pero también podemos usar el método.equalsIgnoreCase,
el cual ignora la diferencia entre mayúsculas y minúsculas al momento de realizar la comparación.
Por ejemplo, si tenemos en la variable var
el valor de casa, todo en minúsculas, y lo comparamos
con el texto CaSa, el cual tiene la C y la S en mayúsculas,
el método.equalsIgnoreCase nos devolverá true,
ya que no tiene en cuenta la diferencia entre mayúsculas y minúsculas.
Veamos ahora algunas preguntas más complejas
Por ejemplo, si quisiéramos si el nombre de la pizza no es carnes,
o si se han producido menos de 20 pizzas, y su precio es mayor a $15.000,
o, por ejemplo, para el caso de nuestro cocinero que sabe preparar dos pizzas,
quisiéramos saber si ya se han inicializado los atributos que
definen a la pizza uno y a la pizza dos.
Para poder responder estas preguntas notemos que existen
conjunciones, disyunciones y negaciones, es decir,
existen "nos", existen "ys", y existen "os".
Veamos los operadores booleanos que nos permiten escribir esto en Java.
Para la "y" usaremos dos ampersand seguidos, "&&",
para la "o" usaremos dos barras verticales seguidas, "||",
y para la negación, usaremos el signo de admiración "!".
Teniendo estos operadores ya podemos responder las preguntas que nos habíamos planteado.
Tratemos de responder las preguntas de la clase pizza
queríamos saber si el nombre de la pizza no era carnes
Iniciemos haciendo la pregunta inversa,
saber si el nombre de la pizza es carnes, es decir, si nombre.equals("carnes");
y neguemos su resultado, usando el signo de admiración, "!".
Ahora, queríamos saber
si se han producido menos de 20 pizzas, y si su precio es mayor a $15.000,
para esto veamos que son dos preguntas,
iniciemos responder a la primera pregunta,
es decir, se han producido menos de 20 pizzas
entonces escribimos, cantidadProducida menor que 20.
Y la segunda pregunta es saber si el precio de venta supera los $15.000,
entonces escribimos precioVenta mayor que 15.000.
Para unir las dos preguntas usaremos el operador "&&".
Finalmente
respondamos las preguntas que nos habíamos planteado sobre el cocinero
queríamos saber si ya se han creado
los objetos pizza uno y el objeto pizza dos.
Entonces, veamos nuevamente que son dos preguntas separadas
queremos saber si la pizza uno ya existe, es decir,
si no es nula, como habíamos visto previamente,
por lo tanto, diremos que,
pizza_1 es diferente de null "!=",
y la misma pregunta la haremos para la pizza dos
Como el operador que está uniendo las dos preguntas uno
usaremos dos para verticales.
Con esto hemos terminado la revisión de las expresiones booleanas.
En la próxima sesión trataremos el tema de instrucciones condicionales.