9 – Introducción a los bucles iterativos

1. Bienvenidos de nuevo

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.

Soy consciente que me lo he tomado con calma desde mi última entrada, lo cierto es que necesitaba unas vacaciones para coger el blog con ganas una vez más ya que con las últimas entradas tuve la sensación que escribía más por obligación hacia los, como tu, siguen el blog que no por placer. Mi objetivo cuando hice éste blog era compartir todo aquello que he ido aprendiendo con los años pero me temo que lo cogí con tantas ganas al principio que he ido perdiendo fuelle muy rápido… eso sumado a que la parte de Windows Forms es para mí la más aburrida y una vez explicada me había quedado exhausto. Os pido disculpas por ello.

Pero no todo son malas noticias pues aquí estoy de nuevo para continuar donde lo dejamos, espero que te hayas animado a practicar todo lo que hemos aprendido hasta el momento (tiempo has tenido 😉 ) ya que voy a dar por sentado que lo tienes cogido por la mano. Si no es el caso ya sabes que tienes los comentarios y que me encanta contestarlos todos 😀

Si has sido un niño/a bueno/a y has practicado, te habrás dado cuenta que te falta algo, que con las herramientas que hemos visto juntos aún hay cosas, conceptos, ideas, algo… un clic en el engranaje que falta, y tienes razón, nos falta una cosa muy importante: los bucles.

2. Contenido del capítulo

Como siempre, antes de empezar a soltarte el rollo, echemos un vistazo al contenido del capítulo de hoy

  • Introducción a los bucles iterativos
  • Condición de salida
  • Cuerpo del bucle
  • Invariante
  • Ejemplos
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

Antes de seguir déjame advertirte que si no estás familiarizado con los conceptos de “iteratividad” y “recursividad”, uno: estás en el sitio correcto; y dos: son conceptos raros de la hostia. Por ese motivo voy a bajar el ritmo habitual del curso y nos lo vamos a tomar con más calma, dando vueltas al mismo asunto y dando más ejemplos de lo normal.

Recuerdo que cuando yo estudié ésto por primera vez no entendía absolutamente nada y necesité de mucha ayuda y muchos más ejemplos para cogerle el tranquillo, así que tómatelo con calma y pregúntame todo aquello que se te escape.

Como he comentado, existen dos conceptos clave en ésto de los bucles, la “iteratividad” y la “recursividad”, como creo que la primera es más sencilla vamos a centrarnos en ella y una vez seamos unos cracks en esto de los bucles iterativos saltaremos a la siguiente.

3. Introducción a los bucles iterativos

Pues bien, empecemos por el principio, ¿que coño es un bucle?

En los ejemplos que hemos ido haciendo a lo largo del blog, cuando debugábamos nuestros códigos que siempre íbamos línea a línea de arriba a abajo de forma secuencial? Pues un bucle rompe ésta secuencialidad, pues se produce un “salto hacia atrás” para repetir un trozo de código previamente ejecutado.

¿Te acuerdas de cuando aprendías las tablas de multiplicar? Al menos en mis tiempos nos las aprendíamos… pues resulta que yo tenía un método infalible para aprenderme la tabla del 5, que era empezar por cero y, de cinco en cinco, llegar a 50. Obviamente, cuando la profesora preguntaba “4×5” se notaba a la legua si te la sabías o estabas contando pero ese detalle no nos interesa ahora mismo, nos interesa el concepto de contar.

Podríamos definir un bucle como un proceso repetitivo que empieza en un punto y termina en otro distinto, es decir, desde A hasta B hacemos algo. En el caso que te explicaba antes sería algo parecido a “desde 0, hasta 50, sumar 5 a la cuenta”.

¿Se entiende no? Es un concepto bastante simple que ojalá me lo hubieran explicado así y no con fórmulas matemáticas que solo servían para que el profe fuera de listo y se riera de nuestra cara de “no me entero de una mierda”. Si sigue sin entenderse no te preocupes que pondré más ejemplos.

4. Condición de salida

Todo bucle ha de tener una condición de salida, esto ya te lo puedes grabar a fuego. “¿Por que?” te preguntarás, “fácil”, te responderé. Imagina que en el ejemplo anterior no nos hubiéramos puesto el límite de contar hasta 50, ¿que hubiera pasado? Probablemente hubiéramos muerto de hambre o de sed al contar hasta el infinito.

Vale, seguramente nos hubiéramos cansado de contar antes de llegar a 500 pero recuerda que las máquinas no se cansan (mira Terminator) y si no les decimos cuándo parar sencillamente no lo harán, seguirán contando hasta infinito durante toda la eternidad.

Por tanto, la condición de salida es aquella parte del bucle que le dice a la máquina cuando puede salir del mismo, en el ejemplo que nos ocupa, llegar a 50

5. Cuerpo del bucle

Ésta es la parte más fácil de explicar, pues se trata de la “chicha”, el código o trozo de programa que “hace cosas”. En nuestro ejemplo simplemente sumar 5 al total, pero podrían ser cosas mucho más complejas.

6. Invariante

Vale, agárrate fuerte porque no entendí éste concepto hasta varios años después (y eso que aprobé el examen…). El invariante es la descripción formal de aquello que tenemos si paramos la ejecución del programa en cualquier momento durante la ejecución del bucle.

¡¡¡ALERTA CULTURAL!!!

En otras palabras, imagina el ejemplo anterior, nos estamos aprendiendo la tabla del 5 y nos dedicamos a empezar desde cero e ir sumando 5 al total hasta llegar a los 50: 0, 5, 10, 15, 20… Ahora imagina que nos paramos en un momento al azar de dicha cuenta, cuando llevamos 30, o 5, o 45… ¿que es lo que siempre se cumple? Eso es el invariante.

En éste caso, lo que siempre se cumple es que “llevo la cuenta de 5 en 5 desde que he empezado hasta el momento actual”… ¿menuda mierda verdad? Pues sí, no sirve para nada. Jamás en mi vida he escrito un invariante más que en un examen, pero si es verdad que a veces, si el bucle es complejo, puede resultar interesante dejar un comentario en el código explicando que es lo que hace… ¿lo podríamos entender como un invariante? Bueno, depende.

Un profesor seguramente te diga que los invariantes deben escribirse en notación formal (conceptos algebraicos de existencia, pertenencia… mierda pura) pero que eso no te quite el sueño, si alguien ajeno al código tiene que entender que es lo que hace te aseguro que te verán con mejores ojos si describes el bucle en una frase que si escribes una fórmula infumable… de hecho lo más probable es que seas tu mismo quien lo lea en unos meses y te des las gracias a ti mismo por haber puesto una explicación clara y sencilla.

¡¡¡FIN DE LA ALERTA CULTURAL!!!

En resumen: el invariante es un resumen de lo que hace tu bucle.

7. Ejemplos

Bueno, vamos a ver algunos ejemplos para que la cosa quede más clara pero… ¡tachán tachán! ¡no vamos a ver NADA de código!

Lo sé, lo sé, soy un pequeño cabroncete, pero créeme que lo último que necesitas ahora mismo es liarte más todavía con códigos y nomenclaturas. Prefiero que lo entendamos todo en un lenguaje mucho más natural.

7.1. La tabla del 5

Vamos a definir el bucle para el ejemplo que hemos estado tratando hasta ahora, recordemos que hablamos de la tabla del 5 y que consiste básicamente en empezar en cero e ir sumando cinco hasta llegar a cincuenta.

Éste bucle lo vamos a definir de la siguiente manera:

var total := 0
desde total = 0 hasta total < 50 hacer
    total += 5;
fin

Esto es lo que llamamos pseudocódigo, un lenguaje semiformal que sirve para definir piezas de código de forma independiente al lenguaje de programación que después queramos utilizar. Sinceramente desconozco si existe un estándar para el pseudocódigo pero por lo que a mi respecta mientras nos entendamos todos nos sirve :p

En nuestro pseudocódigo definimos una variable llamada “total” que vale 0. Acto seguido definimos las condiciones de nuestro bucle, que empieza en 0 y sigue hasta 50, es decir, que la condición de salida es superar 50 (fíjate que la condición de salida es siempre un booleano). Por último tenemos el cuerpo del bucle.

Ahora vamos a repasar los puntos clave para ver si está bien construido:

Invariante: En la variable total tenemos la acumulación de contar de 5 en 5 desde 0 hasta la iteración actual.
Condición de salida: Llegar a 50.

Pues ya está, supongo que se entiende. El invariante describe lo que hace el bucle de forma genérica y además garantiza que se cumpla la condición de salida.
Si pudiéramos ejecutar el bucle veríamos que “total” toma los valores 0, 5, 10, 15, 20, 25, 30, 35, 40, 45 y 50. En ese orden.

7.2. Condición de salida hasta 49

Vamos a modificar el bucle anterior de la siguiente manera:

var total := 0
desde total = 0 hasta total < 49 hacer
    total += 5;
fin

Y vamos a redefinir sus puntos clave:

Invariante: En la variable total tenemos la acumulación de contar de 5 en 5 desde 0 hasta la iteración actual.
Condición de salida: Llegar a 49.

Por lo que hemos definido en el ejemplo anterior, la condición de salida será igualar o superar 49, por lo que el resultado será exactamente el mismo.

