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

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s