8 – Resumen del primer bloque

1. Resolución del ejercicio del capítulo anterior Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5. Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, pero antes recordemos el enunciado: Te piden un formulario que recoja el nombre de una persona y permita escoger es estado civil de ésta persona de un listado predefinido. La lista de estados es la siguiente:

  • Soltero/a
  • Casado/a
  • Divorciado/a
  • Viudo/a

También te piden una opción que permita cambiar el color de:

  • Fondo del formulario
  • Fondo de los controles
  • Texto

Bien, la parte sencilla es la que ya hemos visto en el capítulo anterior y no es otra que usar un textbox para recoger el nombre, le pondremos también un label para que el usuario sepa que le estamos pidiendo: 8.resol.1 Hasta aquí ningún misterio, lo siguiente si es un poco más complicado básicamente porque no lo he explicado, pero seguro que has hecho caso de las pistas y has buscado por internet como se usa el control “ComboBox”. Vamos a empezar añadiendo uno en nuestro formulario: 8.resol.2 Si haces clic en el combo verás que aparece una flechita en su esquina superior derecha que te permite desplegar un menú, desde ahí puedes entrar en “Editar elementos” y añadir los que te pide el enunciado: 8.resol.3 Después de aceptar el mensaje vamos a darle al play y comprobar como se comporta nuestro nuevo y flamante combo: 8.resol.4 ¿Fácil verdad? Los combos están ahí para eso, para que un usuario escoja entre alguna de las opciones prefijadas que se le ofrecen. No tiene sentido preguntar el estado civil en un campo de texto libre como un “textbox” porque no nos interesa que se inventen un estado civil o que lo escriban mal, por ejemplo. Bien, vamos a la última parte del ejercicio: el cambio de color. Hasta ahora el enunciado no nos pedía programar nada de código, simplemente montar el formulario para recoger datos pero me temo que con lo de los colores nos vamos a tener que manchar las manos de barro. Empecemos añadiendo un control “ColorDialog” tal y como nos dicen las pistas: 8.resol.5 Como ves se parece al “Timer” ya que no tiene una representación gráfica en nuestro formulario, pero nos aparece bajo éste para que sepamos que lo tenemos creado y podamos tocar sus propiedades. Bien, si has buscado por Internet verás que para usar éste control necesitamos pedirle que nos muestre su cuadro de colores y esto lo tenemos que hacer por código. Una buena práctica es estudiarse el listado de propiedades, eventos y métodos de un objeto, lo cual ya hemos visto en capítulos anteriores cuando, desde código, escribíamos el nombre de un control y le dábamos al punto, desplegando el listado de opciones. Para no complicarlo vamos a añadir un menú en el formulario y vamos a programar el evento click de sus opciones para que nos muestre el cuadro de diálogo: 8.resol.6 Recuerda que haciendo doble click podemos programar directamente el evento click de la opción: 8.resol.7 A éste cuadro que nos muestra lo que podemos hacer con un objeto se le conoce como “IntelliSense” y hasta nos explica para que sirven los métodos si sus nombres no están del todo claros. Piensa que seguramente seas capaz de aprenderte los métodos y propiedades más importantes de los controles que trae el .NET Framework pero también se pueden instalar componentes de terceros (que suelen ser muy potentes… y también de pago…) y la única forma de saber que coño hacen y como utilizarlos es mirar la documentación donde, precisamente, te explican que propiedades y métodos traen consigo. Como somos personas curiosas vamos a echar un vistazo y… ¡voila! Hay un método que se llama “ShowDialog” que nos viene de perlas: 8.resol.8 Vamos a ver como se comporta ahora nuestro form cuando usamos dicha opción: 8.resol.9 ¡Anda la hostia! Que opción más chula pero… ¿una vez se escoge un color como lo usamos? Pues volvamos a investigar la lista de opciones que tiene el objeto… vaya, tiene una propiedad llamada “Color” y además nos dice que es la que nos da el color seleccionado por el usuario… pues vamos a cogerlo y a ponerlo de color de fondo del formulario: 8.resol.10 Quizás la parte más complicada aquí sea ver como cambiar el color del formulario, pero no es para nada difícil una vez lo ves claro. Si te fijas bien estás programando el código el propio formulario que quieres modificar, lo puedes ver justo después de declarar el namespace, cuando se declara la clase actual (en mi caso línea 13), estamos dentro de la clase Form1 que es de tipo Form por lo que queremos modificar el objeto dentro del cual estamos programando, y la mejor forma de acceder a dicho objeto es mediante la palabra “this”. Una vez visto esto, modificando la propiedad “BackColor” de “this”, es decir, el objeto actual, es decir, el formulario que queremos cambiar, queda todo hecho. ¿Por que no le damos al play para probarlo? 8.resol.11 Si hasta aquí está todo claro solo nos queda repetir todo esto en la otra opción, pero en lugar de cambiar le color del formulario cambiaremos el de los controles: 8.resol.12 Y listos, con esto tenemos el ejercicio completado. Espero que te animes a probar los otros controles y a jugar con ellos, se pueden hacer cosas muy chulas 🙂