7.2. Condición de salida hasta 51

Vamos a modificar el bucle anterior de la siguiente manera:

var total := 0
desde total = 0 hasta total < 51 hacer
    total += 5;
fin

Y vamos a redefinir sus puntos clave:

Invariante: En la variable total tenemos la acumulación de contar de 5 en 5 desde 0 hasta la iteración actual.
Condición de salida: Llegar a 51.

En éste caso vamos a tener una diferencia con respecto a los dos anteriores y es que cuando salgamos del bucle “total” no valdrá 50, sino “55”.
¿Por que? Pues porque en el caso anterior, cuando “total” valía 50 se cumplía la condición de salida, es decir, “total” no era menor a 49. Sin embargo ahora no se cumple dicha condición pues cuando “total” vale 50 no es mejor a 51, eso se cumple en la siguiente iteración cuando “total” vale 55.

7.2. Condición de salida igual a 51

Vamos a modificar el bucle anterior de la siguiente manera:

var total := 0
desde total = 0 hasta total = 51 hacer
    total += 5;
fin

Y vamos a redefinir sus puntos clave:

Invariante: En la variable total tenemos la acumulación de contar de 5 en 5 desde 0 hasta la iteración actual.
Condición de salida: Igualar 51.

¿Que me dices de éste? ¿Hay algo raro verdad? Exacto, el bucle nunca termina.
Cuando “total” vale 50 no se cumple la condición de salida (total = 51) y en la siguiente iteración tampoco pues “total” vale 55… Tenemos lo que se conoce como bucle infinito, lo cual significa que nuestro programa se va a colgar porque porque es incapaz de cumplir la condición de salida.

8. Resumen

Bien, ha sido corto pero intenso y creo que eso es bueno. Si sigo explicándote cosas seguramente te volverías loco así que mejor repasemos lo que hemos visto.

Hemos aprendido lo que es un bucle, que no es más que un trozo de código que se repite una y otra vez. Se compone de un punto de inicio, un punto de final y un cuerpo de bucle.

En el cuerpo del bucle podemos poner el código que nos dé la gana y se ejecutará tantas veces como vueltas (o iteraciones) hagamos, que puede ser un número finito si llega a cumplirse la condición de salida, o infinito si la hemos cagado :p

9. Enunciado del ejercicio para la próxima entrada

Como hace mucho que no mando deberes voy a ser bueno y te voy a proponer algo muy sencillo:

Escribe el bucle en pseudocódigo para contar la tabla del 3, de la misma forma que hemos visto la tabla del 5 en el ejemplo.
Utiliza una variable para contar la cantidad de números pares que aparecen en la tabla.

Nos vemos en la próxima entrada, donde seguiremos ampliando los bucles iterativos y veremos ejemplos mucho menos mierder que los que te he explicado… te lo prometo.
¡¡¡Gracias por seguirme!!! 🙂

Anuncios

7 – Introducción a los Windows Forms (Continuación)

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, que consistía en implementar (o programar) el comportamiento de la calculadora de Windows según el siguiente esquema:

actual = 0
resultado = 0

pulso el número 1

actual = 1
resultado = 0

pulso el símbolo +

actual = 0
resultado = 1

pulso el número 3

actual = 3
resultado = 1

pulso el símbolo +

actual = 0
resultado = (3 + 1) = 4

pulso el número 7

actual = 7
resultado = 4

pulso el símbolo –

actual = 0
resultado = (7 + 4) = 11

pulso el número 2

actual = 2
resultado = 11

pulso el símbolo +

actual = 0
resultado = (11 – 2) = 9

Solución:

Para empezar veo bastante claro (espero que tu también lo hayas visto) que hacen falta dos variables, una para el valor actual y otra para el resultado. Tal y como sugerí en el enunciado voy a hacer uso de la clase Calculadora que creamos en capítulos anteriores.

Si recuerdas bien, a dicha clase le podíamos pedir operaciones y que nos dijera el resultado por lo que la podemos usar para almacenar nuestro resultado.

Voy a aprovechar todo el código del capítulo anterior pues estamos ante la continuación del mismo. La cosa empezaría así:

7.res.1

Vale, no era mi intención que se me complicara la cosa nada más empezar pero ya nos viene bien para hablar de los “namespaces”.

1.1. Namespaces

Empecemos primero con un ejemplo sencillo:

Tú has programado tu calculadora (la del capítulo 5) en un proyecto que se llama “C5” y nuestra amiga Carola lo ha hecho en un proyecto que se llama “Cap5”. Tu clase se habría creado en un namespace llamado “C5” de esta forma:

7.res.3

Y la de nuestra amiga Carola sería de la siguiente forma:

7.res.4

Las dos están bien construidas (falta código, solo he puesto el inicio) pero en namespaces diferentes., esto es así porque cuando creas un proyecto Visual Studio te mete las clases en un namespace que se llama igual que el proyecto.

El namespace es como si fuera una caja con un nombre, si sabes el nombre de la caja puedes ir a buscar lo que sea que haya dentro. Si dos cajas se llaman igual… pues tenemos un problema.

Si te fijas, en éste ejemplo tanto tú como Carola tenéis una clase que se llama igual (Calculadora) pero en namespaces diferentes, así que podrías usar las dos clases en el mismo proyecto sin problemas así:

7.res.5

¿Lo ves? Con decirle a C# en que namespace debe buscar la clase la cosa funciona y eso es lo mismo que he hecho yo, solo que mi namespace se llama “Capitulo_5”.

Además si te fijas mi proyecto también se llama “Calculadora” (línea 11 de la imagen superior) por lo que estoy obligado a decirle que quiero usar la calculadora de “Capitulo_5” si quiero hacer las cosas bien.

Espero que se haya entendido, si no siempre tienes los comentarios 😉

1.2. Programando la solución

Recuerda que ya teníamos programados los métodos de los botones numéricos, al pulsarlos se ponía el valor del número en “_current” y se mostraba el número en el display de nuestra calculadora.

Si te fijas, según el enunciado, cuando se pulsa un número se guarda en “_current” y eso ya lo tenemos hecho. Nos falta hacer la parte de pulsar un botón de opración por lo que tenemos que programar los botones de “suma”, “resta”, “multiplicación” y “división”.

Según el enunciado, al pulsar uno de estos botones se realiza la operación entre “_current” y lo que haya en el total para, después, dejar “_current” a cero. Vamos a ello:

7.res.6

Si miras el primer método (corresponde a la suma) verás que lo único que hace es decirle a la calculadora que sume el número que hay en “_current” y acto seguido invoca al método ActualizarTotal. Esto método (el último de la imagen) resetea “_current” a cero y muestra el total de la calculadora en el display.

El método ActualizarTotal nos lo podemos ahorrar pero tendríamos dos líneas repetidas en los 4 métodos de las operaciones lo cual no es aconsejable. Te recomiendo que todo el código repetido lo metas en un método porque te será más fácil hacer cambios después (imagina que no queremos resetear “_current”, tendrías que hacer 4 cambios en lugar de uno).

Y con esto tan tonto ya hemos hecho lo que se nos pedía.

2. Contenido del capítulo

Bueno, lo cierto es que éste capítulo es una ampliación del anterior así que la temática va a ser muy similar.

Me encantaría que pudiéramos ver todos los controles y hacer ejemplos con cada uno de ellos pero eso nos llevaría demasiado tiempo así que me voy a centrar en algunos controles que considero más interesantes que otros. No obstante te invito a que crees un nuevo proyecto con Visual Studio y te pongas a jugar con los controles que ofrece, esa es la mejor manera de aprender 🙂

El temario de hoy es:

  • Controles
    • CheckBox
    • RadioButton
    • DateTimePicker
    • PictureBox
    • MenuStrip
    • Timer
  • Resolución de un ejercicio de ejemplo
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

Lamentablemente no podemos aplicar estos controles en nuestra calculadora (excepto el menú) por lo que la vamos a dejar aquí, si más adelante surge la oportunidad de continuarla para hacer algún ejemplo la volveremos a tocar pero por ahora la dejamos en pausa. Eso sí, te animo encarecidamente a que la termines por tu cuenta, con lo que te he enseñado tienes más que suficiente para terminarla con la ayuda del Sr. Google y, si por lo que sea te quedas encallado/a en algún punto no dudes en enviarme un mensaje vía comentarios.

Si además, por petición popular queréis que continuemos con la calculadora, también lo podemos hacer 🙂

3. Controles

Pues al turrón, recordemos que hemos visto los “Buttons”, los “TextBoxes” y los formulario pero nos quedan unos cuantos controles interesantes por ver. Como he dicho antes me voy a centrar en los más útiles y/o comunes.

Te recomiendo que crees un nuevo proyecto limpio para que no te líes con lo que tenemos hecho hasta ahora.

3.1. CheckBox

El “CheckBox” es el típico recuadro que se marca con un “tick” y se suele utilizar para selecciones de respuesta múltiple, crea un CheckBox en el formulario (de la misma forma que hicimos con los botones) y échale un vistazo a sus propiedades:

7.check.1

Verás que sus propiedades son muy similares a las de un “Button” o un “TextBox”, pero el valor que más te interesa es la propiedad “Checked” que será la que te permitirá saber si una persona ha hecho clic o no. Además, como puedes observar si tocas el botón del rayo, tienes multitud de eventos que puedes programar como “Click” o “CheckedChanged”.

