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!

Anuncios

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).