2. Contenido del capítulo

Le he estado dando algunas vueltas al tema y creo que antes de continuar explicando cosas nuevas sería conveniente hacer un repaso de todo lo que llevamos visto hasta ahora, aunque he intentado que todos los ejemplos que he ido poniendo sean acumulativos, incluyendo así elementos ya vistos antes, nunca está de mas echar la vista atrás para refrescar conceptos sin detenernos en los detalles.

Éste es el listado de lo que hemos aprendido hasta ahora y, por tanto, vamos a repasar:

  • Tipos de datos básicos
  • Arrays
  • Variables y constantes
  • Operadores lógicos
  • Operadores booleanos
  • Condicionales
  • Programación orientada a objetos
  • Windows Forms

¡Pues no perdamos más tiempo y vamos a repasar un poco!

3. Tipos de datos básicos

Dado que programamos con C# sobre .NET Framework disponemos de un conjunto de tipos de datos que vienen incluidos en el sistema con los que podemos trabajar.

Los tipos que hemos visto hasta ahora son:

  • int: para números enteros
  • float: para números reales
  • bool: almacena el valor de cierto o falso.
  • string: contiene una cadena de texto.
  • object: es el tipo básico, como si fuera un comodín podríamos tratar todos los tipos que hemos visto como si fueran object (cuando hablemos de herencia quedará más claro).

Existen otros tipos de datos pero para lo que vamos a hacer nos podemos bastar de sobras con estos, si tienes curiosidad sobre otros tipos puedes consultar la documentación de Microsoft al respecto.

4. Arrays

Es posible crear colecciones de elementos, por ejemplo, un conjunto de enteros o un conjunto de floats. Los arrays son de tamaño fijo y es necesario indicar que tamaño queremos reservar, por ejemplo:

int[] my_array = new int[10];

De ésta forma estamos declarando un array de de enteros de 10 posiciones, después podemos acceder a dichas posiciones mediante los corchetes y tomar o asignar valores, asi:

my_array[3] = 25;

Esiten otras formas de inicializar arrays, como por ejemplo la siguiente que nos permite establecer sus valores de forma inlne:

object[] my_array = new object[]{1, “hola”, 4.5f, false};

Como puedes ver, todo cabe en un array de objects 😉

5. Variables y constantes

Como hemos visto en multitud de ocasiones, cuando necesitamos trabajar con datos es necesario que los guardemos en campos constantes o variables, dependiendo de si el valor es fijo es modificable respectivamente.

El valor de una constante se declara junto con la misma y no se puede modificar durante la ejecución del programa, es importante identificar las constantes y hacer buen uso de ellas ya que no solo mejora el rendimiento del programa sino que nos indica que estamos entendiendo lo que hacemos.

Las constantes se declaran así:

const int my_const = 25;

En el otro lado tenemos las variables, que son valores que se pueden modificar durante la ejecución de un programa y se declaran asi:

int my_var = 35;

6. Operadores lógicos