Su uso es tan simple que vamos a reservarnos los ejemplos para el final, donde los vamos a ver todos de golpe.

3.2. RadioButton

El “RadioButton” es el hermano del “CheckBox” (checks para los amigos) pues la función es la misma (seleccionar) pero en éste caso de forma única. Haz una prueba y pon un par de radios (“RadioButtons”) en el formulario, cuando le des al play verás que solo puedes seleccionar uno de ellos, cosa que no ocurre con los checks.

7.radio.1

3.3. DateTimePicker

El “DateTimePicker” permite que un usuario pueda seleccionar una fecha desde un calendario desplegable de forma cómoda y sencilla. Además, el valor que podemos recoger (en la propiedad “Value”) nos viene en forma de objeto “DateTime”, dicho objeto contiene una fecha y la podemos transformar con total comodidad.

Unas de las ventajas de éstos componentes es que nos ahorra el molesto problema de “escribe la fecha con dos dígitos para el día, dos para el mes y cuatro para el año. ¡Ah! No escribas letras que sino revienta todo el puto programa”. Además el objeto “DateTime” lo podemos mostrar al usuario en forma de texto con el ya conocido “ToString” y podemos decidir en que formato (dd-mm-aaaa, dd/mm/aaaa, etc), por no hablar de sumar días, horas, etc.

7.date.8

3.4. PictureBox

El picture box es uno de los controles más sencillos de utilizar, cuando lo crees verás que aparece una flechita que te despliega un asistente. La gracia de éste control es que se puede manipular en tiempo de ejecución mediante código para, por ejemplo, cambiar la imagen. Una posible aplicación sería mostrar un led que se enciende cuando movemos el ratón y parpadea cuando se queda quieto.

7.pic.7

3.5. MenuStrip

Éste control te permitirá montar menús tan clásicos como “Archivo”, “Ayuda / Acerca de…” o el favorito de todos “Edición / Copiar”. Cuando lo crees verás que puedes ir añadiendo otros elementos o ir escribiendo los nombres de las secciones. No tiene demasiado misterio.

Además, al igual que los botones, puedes hacer doble click para crear eventos en caso que quieras programar alguno.

7.menu.9

3.6. Timer

El timer es un objeto muy interesante, ya que nos permite decirle cada cuanto tiempo se ha de disparar un evento que nosotros podemos programar. Simple, sencillo y sin misterio. Además, es el único control que hemos visto que no es gráfico (no aparece en el formulario cuando le das al play).

4. Resolución de un ejercicio de ejemplo

Nos piden un formulario de Windows que recoja el nombre, apellido, fecha de nacimiento, sexo y aficiones de una persona. Debe incluir dos botones: uno para resetear el formulario y otro para aceptar. Cuando se acepta se debe mostrar un mensaje con un resumen de las opciones seleccionadas. También ha de aparecer de forma automática, cada 30 segundos, un mensaje que diga “Programar mola y saltar a la comba también.”

Además, como guinda del pastel, se pide una opción en un menú para cerrar la aplicación.

4.1. Primera parte: el botón “Aceptar”

Pues vamos al turrón, la parte más fácil es montar el formulario con los elementos que nos piden. Vamos a usar “Labels” para las etiquetas, “TextBoxes” para el nombre y apellido, “DateTimePicker” para la fecha de nacimiento, como el sexo es de opción única vamos a usar “RadioButtons” y para las aficiones “CheckBoxes”. La cosa quedaría más o menos así:

7.ejemplo.1

Vale, le damos doble click al botón aceptar y programamos su evento clic. Lo que vamos a hacer es recorrer los controles (yo les he puesto un nombre que me sea fácil de recordar), coger su valor, montar un string y mostrarlo en un “MessageBox” (que ya los hemos visto antes). Allá vamos:

7.ejemplo.2

Espero que se entienda todo lo que he hecho, a estas alturas debería ser así. Si no es el caso siéntete libre de preguntar en los comentarios pues soy consciente que en ocasiones me puedo explicar como el puto culo.

Si se ejecuta esto, se rellena el formulario y se le da al botón de aceptar nos encontramos con el siguiente mensaje:

7.ejemplo.3

¿Feo de cojones verdad? Normal, no hemos puesto ningún salto de línea. Vamos a retocar nuestro mensaje:

7.ejemplo.4

Ahora el mensaje mola mucho más porque he puesto saltos de línea después de cada línea:

7.ejemplo.5

¿Lo ves? Todo más clarito.

Antes de seguir con el ejercicio me gustaría hacer algunas optimizaciones en el código para que quede más bonito (ya sabes que me encantan estas cosas), las hago y las comentamos:

7.ejemplo.6

Bien, la primera optimización la tenemos en la línea 26. Los checks “sexoSi” y “sexoNo” son complementarios por lo que para saber que se ha marcado me basta con mirar uno de los dos… siempre y cuando active uno como predeterminado (sino podría ser que ninguno estuviera marcado que es el estado inicial del formulario). Activar uno por defecto es tan fácil como poner a “true” la propiedad “Checked” desde la vista del formulario.

Lo segundo que he hecho está en la línea 27, he inicializado el array de forma inline, algo que ya habíamos visto en capítulos anteriores.

Lo último es un poco más extraño, está en la línea 29 y es una forma curiosa, potente y eficiente de construir strings. Consiste en utilizar el método “Format” del objeto “string”, en el primer parámetro metemos el texto y dejamos huecos en blanco con llaves numeradas (“{0}, {1}, {2}, etc.”). El resto de parámetros son los valores de esos huecos, como nosotros hemos usado dos huecos hemos de poner dos parámetros y ahora viene lo mejor: ¡da igual el tipo de objeto! Puedes poner un string, un int, un bool… lo que quieras.

Por último fíjate en la línea 31, el método “ToString” de “fNaci” tiene un parámetro de tipo string con el valor “dd/MM/yyyy”. Eso es así para que la fecha aparezca en ese formato, es decir, dos dígitos para los días, dos para los meses (la m es mayúscula porque las minúsculas hacen referencia a los minutos) y cuatro para la hora. Tienes más información sobre como formatear fechas aquí.

4.2. Segunda parte: el botón “Reset”

Esto va a ser más fácil, lo único que hay que hacer es dejar los controles como estaban cuando se carga el formulario. Doble click al botón “Reset” y a programar:

7.ejemplo.7

De aquí lo único que quiero comentar es la tercera línea, “DateTime.Today” accede a la propiedad “Today” del objeto “DateTime” (que no hace falta declarar) que es la fecha con la que arranca por defecto nuestro “DateTimePicker”.

Seguramente volvamos sobre éste ejemplo en el siguiente capítulo cuando hablemos de la iteratividad… no te asustes que mola más que asusta 😉

4.3. Tercera parte: el menú

Voy a crear un control “MenuStrip” con una opción llamada “Archivo” y dentro otra llamada “Salir” al igual que en la mayoría de aplicaciones:

7.ejemplo.8

Ahora doble click sobre “Salir” y programamos el cierre de la aplicación:

7.ejemplo.9

¿Fácil verdad? El objeto “Application” nos permite controlar nuestra propia aplicación y uno de sus múltiples métodos es “Exit”. Te animo a que juegues con éste objeto para que veas su potencial.

4.4. Cuarta y última parte: el temporizador

Esta es la más diver-chachi, vamos a crear un control de tipo “Timer” y lo vamos a programar a 30 segundos:

7.ejemplo.10

El “Timer”, a diferencia del “MenuStrip” no aparece dibujado en el formulario pero si vemos el componente en esa zona etérea de debajo del mismo donde lo podemos seleccionar como un control más y acceder a sus propiedades. Fíjate que lo he marcado como “Enabled” para que funcione desde el principio y que el intervalo es de 30.000 milisegundos, es decir, 30 segundos.

Ahora le hacemos doble click al timer y empezamos a programar lo que hará cada vez que se active, que será mostrar un mensaje tal y como nos han pedido:

7.ejemplo.11

Otra vez nuestro amigo “MessageBox” nos hace el trabajo, si ahora arrancas la aplicación y esperas 30 segundos verás como aparece el mensaje.

5. Resumen

Hoy hemos ampliado nuestros horizontes con los controles de Windows Forms y, aunque no están todos los que són, si que son todos los que están… o algo así… osea que todo lo que hemos visto son controles, pero no los hemos visto todos… es igual, que me voy por las ramas…

Ya hemos visto y jugado con los siguientes controles:

  • Label
  • TextBox
  • Button
  • DateTimePicker
  • RadioButton
  • CheckBox
  • MenuStrip
  • Timer

Me gustaría enseñártelos todos pero acabaríamos en dos años y tampoco es el objetivo de éste curso, yo solo pretendo enseñarte las bases y quitarte el miedo a probar y descubrir las cosas por ti mismo, y para ello nada mejor que un ejercicio para la entrada que viene:

6. Enunciado del ejercicio para la próxima entrada.

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

Pistas

Para el estado civil puedes usar el control “ComboBox”.
Para los colores el control “ColorDialog”.
Como mostrar el “ColorDialog” queda a tu elección (botón, menú…)

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

6 – Introducción a los Windows Forms

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:

Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máximo de pasajeros permitido y tu sistema debe permitir lo siguiente:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Solución:

Muy bien, vamos a empezar haciendo el truco que te enseñé en el capítulo anterior y vamos a determinar que clases necesitamos, con que atributos y que métodos. Empecemos con las clases, recuerda que para ello hemos de buscar sustantivos:

Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máximo de pasajeros permitido y tu sistema debe permitir lo siguiente:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Empecemos por “sistema”, el sistema de seguridad es lo que nos piden montar, aquí podemos hacer dos cosas: desarrollar el sistema como una clase, o obviarlo y meter toda nuestra lógica directamente en el formulario… Había pensando en obviarla pero la voy a tener en cuenta para que veas que esto puede ser tan flexible como tu quieras. Seguimos por “ascensor”, que es el elemento principal de éste ejercicio. Si te fijas todo gira en torno al ascensor (es por ello que decía que podíamos obviar la clase “sistema”) por lo que podemos decir que “ascensor” es la clase fuerte o dominante.

Nos queda la clase “pasajeros”, nos la apuntamos también.

Vamos a buscar ahora atributos, recuerda que es todo aquello que denote algún tipo de propiedad o descripción ya sean adjetivos o pequeños sintagmas:

Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máximo de pasajeros permitido y tu sistema debe permitir lo siguiente:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Bien, sencillo hace referencia al sistema de seguridad y nos indica que el problema es fácil, no hace falta comerse mucho la cabeza para ver que nos lo podemos pasar por el forro. Lo siguiente tiene más chicha, “número máximo de pasajeros” no es un adjetivo pero sí que define una propiedad del ascensor, nos está dando información detallada del mismo así que podríamos tomarlo como un parámetro.

Esto no siempre es infalible ni tampoco claro, ante la duda te recomiendo que lo tengas en cuenta y sobre la marcha te darás cuenta que sobra… siempre es mejor que sobre que no que falte 😉

Fíjate que he marcado “el límite de pasajeros permitido”, “la cuenta de pasajeros que entran” y “la cuenta de los pasajeros que salen”. El primero ya lo hemos tenido en cuenta, pero los otros dos nos dan una pista de que vamos a necesitar un contador de pasajeros, por tanto necesitamos otro atributo.

Por último los métodos, suelen ser verbos o acciones:

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

¿Bastante fácil esta parte no? Lo cierto es que intenté que el enunciado fuera sencillo y fácilmente analizable, si no lo he conseguido me lo tengo que hacer mirar :p

¿Que tenemos hasta ahora? Agarra papel y lápiz (tus dos mejores amigos) y hagamos recunto:

  • Tres clases: “sistema”, “ascensor” y “pasajero”.
  • Dos atributo de “ascensor”: el “número máximo de pasajeros” y “los pasajero que hay montados”
  • 4 métodos para el sistema de seguridad:
  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Si te fijas, la clase “pasajero” se nos ha quedado sin atributos ni métodos, de hecho lo único que vamos a hacer es contar pasajeros, por lo que son más bien un atributo y no una clase así que no la tendremos en cuenta.

Te recomiendo siempre que vayas de dentro hacia afuera, como el sistema de seguridad es el que maneja ascensores vamos a empezar por ascensor, programemos:

6.1.solucion1

Aquí tienes mi clase Ascensor, que he creado en un fichero nuevo llamado “Ascensor.cs” y tiene los dos atributos que hemos visto antes.

Vamos ahora con la clase Sistema:

6.2.solucion2

El constructor de Sistema crea el ascensor. El resto de métodos nos permiten hacer lo que nos pide el enunciado: establecer el número máximo de pasajeros, llevar la cuenta de los que entran y salen (es decir, poner y quitar) y mirar si el límite está sobrepasado.

El atributo “_ascensor” lo que puesto como private para que no sea visible desde fuera de “Sistema”, lo del guión delante es una manía mía que me ayuda a identificar rápidamente que atributos son públicos y cuales privados… no es esencial pero a mi me resulta útil.

Con esto habríamos resuelto el ejercicio pero creo que es una oportunidad perfecta para enseñarte la importancia de los atributos y métodos privados.

2. La importancia de los atributos y métodos privados.

Imagina que le entregamos a un cliente esta clase tal cual la tenemos programada y la empieza a usar en sus sistema de seguridad para ascensores. Nos dice que gracias a nuestro trabajo ha desarrollado un sistema de alarma que le avisa si el ascensor está en peligro de sobrecarga.

Como gracias a nuestro trabajo no ha de preocuparse de que el ascensor se caiga nos va a pagar un pastizal, pero también nos advierte de que si algo sale mal nos va a tirar a sus abogados para que nos quiten hasta los dientes.

Si código es el que sigue:

6.3.solucion3

Como puedes ver el tío tiene razón, ha usado nuestra clase Sistema para montar un sistema de alarma, su méetodo PasajeroEntra le retorna un booleano que le dice si se ha sobrepasado el límite de ocupación o no (que está inicialmente establecido en 4).

¿Te das cuenta de lo que ha hecho este pedazo de imbécil? ¡El tío incrementa el número máximo de pasajeros cuando se supera el límite y se queda tan tranquilo! ¡¡Esta alarma nunca va a sonar!! ¡¡¡Nos va a echar la culpa a nosotros!!!

Vale, es un ejemplo un poco bestia pero toda esa gente va a morir porque nosotros le hemos dejado usar nuestro sistema de seguridad como le ha dado la gana y eso, precisamente, no es seguro… Vamos a hacer un par de cambios:

6.4.mejora1

Ahora nuestro método SetMaxPasajeros es privado y no se puede llamar desde fuera, en cambio el máximo de pasajeros se le pasa a la constructora que sí puede llamar al viejo método SetMaxPasajeros.

¿Que hemos conseguido ahora? Justamente esto:

6.5.mejora2

El tío ya no puede hacer lo que hacía, porque los métodos que quiere tocar ya no son accesibles y por ello se ve obligado a cambiar el código de la siguiente forma:

6.6.mejora3

Se ve obligado a establecer el máximo desde un inicio y ya no lo puede cambiar dentro de nuestro “Sistema” aunque el muy burro lo cambie fuera. Con éste sencillo cambio nuestro sistema ha dado la alarma cuando debía sin sufrir manipulaciones externas… siempre y cuando sea verdad que el ascensor aguanta a 4 personas…

3. Contenido del capítulo

Ya sé que siempre pongo esto en el punto 2 pero esta vez se me ha ido al 3…

  • Introducción a Windows Forms
    • Controles
    • Propiedes
    • Eventos
  • Resolución de un ejercicio de ejemplo
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

Como puedes ver lo prometido es deuda y hoy vamos a hablar de ventanitas, botoncicos 🙂

4. Introducción a Windows Forms

Windows Forms es el nombre que reciben las aplicaciones desarrolladas con Visual Studio que muestran ventanas con botones, menús, campos de texto, etc. Hasta la fecha hemos estado creando aplicaciones de éste tipo pero solamente hemos visto el código, hasta hoy.

Ha llegado el momento de echar un vistazo al fichero “Form1.cs” en su vista de diseño, puedes usar el mismo proyecto que usamos para la calculadora porque nos va a ir de lujo para lo que te quiero enseñar. Si lo abres deberías ver algo como esto:

6.7.forms1

Seguro que lo recuerdas de sesiones anteriores, era esa ventana donde no podíamos tocar nada excepto hacerla más grande. Pues ese es nuestro formulario y es donde vamos a aprender a usar éstos elementos.

4.1. Controles

Lo primero que vamos a hacer es poner un cuadro de texto en éste formulario, para ello desplegamos el “cuadro de herramientas” (a la izquierda) y, dentro de “Controles comunes”,  escogemos “TextBox” haciendo clic. 6.8.forms2

Lo siguiente que has de hacer es dibujar el cuadro de texto sobre el formulario, verás que el cursor ha cambiado de forma al escoger el TextBox así que lo único que tienes que hacer eshacer clic sobre el formulario. Esto hará que aparezca una hermosa y flamante caja de texto vacía.

6.9.form3

 

Verás que la puedes hacer más grande si arrastras los cuadritos blancos de los laterales (aparecen al hacer clic sobre la caja), que la puedes mover si la arrastras, etc. Hasta aparecerán unas guías que te ayudarán a colocarla de forma más cómoda dentro del formulario. Por ahora vamos a hacer que quede de una forma parecida a ésta:

6.10.forms4

4.2. Propiedades

Ahora haz clic sobre la caja para seleccionarla y fíjate en el panel de propiedades abajo a la derecha:

6.11.form5

¿Chulo eh? Esas son todas las propiedades de nuestro TextBox y la mitad no las vamos a tocar en nuestra puta vida. En el listado puedes ver que su nombre es “textBox1”, que su posición es la “12;12” (al menos en mi caso, si en el tuyo es diferente no pasa absolutamente nada) o que sus modificadores son privados (¿te suena?). Vamos a hacer una cosa, vamos a buscar una propiedad que se llama “Text” y vamos a escribir “Hoy estoy chichinabesco” y ni se te ocurra escribir algo diferente o mataré a un gatito.

6.12.form6

Y ahora mira de nuevo tu formulario para contemplar asombrado como ha aparecido ese texto dentro del TextBox.

6.13.form7