Hemos visto distintos tipos de operadores lógicos y seguro que te son muy familiares ya que hablamos de cosas tan típicas como sumar, restar, multiplicar o dividir. Es importante remarcar que los operadores lógicos solamente se pueden utilizar con datos del mismo tipo, es decir, no se puede sumar un entero con un string si antes no se ha hecho algún tipo de conversión.

Suma:
int a = 1;
int b = 2;
int c = a + b;

Resta:
float a = 2.2f;
float b = 1.2f;
float c = a – b;

Multiplicación:
int a = 33;
int b = 4532;
int c = a * b;

División:
float a = 0;
float b = 1.0000012f;
float c = a / b;

Recuerda también que los strings se pueden concatenar sumándolos.

7. Operadores booleanos

Se trata de lógica básica, los operadores booleanos se suelen aplicar a condicionales y consisten en evaluar ciertas propiedades para determinar si son ciertas o falsas.Por tanto el tipo de dato que retorna un operador de éste tipo siempre es booleano.

Mayor que:
int a = 33;
int b = 4532;
bool c = a > b; (falso)

Mayor que:
int a = 33;
int b = 4532;
bool c = a < b; (cierto)

Igual que:
int a = 33;
int b = 4532;
bool c = a == b; (falso)

Distinto que:
int a = 33;
int b = 4532;
bool c = a != b; (cierto)

A estos operadores de comparación se le unen otros de unión o conjunción:

Y:
int a = 33;
int b = 4532;
int c = 2;
bool c = a > b && c == 2; (falso)

O:
int a = 33;
int b = 4532;
int c = 2;
bool c = a > b || c == 2; (cierto)

8. Condicionales

Los condicionales son una herramienta básica en la programación secuencial (como la nuestra) ya que nos permiten ejecutar piezas de código únicamente si se cumplen ciertas condiciones:

if(low_battery){
ModoReposo();
}
else{
ModoNormal();
}

9. Programación orientada a objetos

Esta es, en mi humilde opinión, la parte más divertida y quizás la más compleja.

Como hemos visto los tipos de datos se representan con objetos, donde un objeto es una entidad que contiene uno o varios valores y un conjunto de métodos. Los integers, booleans, strings y floats que hemos visto tienen un conjunto de métodos predefinidos pero solamente toman un valor dependiendo del tipo que hayamos declarado. Lo divertido del asunto es que nosotros somos capaces de crear nuestros propios objetos mediante clases, donde podemos meter lo que nos dé la gana.

Por ejemplo:

8.clases.1

Lo que tenemos aquí es una clase que se llama Persona u que describe, de una forma muy resumida, los datos de una persona. Tiene 3 atributos privados, un método constructor, 3 propiedades y un método.

El constructor toma como datos de entrada el nombre de la persona y su edad y los almacena en los atributos privados. Si te fijas aparece la palabra reservada “this”, en éste punto es necesaria porque si te fijas los atributos de la clase se llaman igual que los parámetros de entrada del constructos, usando “this” le estamos diciendo al programa a cual de los dos nos referimos. Además como se trata de atributos privados no se pueden acceder desde fuera de la clase, es decir, quien use Persona no podrá ver estos atributos ni modificarlos por lo que los tenemos bien protegidos.

Lo sieguiente son las propiedades, una propiedad es un método especial que solo se encarga de entregar un valor o modificarlo. En nuestro caso, como los atributos son privadas necesitamos propiedades que permitan acceder a los valores pero si te fijas, las dos primeras solo permiten consultarlo por lo que una persona siempre tendrá el mismo nombre de creación (algo similar a la vida real suponiendo que nadie se cambiara el nombre) y tampoco se nos permite modificar libremente la edad.

La última propiedad si que permite modificar los datos a parte de consultarlos, lo hemos permitido porque es normal que una persona cambie de domicilio.

Lo último es un método que representa el día del cumpleaños, incrementando en uno la edad de esa persona.

Es importante que se entienda que tenemos el control absoluto de nuestra clase y, lo que es más importante, somos libres de dejar nuestra clase más abierta o más cerrada a cambios desde el exterior, en mi caso no he dejado que un programador le pueda quitar años a una persona ni le pueda cambiar el nombre una vez creada, pero si que le dejo consultar esos datos o hacerle cumplir años.