Ahora dale al play, verás que aparece esta misma ventana y que podemos jugar con ella y, por supuesto, también podemos modificar el texto que hemos escrito. ¿Por que ocurre esto? ¿Que está pasando? Es muy fácil:

El TextBox que has dibujado, aunque el Visual Studio te lo muestra así en realidad no es más que un objeto, una clase de tipo “TextBox” muy parecida a nuestra clase “Calculadora” pero bastante más compleja. Esta clase “TextBox” tiene sus propios métodos y atributos y uno de ellos es precisamente “Text” que se encarga de almacenar el texto que se ha de mostrar.

 Ahora vamos a añadir un botón a nuestro formulario, repetimos los pasos anteriores pero escogemos “Button” y lo ponemos más o menos así:

6.14.form8

Si haces clic sobre el botón y miras el panel de propiedades verás algo muy parecido a antes, vamos a cambiar la propiedad “Text” y pondremos un texto cualquiera… me siento tán generoso que te dejo elegir XD. Como podrás ver ocurre lo mismo, el texto que sale en el botón ha cambiado.

4.3. Eventos

Ahora quiero que te fijes en el panel de propiedades y busques el símbolo de un rayo, si le haces clic pasarás a ver los eventos del botón (la hojita de la izquierda son las propiedades que veíamos antes, el rayo son los eventos):

6.15.fomr9

Aún no hemos hablado de eventos pero son muy sencillos de entender. Un evento es una especie de método que se ejecuta cuando se produce una situación concreta. Por ejemplo, el evento “Click” de éste botón se ejecuta cuando el usuario le hace clic.

 Vamos a hacer doble clic sobre el texto “Click” y veremos que por automagia se nos ha creado un método click listo para programar:

6.16.form10

Sea lo que sea lo que programes aquí dentro se ejecutará cuando el usuario haga click en el botón. Para demostrarlo vamos a cambiar el texto de la caja de texto que hemos usado antes.

6.17.fomr11

Si recuerdas bien, el TextBox que hemos creado se llamaba “textBox1” (porque no le hemos cambiado el nombre), si lo escribes y le das al punto Visual Studio te muestra sus atributos y métodos. Lo único que hacemos es acceder a su propiedad “Text” y cambiarla por un string a nuestro gusto.

Ahora prueba de darle al play y haz clic en el botón… ¡¡¡sorpresa!!!

6.18.form12

Exacto, ha pasado exactamente lo que hemos programado, al hacer clic se ha ejecutado nuestro código y el texto ha cambiado. Si quieres verlo más en detalle te recomiendo que pongas un breakpoint por ahí e investigues.

Existen infinidad de controles (botones, cajas de texto, tablas, etiquetas…) y obviamente no los vamos a ver todos, pero ya tienes las herramientas necesarias para ir investigando y, como te digo siempre, recuerda que Google es tu amigo y que yo respondo todas las dudas que me encuentro en los comentarios 🙂

5. Resolución de un ejercicio de ejemplo

Para que todo esto quede más claro, vamos a hacer un ejercicio de ejemplo basado en la calculadora que hicimos en el capítulo anterior. Y el ejercicio es… ¡hacer una calculadora!

No te asustes, que la calculadora ya la hemos hecho, es la clase “Calculadora.cs” que hicimos en la sesión anterior pero ahora le vamos a dar una interfaz para que una persona que no sabe programar la pueda usar y, así de paso, ves la diferencia entre el código de una aplicación y el código que controla su interfaz.

Lo primero que vamos a hacer, para que te familiarices con los controles y Visual Studio es imitar la interfaz de la calculadora de Windows en su vista estándar. Usando el mismo proyecto que tenemos creado, vamos a aprovechar el TextBox y el Button que hay en el formulario y vamos a añadir el resto de botones. A continuación te dejo una imagen de la calculadora de Windows (izquierda) y la que he hecho yo (derecha).

  6.19.calc1             6.20.calc2

Antes de liarte a dibujar botones déjame darte dos consejos:

  1. Los botones se pueden copiar y pegar, lo cual es cómodo y útil.
  2. Si quieres poner varios controles iguales, haz clic en el control (del cuadro de herramientas), apreta y deja apretado el control, y a cada clic en el formulario tantas veces como controles del mismo tipo quieras.

Por ahora las calculadoras se parecen como un huevo a una castaña pero ya lo iremos perfilando. Los símbolos de raíz, la flecha, etc. los he cogido del Word (Insertar/Símbolo) pero si no tienes licencia de Word (aquí no animamos a la piratería a no ser que no implique llevar un loro en el hombro) te recomiendo probar con Libre Office (un editor de texto libre y gratuito muy parecido al Word de Microsoft) o, simplemente, copiar y pegar los que te dejo a continuación:

  • Flecha: ←
  • Mas menos: ±
  • Raíz: √

Vale, por ahora no vamos a dejar más bonita la interfaz pero si vamos a tocar un par de detalles de nuestro TextBox. La propiedad Text la vamos a dejar vacía para que no salga nada, y a la propiedad Name le vamos a poner “txtResultado” porque “textBox1” no me gusta… piensa que ahora solo hay un TextBox pero si tuvieras muchos te resultaría muy difícil saber cual es cual si se llaman “textBox1”, “textBox2”, etc.

Vamos a hacer lo mismo con los botones, te dejo escoger el nombre pero te hago dos recomendaciones: que sea un nombre lógico y que empiece por “btn”, como por ejemplo “btnSuma”… ya verás por qué 😉

Vamos al código del formulario principal, re recuerdo que puedes llegar haciendo clic con el botón derecho sobre “Form1.cs” en el “Explorador de soluciones” y escogiendo la opción “Ver código” o pulsando la tecla “F7”.

Asegúrate que todo el código está limpio, deberías ver algo muy parecido a esto:

6.21.clacl3

Vale, antes de empezar a programar una calculadora hay que entender como funciona una calculadora. Como nuestra intención es imitar la calculadora de Windows vamos a ir probando que hace exactamente a fin de irla imitando poco a poco.

Si te fijas, nada más abrirse nos muestra en el resultado un 0, pero si le das al play verás que en tu campo de resultados no aparece nada… No te preocupes que lo solucionaremos.

Empecemos con la suma. Si te fijas, para que la calculadora de Windows haga una suma has de apretar un número, darle al +, después a otro número y acto seguido darle al =. Vamos a empezar programando esto y, para ello hay que entender como funciona por dentro.