10. Windows Forms

Es la parte más gráfica ya que nos permite montar una interfaz para que el usuario interactue con nuestra aplicación de forma más amigable, los formularios se componen de controles que. a su vez, tienen atributos, métodos y eventos. Recuerda que los eventos son métodos programables que se disparan en una situación concreta como, por ejemplo, un clic.

Los controles más comunes son:

  • TextBox: permite recoger texto libre.
  • ComboBox: permite escoger una opción de una lista predefinida.
  • CheckBox: permite marcar una o varias opciones.
  • RadioButton: permite seleccionar una única opción.
  • Button: permite insertar un botón y programar su comportamiento.
  • MenuStrip: permite construir un menú.

Existen multitud de controles nativos y de terceros, todos hacen cosas distintas pero todos tienen cosas en común. Que no te de miedo jugar con ellos, investigar sus métodos, propiedades y eventos, muchas veces descubres una mejor forma de resolver un problema cuando estás haciendo experimentos.

11. Resumen

Y hasta aquí el resumen, porque no pienso hacer un resumen de un capítulo que ya es un resumen. Tampoco se me ocurre un ejercicio que aporte nada porque siempre hemos hecho ejercicios acumulativos, es decir, hemos aprovechado lo aprendido en capítulos anteriores y lo hemos ampliado con lo aprendido en el actual… así que prefiero no ser redundante y dejarte descansar y coger fuerzas.

En el próximo capítulo nos meteremos de lleno en el camino de la iteración (o bucles) y más adelante hablaremos de recursividad, si entretanto te aburres te invito a que crees una clase basándote en algo de la vida real (una persona, una nevera, un armario…), programes sus métodos y atributos y busques la manera de representarlo con WinForms, a tu rollo, sin prisas ni reglas, esa es la mejor forma de aprender.

Mucha suerte y nos vemos en la próxima entrada.
¡Gracias por seguir mi blog!

4 – Booleanos y condicionales

1. Resolución del ejercicio del capítulo anterior

Hola, bienvenido de nuevo a Programar mola con Visual Studio donde puedes seguir éste curso de programación en C# con Visual Studio y .NET Framework 4.5.

Antes de empezar con nuevo temario vamos a resolver el ejercicio que planteamos en el capítulo anterior, recordemos el enunciado:

Una persona te dice que tiene un huerto con cinco parcelas, en la primera cultiva lechugas, en la segunda cultiva zanahorias, en la tercera planta cebollas, la cuarta la tiene vacía y en la quinta tiene puerros.

Un día viene una chica a comprarle unas hortalizas, y en la lista de la compra tiene apuntado comprar 3 zanahorias, 1 cebolla y 2 lechugas.

Escribe el código necesario para calcular el número de hortalizas totales (un número entero) que le quedarán al payés una vez haya realizado la venta. Utiliza como mínimo un array.

Solución:

Bueno, si has seguido el último capítulo habrás visto que es prácticamente una copia del ejemplo de las monedas pero con hortalizas y lo habrás resulto con relativa facilidad. Si no es así no seas tímido y déjame en los comentarios todas tus dudas y preguntas que estaré encantado de contestar 🙂

El enunciado nos habla de 5 parcelas, lo cual ya es una pista de que necesitaremos un array de 5 elementos. La primera posición (la cero) la usaremos para las lechugas, en la segunda zanahorias, después cebollas, en la cuarta no pondremos nada y en la quinta los puerros.

Aquí he sido un poco cabrón y he hecho una pequeña trampa, no te he dicho cuantas hortalizas tiene el payés. Si te fijas bien el enunciado te pide el código para calcular el número final de hortalizas por lo que cuantas tenemos al principio es un dato que no nos hace falta y lo podemos obviar, por tanto la declaración de nuestro array quedaría así:

1.resol.array

Lo que sí que nos dice el enunciado es el número de hortalizas que compra una chica, por lo que podemos realizas las restas en las casillas correspondientes.

2.resol.array

Y éste es el código completo que, dado un array de 5 elementos (que representa al huerto) calcula el número final de hortalizas que quedarán. Ahora te puede parecer raro, pero ya verás que eso de trabajar con cosas que no sabes que valor tienen va a ser nuestro pan de cada día, de hecho si has estudiado algo de matemáticas te sonará de algo… lo llaman incógnitas y suele representarse con una letra X.

2. Contenido del capítulo

Llevamos solo 3 cápitulos (4 con éste) y ya hemos aprendido un montón de cosas, en ésta sesión vamos a ver lo siguiente:

  • Booleanos
    • Números booleanos
    • Operadores lógicos
    • Condicionales
  • Resolución de un ejercicio de ejemplo
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

Como siempre, voy a dar por sentado que los conceptos del capítulo anterior están claros. Si no es así te animo a pegarle un repaso o a dejarme tus consultas en los comentarios.

De hecho me está dando miedo ir demasiado rápido o dar cosas de más por supuestas. Si te cuesta seguirme el ritmo, si crees que me dejo cosas o que necesitas más detalles no seas tímido y déjame tus sugerencias en los comentarios, te prometo que no muerdo. Prefiero que me digas “Eh tio, no me entero de una mierda” a que dejes el curso, dame un toque y te explico lo que necesites saber.

3. Booleanos

Si recuerdas bien hemos visto tres tipos básicos de datos: enteros o int (1, 2, -35, 20190320101, …), decimales o float (1.3, 34.231234, -0.33329099999, …) y texto o string (“hola”, “adios”). Pues bien, ahora vamos a hacer un nuevo amigo, quizás el amigo más importante de todos: el booleano.

¡¡¡ALERTA CULTURAL!!!

Por si no te acuerdas, lo bloques de alerta cultural te los puedes saltar si te aburren o simplemente te da palo leerlo. Creo que son interesantes y que te pueden ser de utilidad pero en serio, si estas cosas te aburren busca el final y sigue con el capítulo desde ahí que no pasa absolutamente nada.

El álgebra de Boole es un campo de las mátemáticas que define un conjunto de estructuras y operaciones básicas. Toda la computación que tenemos hoy en día se basa en eso… casi nada ¿eh?

Los ordenadores, por dentro, si pillas in microscopio y lo incrustas en el microprocesador, a nivel físico hacen esto, álgebra de Boole. Es como decir que tu pisas el acelerador y el coche se mueve y el paisaje avanza, eso es gracias a un motor que hace su magia por dentro… pues aquí algo parecido. Tu mueves el ratón y el cursor responde gracias al álgebra de Boole (entre otras cosas).

Por hacer un resumen y ponerlo fácil el álgebra de Boole se compone (entre otros) de los siguientes operadores: AND, OR, NOT e IF. Eso son los operadores, y los operandos son lo que conocemos como números booleanos.

El número booleano es la estructura más simple de todas, el bit. El bit es la base de todo el sistema binario con el que trabajan los ordenadores y su valor puede ser 1 o 0… sí sí, en serio, un “uno” o un “cero”.

¡¡¡FIN DE LA ALERTA CULTURAL!!!

3.1. Declaración

Para simplificar y no aburriros diremos que un booleano solo puede valer “cierto” o “falso” y en C# se declara así:

3.bools

Hemos instanciado dos booleanos llamados “b_si” y “b_no” donde el primero es cierto y el segundo es falso.

Ahora toca operar con ellos, con los enteros y los floats operábamos matemáticamente con sumas, restas, etc… Con los floats se opera lógicamente. No te me asustes que es muy fácil.

3.2. Operaciónes lógicas

Vamos a ver 4 tipos de operaciones lógicas: AND, OR, NOT e IF.

3.2.1. AND

El AND es un operador de conjunción y en castellano lo podríamos leer como Y, como por ejemplo “x Y z”. Con los operadores lógicos se trabaja a nivel de cierto o falso y el resultado de una operación con AND requiere que todos sus operandos sean cierto para que el resultado sea cierto. Como esto que acabo de decir apenas se entiende veamos el siguiente ejemplo:

4.and

 ¿Lo ves? La única manera de que el resultado de x Y z sea cierto es que tanto x como z sean ciertos. Esto en C# lo escribiríamos así:

5.and_csharp

¿Que resultado tendrá un AND? Solo con que un elemento sea falso ya sabremos que es falso.

3.2.2. OR

Tenemos por otro lado el OR, la disjunción, que se puede leer como “Ó” y que hace justo lo contrario, solo conque uno de los operandos sea cierto el resultado es cierto:

6.or

Que en C# sería así:

7.or_csharp

¿Que resultado tendrá el OR? Solo conque uno de sus elementos sea cierto ya sabremos que será cierto.

3.2.3. NOT

El NOT es la negación, es tan tonto como invertir el resultado. NOT Cierto es Falso y NOT Falso es cierto. En C# sería así:

8.not_csharp

Y si NOT Cierto = Falso y NOT Falso = Cierto… que es ¿NOT NOT Cierto? Pues si lo haces por partes te queda que NOT NOT Cierto = NOT Falso = Cierto… no te preocupes que no suele ser tan complicado… de hecho si te aparece alguna cosa así seguramente has metido la pata por alguna parte o simplemente se puede simplificar.

3.2.4. IF

El IF es la forma que tienen los operadores lógicos de manejar cláusulas condicionales y pueden leerse en castellano como un SI condicional, por ejemplo:
SI b es cierto ENTONCES haces esto, SINO haces lo otro.

Esto en C# sería de la siguiente forma:

9. if

Vamos a darle la vuelta, para que veas que esta cosa tan tonta se puede hacer “del revés”.

10.if2

¿Lo ves? Es fácil ver que es lo mismo pero dado la vuelta. En multitud de ocasiones te preguntarás si hacerlo de una forma o de otra y la verdad es que no existe respuesta, hazlo como te salga de los huevos / ovarios. Mientras lo veas claro y te sientas cómodo yo ya me doy por satisfecho, de hecho muchas veces te preguntarás cual es la forma correcta y, a no ser que el impacto en el rendimiento sea crítico, la respuesta suele ser siempre la misma: tu comodidad como programador manda, sobretodo si no tienes un jefe al que rendir cuentas de tus decisiones 😉

Ya que estamos, voy a enseñarte un pequeño truco:

11.if3

¡Hostias! Esto es la pereza absoluta hecha condicional. Preguntar a un condicional si una cosa “es cierta” es lo mismo que preguntarle simplemente si una cosa “es”, ya irás viendo que me gusta ir reduciendo las cosas a la mínima expresión, a menos líneas y menos letras más limpio y fácil de mantener. Recuerda siempre que el número de errores de un programa es directamente proporcional (yo diría que exponencialmente) a su número de líneas por lo que te recomiendo que abraces la pereza de escribir lo mínimo posible.

Y ya que estamos perezosos… ¿como se le da la vuelta a esto? Veamos:

12.if4

Ale, se le casca una exclamación delante y listos. Recuerda que la exclamación es la forma que tiene C# de hacer un NOT, así que lo que estamos preguntando es si una cosa “no es”, lo cual es lo mismo que preguntar si “es falsa” o si una cosa “no es cierta”.

5. Resolución de un ejercicio de ejemplo

Bueno, llegados a éste punto quiero poner en práctica lo que hemos aprendido, porque la teoría sin práctica no sirve de una puta mierda y, seamos sinceros, si es la primera vez que ves algo parecido a ésto te estarás haciendo un cacao mental de la hostia. Empecemos con un enunciado muy fácil.

Tienes el trabajo más aburrido del mundo pero eres muy feliz… aunque eso no quita que sea tremendamente, enromemente, insufriblemente aburrido.
Tu trabajo consiste en estirar de dos palancas, cuando estiras de la palanca de la derecha creas billetes de 500€, cuando estiras de la palanca de la izquierda conviertes el billete de 500€ en dos billetes de 200€, un billete de 50€ y los 50€ restantes se desvían a las tarjetas black de los hijos de puta de Caja Madrid y aquí no ha pasado nada.

Teniendo en cuenta que un array de enteros de 3 posiciones (donde cada posición es para un tipo de billete diferente), escribe el código que realiza las operaciones en función de la palanca que estiras.