Cada vez que pulsas un número aparece en el display de la calculadora, por tanto necesitamos una variable que lo recuerde. Empecemos por ahí. Vamos de nuevo al formulario (si no lo tienes abierto haz doble click en “Form1.cs” en el “Explorador de soluciones” y pulsa sobre el botón “7”. En las propiedades le damos al botón de eventos (el rayo) y hacemos doble click en “click”, lo cual nos lleva de nuevo a la vista de código pero dentro del método click de éste botón.

Como hemos comentado antes, queremos que la calculadora recuerde que hemos pulsado el 7, por lo tanto vamos a definir una variable global, o lo que es lo mismo, un atributo de nuestra clase “Form1”:

6.22.clalc4

Ahora vamos a hacer dos cosas, vamos a decirle a nuestra nueva variable global “_current” que su valor es 7 y vamos a mostrar dicho valor en nuestro TextBox al igual que hace la de Windows:

6.23.calc5

¿Facil verdad? ¿Ves que he puesto un “ToString” detrás de “_current”? El atributo “Text” de “txtResultado” es de tipo string, pero “_current” es un int, el método “ToString” de “_current” permite transformar ese int a string para que lo podamos poner en “Text”.

Si ahora ejecutas la aplicación y le das al botón 7 verás que pasa exactamente esto que decimos aunque no quede igual de bonito que en la calculadora de Windows. Vamos a hacer lo mismo para el resto de números pero primero ahí va otro truco: si haces doble clic a un botón en el formulario crearás automáticamente un evento clic 😉

6.24.calc6

No me han cabido todos en la imagen pero tengo todos los números programados. Volvamos a la calculadora de Windows, y vamos a ver exactamente que pasos sigue a la hora de calcular.

Empieza en 0, si pulsamos el 1 lo muestra en pantalla, si pulsamos el + no hace nada, si pulsamos el 6 lo saca por pantalla, si pulsamos otra vez el + nos saca la suma de 6+1… De esto podemos deducir que la calculadora tiene dos valores principales: el número actual y el resultado.

El primer valor introducido lo usa como resultado. A partir de ahí cada vez que se pulsa un símbolo de operación toma el valor introducido y hace la operación con el resultado… me explico:

actual = 0
resultado = 0

pulso el número 1

actual = 1
resultado = 0

pulso el símbolo +

actual = 0
resultado = 1

pulso el número 3

actual = 3
resultado = 1

pulso el símbolo +

actual = 0
resultado = (3 + 1) = 4

pulso el número 7

actual = 7
resultado = 4

pulso el símbolo –

actual = 0
resultado = (7 + 4) = 11

pulso el número 2

actual = 2
resultado = 11

pulso el símbolo +

actual = 0
resultado = (11 – 2) = 9

Y así hasta el infinito. A esto de deducir como está programada una aplicación estudiando su uso se le llama “Ingeniería Inversa” y en según que cosas (como descubrir como piratear la Play) puede ser hasta ilegal… Microsoft, si estás leyendo esto no te enfades, nuestra calculadora será mucho mejor que la tuya así que tranquila que no estamos copiando nada :p

Bien, soy consciente que programar esto no es trivial, y es posible que tengas la cabeza hecha un lío. No te preocupes, es totalmente normal. Estas cosas se sacan con muchas horas de práctica y muchas más horas de Google.

Si te pongo el código de como programar esto seguramente te limites a leerlo, copiarlo y entenderlo pero lo realmente difícil es sacarlo cuando tienes una pantalla en blanco. Es así como realmente se aprende y se automatizan estas cosas, cuando tienes un lienzo en blanco, te estrujas los sesos y das con una solución que funciona, luego la mejoras, y la vuelves a mejorar… te aseguro que eso no se olvida y proporciona una sensación de satisfacción increíble. Es por ello que no te voy a decir como continuar… ¡hasta el próximo capítulo!

6. Resumen

En realidad no hemos visto muchas cosas en éste capítulo pero si que tienen bastante calado, hemos visto los controles de Windows Forms y solamente hemos usado “Buttons” y “TextBoxes”. También hemos visto que tienen propiedades, métodos e incluso hemos programado alguno de sus eventos como el “Click”.

Por último hemos visto algún ejemplillo y hemos empezado a hacer una calculadora que el muy cabrón de yo no ha querido terminar con la excusa de que esto es bueno para ti.

7. Enunciado del ejercicio para la próxima entrada.

Te dejo para el próximo capítulo la tarea de programar el funcionamiento básico de la calculadora, es decir, eso que hemos explicado con Ingeniería Inversa. Ni más, ni menos.

Creo sinceramente que con todo lo que se ha explicado tienes las herramientas necesarias para hacerlo con éxito. No te pongas límites, no te ofusques, no te preocupes si el código es bonito o eficiente. Usa tantas variables como quieras, públicas o privadas. Haz todo lo que se te ocurra pero haz que funcione. Si consigues hacer que funcione aunque hayas necesitado 2000 líneas de código significa que eres el/la puto amo/a y que estás siguiendo el curso a un ritmo excelente. En serio, para hacer las cosas bonitas siempre se está a tiempo, lo que me interesa ahora es que des con una solución funcional que salga directamente de tu cabeza y a tu manera.

Pista:

¿Recuerdas la clase “Calculadora” del capítulo anterior? Te puede ser de utilidad aunque si no la usas no pasa absolutamente nada.
Usa tantas variables globales como creas que necesitas.
No hay límites de ningún tipo, ¡¡¡desata tu creatividad!!!

5 – Programación orientada a objetos

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:

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.

Solución:

¿Lo has conseguido? Sea de la forma que sea, usando Google, sin ayuda y dándole al coco, sea como sea… si lo has conseguido mis más sinceras felicitaciones, significa que lo estás pillando todo al vuelo. Si no lo has conseguido no pasa, estamos aquí para aprender.

Eso sí, si has mirado la solución sin haberle dedicado como mínimo una hora a darle al tarro haz una cosa: date unos cuantos azotes en el culete y repite conmigo “soy un niño/a muy travieso”. Ahora en serio, no pasa nada siempre y cuando te sirva para aprender, pero como se aprende de verdad es resolviendo las cosas por ti mismo, seré muy pesado con esto porque creo que es el mejor consejo que te puedo dar 🙂

Vale, vamos allá.

Vamos a empezar haciendo caso al enunciado y vamos a hacer un copy/paste del ejemplo del capítulo anterior:

17.ejemplo5

No lo he dicho antes (mea culpa, lo siento) pero habrás notado a la hora de debugar que C# es un lenguaje secuencial, eso quiere decir que las instrucciones se ejecutan en orden una después de otra, en nuestro caso línea a línea de arriba a abajo. Lo que estamos haciendo con los condicionales es abrir caminos, es decir, indicarle al código que unas cosas se ejecutan solo bajo unas condiciones… algo así como las señales de prohibido aparcar a un lado de la acera los días impares.

En el ejemplo anterior iremos ejecutando el código línea a línea y entraremos en el primer condicional. Si cambias el valor de palancaDerecha a false verás que no entras en el primero sino en el segundo.

Vale, copiando esto tenemos medio ejercicio resuelto ya que tenemos programado el comportamiento de dos de las tres palancas. Primero vamos a entender bien que estamos haciendo, nos vamos a alejar mucho, tanto que no vamos a ver el código sino solo la idea que refleja de una forma sencilla y abstracta. Vamos a dibujar el diagrama de flujo:

5.2.solucion2

Aquí se ve muy clara la idea que sigue nuestro programa, el rombo representa la decisión de tirar de la palanca derecha, el SI nos lleva una acción y el NO a otra acción diferente por lo que estamos haciendo algo como “Si estiro la derecha hago lo que hace la palanca derecha, sino hago lo que hace la palanca izquierda”.

Esto lo podemos extender fácilmente haciendo: “Si estiro de la palanca de la derecha, hago lo que hace la palanca derecha, sino hago otra cosa“. ¿Ves por donde voy?

5.3.solucion3

Esto en código sería algo muy parecido a lo de antes… de hecho es lo mismo pero borrando el código que aún no hemos programado:

5.1.solucion1

Si te fijas, esa “otra cosa diferente” puede ser otra decisión, nada te lo prohíbe 😉

5.4.solucion4

A mi me resulta muy útil hacer éste tipo de dibujos, sobretodo con casuísticas muy complicadas ya que se puede ver de un simple vistazo cual es el razonamiento detrás de tu código y, es más, no importa en que lenguaje lo vayas a programar porque el razonamiento será el mismo.

Siempre que tengas dudas, te recomiendo que cojas pepel y boli (y a tu amigo Google) y te pongas a pensar en “Que tengo que hacer” y una vez claro “Como lo hago”. Si el esquema que dibujas tiene sentido entonces, y sólo entonces, estás listo para empezar a programar.

Veamos el código final:

5.5.solucion5

Como puedes ver he incrementado el array en un posición para que pueda usar billetes de 100 pues en el ejercicio de ejemplo no habían.

Espero haberme sabido explicar, si te baila algún concepto dame un toque en los comentarios que te aclaro lo que haga falta.

Bien, ¿hemos terminado? ¡¡¡NO!!! Porque como siempre voy a aprovechar para dejarlo todo un poco más bonito 🙂

2. Contenido del capítulo

Déjame dar un pequeño vistazo al contenido de éste capítulo antes de seguir, vamos a ver lo siguiente:

  • Operadores lógicos con otros tipos de datos
    • =
    • !=
    • >
    • <
  • Introducción a la programación orientada a objetos
    • ¿Que es un objeto?
    • Atributos
    • Métodos
  • Resolución de un ejercicio de ejemplo
  • Resumen
  • Enunciado del ejercicio para la próxima entrada.

La verdad es que en éste capítulo quería dejar el “aburrido” mundo del código y empezar a ver cosicas más curiosas como ventanitas, botones y otras cosas gráficas pero creo que aún no estamos preparados. Bueno, sí lo estamos pero lo veríamos muy a medias y no quiero liaros, creo que me sabréis perdonar si os prometo si o sí que en la próxima sesión tocaremos el tema de los Windows Forms que son más divertidos.

En serio, si te estás cansando de ésto solo te pido un pequeño esfuerzo más, seguro que la próxima sesión te parece mucho más divertida… casi casi como Breaking Bad, que el primer capítulo es raro, el segundo te planteas dejar la serie pero después del tercero te tragas las 5 temporadas y te masturbas pensando en Brian Cranson, la meta azul y la bendita madre que parió a los guionistas. Un 10 para ellos.

Lo dicho, si dejas de lado éste curso que por lo menos sea para ver Breaking Bad :p

3. Operadores lógicos con otros tipos de datos

Te he enseñado lo que son los números booleanos, como se opera con ellos, etc. Lo cierto es que también se puede operar con otros tipos de datos mediante operadores lógicos. Ya hemos visto algunos de ellos que nos son más conocidos en nuestro día a día como la suma y la resta, pero los que vamos a ver ahora entran en el campo de las comparaciones.

3.1 =

Éste es el operador de igualdad, que devuelve cierto o falso. Por ejemplo:

5.6.comparador1

En C# una operación de igualdad se hace con dos signos de igual seguidos (los paréntesis son opcionales, los he puesto para que quede más claro) y como se puede ver “no_son_iguales” valdrá falso mientras que “son_iguales” valdrá cierto. ¿Por que? Porque los operadores de comparación retornan booleanos, ese es el motivo por el que los podemos usar en los condicionales.

3.2 !=

A éste operador se le conoce como desigualdad, y viene a ser el contrario que el anterior. Básicamente sirve para mirar si algo es diferente a otra cosa.

5.8.comparador3

Aquí se puede ver que los dos booleanos son ciertos.

3.3 >

El operador de “mayor que” se representa con éste tipo de símbolo, si te fijas la parte más abierta apunta al elemento que queremos ver si es mayor. En C# se usa así:

5.7.comparador2

En nuestro caso, numero1 no es mayor que numero2, pero numero2 si es mayor que numero3. Como bonus remarcar que numero1 no es mayor que numero3, son iguales, que no es lo mismo 😉

3.4 <

El operador “menor que” funciona a la inversa que el anterior, me ahorro el ejemplo porque es exactamente lo mismo pero dándole la vuelta.

¡Ah! Y funciona también con floats, strings, etc…

Vale, visto esto, ¿como lo podemos usar para mejorar nuestro ejercicio anterior? Pues si te fijas, en el primer ejercicio un booleano nos iba bien porque teníamos 2 palancas, ya que un booleano solo tiene 2 valores: cierto o falso.

Ahora que tenemos 3 palancas, parece que nos iría mejor usar otro tipo de elemento como por ejemplo un número entero. Podríamos hacerlo así:

5.9.mejora_ejercicio1

¿Ves? Usando un entero conseguimos lo mismo y nos ahorramos el segundo booleano. En éste caso uso el valor del entero para determinar que camino seguirá la ejecución del código.

Aún se puede mejorar más, pero antes fíjate en una cosa: el diagrama de flujo no ha cambiado, pero sí el código. Eso significa que existen muchas maneras de llevar a cabo una idea, y también existen diferentes ideas para llevar a cabo una tarea.

Para mejorar esto un poco más necesito explicarte otra cosa sobre los condicionales. Hemos visto el “SI” y el “SINO”, es decir, el “if” y el “else”, pero también existe el “SINO SI” o “else if” lo cual nos permite comprimir un poco el código, veamos:

5.10.mejora_ejercicio2

De ésta forma nos ahorramos un condicional dentro de otro condicional, cosa que os recomiendo evitar porque puede resultar en un puto lío de cojones, sobretodo cuando sobrepasa los dos niveles.

No creo que haga falta explicar mucho más el código, básicamente hacemos “SI es la palanca derecha ENTONCES hacemos la derecha. SINO SI es la palanca izquierda ENTONCES hacemos la palanca izquierda. SINO hacemos la palanca central” (pongo mayúsculas para que se noten bien los condicionales).

Y aún se podría hacer alguna cosilla más, pero lo vamos a dejar aquí que no te quiero liar más la cabeza.

4. Introducción a la programación orientada a objetos

C# es un leguaje de programación orientado a objetos, lo cual dicho de una forma sencilla significa que podemos crear nuestros propios componentes, usar los de otros, extenderlos, etc. facilitando mucho la comprensión del código y dotándolo de gran potencia y versatilidad.

4.1. ¿Que es un objeto?

Un objeto no es más que la encapsulación de un conjunto de elementos, dicho de otro modo, es coger un grupo de variables y meterlas dentro de una caja. Lo vas a ver super claro si recuperamos el ejemplo de las palancas.

En el ejemplo de las palancas tenemos un array que hemos usado para guardar nuestro dinerito, y un código que determina que tipo de acción se ejecuta en función de las palancas de las que se estira. Esto que nosotros hemos programado directamente sobre el código del formulario lo podemos encapsular en un objeto, al que podemos llamar, por ejemplo, “Fabrica”. En C# los objetos se definen mediante “clases” y siguien la siguiente nomenclatura:

5.11.clases1

Esto le dice a C# que vamos a crear un nuevo objeto que se llamará fábrica.

Vamos a crear nuestro primer objeto y para ello vamos a crear un nuevo fichero. No es obligatorio meter las clases en ficheros separados pero si muy recomendable ya que facilita su mantenimiento. Veamos como se hace:

5.12.clases2

Se hace clic con el botón derecho sobre el proyecto, se selecciona “agregar” y se escoge la “clase”.

5.12.clases3

Donde pone nombre le vamos a poner “Fabrica.cs”, donde “Fabrica” es el nombre y  “cs” la extensión de una clase C#. Cuando le des a agregar verás que te abre tu nueva y flamante clase:

5.13.clase4

Vale, ahora tenemos nuestra clase vacía, aún no hace nada pero oye, por lo menos hemos visto como se crean. Es fácil ¿no?.

4.1. Atributos

Los atributos son los campos que tiene nuestra clase, por ejemplo si nuestra clase fuera un Coche, los atributos podrían ser “color”, “caballos”, “velocidad máxima”, etc. Si nuestra clase fuera “Persona” los atributos podrían ser “edad”, “sexo”, “altura”, etc.

Como nuestra clase es la “Fabrica” del ejercicio anterior lo que vamos a poner como atributos son los dineritos que genera, que en lugar de meterlos en un array los vamos a poner en sus propios campos:

5.14.clase5

Vamos a fijarnos en varias cosas. Para empezar el nombre de la clase está en mayúsculas, eso no es estrictamente obligatorio pero se ha adoptado por convenio que es mejor hacerlo así. Si te preguntas por que verás que los atributos de la clase “billete50”, “billete100”, “billete200”, “billete500” empiezan por minúsculas, también va por convenio y es precisamente para distinguirlos rápidamente de las clases. Si empieza por mayúscula: clase; si empieza por minúscula: atributo o variable.

Vale, yo he creado 4 atributos y usaré cada uno de ellos para almacenar el número de billetes que voy generando, la palabra “public” que aparece delante de cada atributo sirve para indicar que éste atributo es público y se puede ver desde fuera de la clase… es un concepto que veremos más adelante así que no le des más vueltas por ahora que no quiero que te me pierdas.

4.2. Métodos

Esta parte es un poco más complicada así que voy a intentar simplificarla al máximo.

Los métodos son las acciones que puede realizar un objeto, por usar los mismos ejemplos de antes con una clase “Coche” un método podría ser “Acelerar”, “Frenar”, “Girar”, etc. Con una “Persona” los métodos podrían ser “Correr”, “Hablar”, “Cagar”, etc.

En el ejemplo que nos ocupa los métodos podrían ser simplemente “PalancaDerecha”, “PalancaIzquierda”, “PalancaCentral”, veamos:

5.15.clase6

4.2.1. Acciones

Como puedes ver, un método se declara con un indicador de “public” (más adelante veremos que quiere decir y que otros tipos existen), “void” (que también veremos más adelante que quiere decir), el nombre del método que también empieza por mayúsculas por convenio, unos paréntesis y unas llaves que marcan el inicio y el final del método.

¿Y para que sirven los métodos? Pues para definir comportamientos. Vamos a meter el código de las palancas del ejercicio anterior dentro de cada método y los vamos a adaptar a los atributos que tenemos definidos:

5.16.clase7

Lo que hemos hecho es encapsular el comportamiento de las palancas dentro de un objeto llamado “Fábrica” que tiene 3 métodos, uno por palanca. Además cada palanca realiza su función modificando apropiadamente los atributos de “Fabrica”.

El “void” que vemos por ahí indica que nuestro método no retorna ningún valor, simplemente realiza una acción y por ello se le conoce como “acción”. Las “funciones” en cambio son algo diferentes y enseguida verás la diferencia.

4.2.2. Funciones

Voy a crear un nuevo método que calcule el total de pasta que tiene Fabrica.

5.17.clase8

Fíjate que ya no aparece el “void” sino el tipo de dato “int”, esto quiere decir que el método devuelve un dato de tipo entero. Si te fijas lo que he hecho es calcular el total de dinero que tiene la fabrica y retornalo, la cláusula return es la que envía el resultado de la función hacia fuera.

Como el valor que he calculado es un número entero lo puedo devolver mediante “return”, si hubiera sido de otro tipo tendría que haber cambiado el tipo de retorno o el Visual Studio me lo habría subrayado en rojo.

4.2.3 Contructor

Existen excepciones, pero normalmente los objetos necesitan instanciarse para poderse usar. Cuando un objeto se instancia se le dice al programa que lo queremos crear y que debe reservar espacio en memoria para poder usarlo, es como decirle a la familia en navidades que haga sitio en la mesa porque vamos a sacar el trivial.

Para que una clase se pueda instanciar necesita un constructor, un contructor es un método un poco especial:

5.18.clase9

Se parece mucho a los métodos pero no tiene tipo de retorno, ni “void”, ni “int”, ni “string” ni nada de nada. Además el nombre del método es el nombre de la clase.

Lo que se suele hacer dentro de los constructores es dar un valor iniciar a sus atributos, como nosotros tenemos atributos de tipo “int” los vamos a poner a cero que es como estaría la fábrica el primer día de apertura:

5.19.clase10

Seguro que ahora te parece un mundo, pero te aseguro que cuando hayas hecho un par lo verás super fácil. Tú tranquilo que voy a poner algunos ejemplos muy fáciles de pillar que te ayudarán a atar cabos, si no los ves claro aún no te preocupes y sigue leyendo 🙂

Vale, ya hemos visto como se crea la clase, sus atributos y sus métodos. Ahora nos queda ver como se usa.

Lo primer que tenemos que hacer es instanciar nuestro nuevo y flamante objeto “Fabrica”, nos vamos a ir al código fuente de “Form1.cs” (si lo has cerrado recuerda que puedes entrar haciendo clic con el botón derecho sobre “Form1.cs” en el “Explorador de soluciones” y seleccionar código fuente. Si también has cerrado el “Explorador de soluciones” recuerda que lo puedes abrir fácilmente desde el menú “Ver” y después “Explorador de soluciones” o pulsando “Ctrl + Alt + L”.

Ahora que estamos en “Form1.cs” vamos a instanciar nuestra clase de la siguiente manera:

5.20.clase11

Con “Fabrica f” hemos creado una nueva variable llamada “f” y que es de tipo “Fabrica”, de la misma forma que hemos hecho tantas veces con enteros y booleanos. Con “= new Fabrica()”  le hemos dicho a nuestro programa que debe reservar espacio en memoria para ella.

Vamos a ver como se comporta esto, vamos a poner un breakpoint sobre ésta línea y otra dentro del contrustor de Fabrica:

5.21.clase12    5.22.clase13

Ahora vamos a ejecutar nuestro programa línea a línea y verás como, cuando llegue el momento de crear el nuevo objeto se mete dentro de la constructora e inicializa los atributos a cero.

Vamos ahora a realizar una llamada a cada uno de sus métodos de la siguiente manera:

5.23.clase14

Cuando lo estés programando verás que, cuando escribes la variable “f” y le das al punto te despliega todo el listado de métodos y atributos de la clase que has definido. Esto se conoce como “Intellisense” y es la ayuda que nos proporciona Visual Studio para trabajar con objetos, es muy útil para saber que hace un objeto que no has hecho tú ya que puedes mirar que propiedades y métodos tiene y te puede dar una muy buena idea de por donde van los tiros.

Lo que hemos hecho es invocar a sus métodos palanca e ir grabando el valor en total, si debugas te será fácil ver como la cosa funciona como una seda. De hecho te invito a que inspecciones el objeto Fabrica y veas sus tripas en plena ejecución. Para hacerlo por un breakpoint allá donde quieras parar e inicia la ejecución:

5.24.clase15

Si haces clic con el botón derecho sobre la variable f y seleccionas “Insepcción rápida” abrirás el inspector de objetos con el que podrás ver cómodamente cuanto valen los atributos de nuestra clase “Fabrica”:

5.25.clase16

Te invito a que juguetees un rato con esto y vayas viendo los cambios que se producen, también puedes seleccionar “Agregar inspección” en lugar de abrir la “Inspección rápida” si quieres ir viendo como cambian los valores en tiempo real (acuérdate de tocar el pin al lado de la X cuando se abra el panel de inspección, sino se esconderá solo).

5.25.clase17

5. Resolución de un ejercicio de ejemplo

¡Buf! ¿Cuanta información de golpe verdad? Tranquilo que esto es más fácil de lo que parece y para demostrarlo te voy a poner un ejemplo muy sencillo. Después de todo quieres ver ventanas en la próxima sesión… ¿o no? Pues si quieres ver ventanas me temo que primero te has de comer todo este rollo 😉

Empecemos por el enunciado:

Haz una puta calculadora

Jajajaja, perdona, no lo he podido evitar. Creo que hacía rato que no soltaba algún taco y me quemaba la boca… en fin, que vamos a hacer una calculadora muy muy simple. Lo que tiene que hacer nuestra calculadora es lo siguiente:

  • Tener un campo donde se almacena el total, inicialmente vale cero.
  • Sumar un número decimal al total.
  • Restar un número decimal al total.
  • Multiplicar un número decimal al total.
  • Dividir el total por un número decimal.
  • Pedir el total acumulado.
  • Resetear el total a cero.

Vale, como he prometido es una calculadora muy sencillita. Vamos a comenzar creando una nueva clase a la que llamaremos “Calculadora.cs”.

5.26.calc.1

 

Existen una serie de trucos para deducir la forma de montar un objeto. Seguramente llegado a éste punto estés un poco perdido sobre como continuar y es totalmente normal, no te preocupes que el tito Fher te va a contar un secreto y es que existe una forma de, dado un enunciado, deducir por donde van los tiros.

El primero es el más simple: los sustantivos equivalen a objetos, es decir, los nombres son clases. Por ejemplo: el enunciado habla de una calculadora, así que ahí tenemos una clase.
El segundo es muy sencillo también, las acciones o verbos son métodos. En el ejemplo aparecen Sumar, restas, multiplicar, dividir, pedir el total y resetearlo que serán los métodos a implementar.
Por último, los adjetivos siempre hacen referencia a una propiedad, por ejemplo: “una persona es alta” nos daría dos pistas, necesitamos una clase “persona” con un atributo “altura”.  En éste ejemplo no se ve muy claro pero creo que es bastante evidente que el “total” es un campo de la calculadora y por tanto un atributo.

Obviamente esto no es una regla a seguir a pies juntillas, pero si la tienes en mente y la adornas con un poco de sentido común creo que te puede ser de gran utilidad. Y no te preocupes si alguna cosa no te queda del todo atada, recuerda que existen muchas formas de resolver los problemas y muchas veces la mejor solución se presenta sobre la marcha. Coge papel y boli, empieza a hacer esquemas y, cuando tengas clara la idea tírate a programar que los detallitos ya los irás puliendo.

Dicho esto vamos a definir las propiedades y métodos de nuestra calculadora:

5.27.calc.2

Fíjate que el atributo “total” lo he declarado como privado, no te preocupes que más adelante te explicaré la diferencia. Además todos los métodos toman de entrada parámetros float que nos permite el uso de decimales tal y como exige el enunciado. Por último date cuenta que el atributo “total” y el método “Total” no son iguales porque C# es “case-sensitive”, es decir, distingue mayúsculas de minúsculas. Por cierto, “Total” aparece marcado en rojo porque debe retornar un “float” y ahora mismo no lo hace porque no la he programado.

Date cuenta que Sumar, Restar, Multiplicar, Dividir y Reset son acciones. No retornan ningún valor y lo único que hacen es realizar acciones matemáicas sobre “total”. El método “Total” en cambio es una función que no toma parámetros de entrada pero si que nos da un float como salida.

Ahora vamos a programar los métodos tal y como nos pide el enunciado, creo que con lo que hemos visto hasta ahora te será fácil entender lo que hago. Como siempre, si no es así déjame un comentario y te aclaro cualquier duda sobre el tema.


5.28.calc.3

Tenemos el constructor (el primer método que se llama como la clase) que setea el atributo”total” a cero y el resto de métodos que hacen lo que nos pide el enunciado. Ya hemos terminado el ejercicio, ¿fácil no?.

Vamos a probar un poco nuestra nueva clase volviendo al código de “Form1”, instanciando nuestra clase y usando sus métodos a ver que hace. Yo te propongo el siguiente código pero puedes hacer lo que te de la gana, al fin y al cabo en tu ordenador la has programado tu 🙂

5.29.calc.4

Si lo debugas podrás ir viendo como va cambiando el valor que guarda nuestra calculadora, te invito a jugar con el código un rato para acabar de pillarle el truco… por cierto, ¿recuerdas aquello que nos decían en clase de mates sobre dividir un número entre cero? Te invito a probarlo pero no explicaré como controlar ese tipo de situaciones hasta más adelante 😉

Por cierto, ¿has mirado detenidamente el listado de métodos y atributos de “Calculadora” que nos lanza intellisense cuando escribimos “calc” y le damos al punto?

5.30.intellisense

Hay métodos que nosotros no hemos programado como Equals, GetHashCode o GetType que aparecen porque son heredados de Object. Todas las clases que programes heredarán automáticamente de un objeto de .NET llamado Object… no te preocupes por la herencia que la veremos más adelante. Lo que quiero que busques es el atributo “total”… no sale, ¿a que no? Eso es porque es privado.

Los métodos y atributos privados se pueden usar dentro de la clase pero no se pueden ver desde fuera. Por eso cuando programas en “Calculadora” puedes ver a “total” pero cuando usas el objeto “Calculadora” desde “Form1” no lo ves. Es una forma de proteger las partes sensibles del código que un programador manazas no debería tocar.

Por ejemplo, a nuestra amiga Cloe le gusta nuestra calculadora y la quiere usar, con los métodos públicos le estás dando una forma segura de usar la calculadora porque le das métodos que has probado y sabes que funcionan. En cambio no le das acceso al atributo total porque lo podría tocar sin quierer y cambiar los resultados de las operaciones, en cuyo caso no podrías garantizar el correcto funcionamiento de la calculadora.

6. Resumen

Bueno bueno bueno, hoy hemos visto muchas cosas nuevas. Unas más bonitas, otras más difíciles pero todas ellas igual de importantes.

Tenemos por un lado los objetos, que programamos mediante clases y nos permiten agrupar funcionalidades. Los objetos a su vez tienen atributos (públicos y privados) y métodos (acciones y funciones públicas o privadas).

La idea de usar objetos es organizar nuestro código por “temáticas”, creando piezas del puzzle que después podemos usar cómodamente para resolver un problema mayor.

7. Enunciado del ejercicio para la próxima entrada

“Te piden desarrollar un sistema de seguridad muy sencillo para un ascensor. El ascensor tiene un número máxima de pasajeros permitido y tu sistema debe permitir lo siguiente:”

  • Establecer el límite de pasajeros permitido.
  • Llevar la cuenta de los pasajeros que entran.
  • Llevar la cuenta de los pasajeros que salen.
  • Consultar si se ha sobrepasado el límite.

Pistas:

Se parece mucho a la calculadora pero más sencillo. Trata de identificar las clases (aunque solo necesitas programar una), los atributos (hay uno) y los métodos necesarios (5 si contamos el constructor, pero se puede hacer con 4).