Bueno, tranquilo que es más fácil de lo que parece. Vamos a empezar declarando ese array que sale por ahí.

13.ejemplo1

Vale, tenemos un array de 3 posiciones como nos sugiere el enunciado y vamos a usar la posición 0 para los billetes de 50, la 1 para los de 200 y la 3 para los de 500… en realidad lo puedes hacer en el orden que os de la gana pero ésta me ha parecido la más lógico.

Ahora toca definir las palancas, lo único que necesitamos saber es si es derecha o es izquierda. Vamos a usar un booleano, lo vamos a llamar palancaDerecha y… ¡exacto! si es cierto es la palanca derecha y si es falso será la izquierda porque es la única que queda.

14.ejemplo2

Ahora nos toca montar el condicional, lo voy a hacer como en los ejemplos anteriores:

15.ejemplo3

 

He puesto el booleano a cierto para que no se me queje el compilador, obviamente sabemos que parte del código se va a ejecutar pero ya veremos más adelante que no suele ser así.
Voy a llenar los huecos con lo que pide el enunciado.

16.ejemplo4

 

Ésta parte se parece mucho a los ejercicios de capítulos anteriores así que me ahorro el explicarla, si tienes dudas pégale un vistazo al capítulo anterior o déjame un comentario y te echo una mano.
Aunque no lo pide el enunciado voy a añadir una línea que calcule la pasta final y voy a mostrarte el código completo.

17.ejemplo5

Te acuerdas de como se debuga ¿verdad? Pues dale caña al mono, pon un breakpoint sobre la delcaración del array, pulsa el play verde y ves pulsando la tecla F10. Verás como la ejecución avanza punto por punto, como entra en el primer condicional y como el resultado de “total” es 500.

18.ejemplo6

6. Resmuen.

Llegados a éste punto y si la cabeza no te ha estallado debería quedarte claro lo que es un booleano y como se utiliza.

Hemos visto que existen 4 operadores: AND, OR, NOT y IF. El AND mira que todos sean ciertos, el OR que solo uno lo sea, el NOT le da la vuelta y el IF nos permite tomar decisiones.
Dicho de carrerilla parece rápido y fácil, si te lo ha parecido bien por ti, si no tranquilo, a mi me costó mucho tiempo pillarlo pero con práctica todo se consigue.

7. Ejercicio

Vale, antes de poner el enunciado te pido perdón porque voy a ser un poco cabroncete. Quiero que le des al coco y pienses por ti mismo una forma de solucionarlo, con lo que hemos visto hasta ahora deberías ser capaz de hacerlo mirando solamente éste blog, pero te recomiendo encarecidamente que tires de “San Google” si te quedas bloqueado, en mi trabajo de cada día me encuentro constantemente con cosas que no tengo claro como resolver y el Sr. Google es mi mejor aliado.

Bien, allá vamos:

Aunque eres muy feliz están harto de tu aburrido trabajo, necesitas mayores retos y por fin ha llegado tu oportunidad. Tus jefes te han dado el ascenso que tanto te merecías y ahora tienes tres magníficas palancas para ti mismo. ¡¡¡TRES!!! Oh Dios mío, es un sueño hecho realidad. Dos palancas era una mierda pero TRES lo cambia todo… que maravilla… en fin, que me voy por las ramas…. la palanca de la derecha crea un billete de 500, la de la izquierda (al igual que antes) convierte un billete de 500 en dos de 200 y uno de 50. La misteriosa palanca del centro convierte un billete de 200 en uno de 100, y uno de 50… ya sabemos a donde va la pasta que sobra ¿no?

Puedes usar el mismo array que en el ejercicio de ejemplo. De hecho has de hacer lo mismo, pero para 3 palancas.

Pista:
Puedes basarte en la solución del ejercicio de ejemplo.
Busca la manera de poder tomar 3 decisiones, puedes crear tantas variables como necesites.
Puedes usar tantos condicionales como necesites.

Como siempre la respuesta en el próximo post.
Saludos y gracias por llegar hasta aquí.

¡Hasta la próxima!