Guía para entender el paradigma de POO.
JavaScript - El paradigma de POO
En el paradigma de la Programación Orientada a Objetos (POO o OOP en sus siglas en inglés) existen los principios o reglas SOLID los cuales son una serie de normas que guían la forma en la que diseñamos nuestros sistemas. Aplicando dichos principios podemos encontrar los objetivos.
Un punto importante para poder comprender los principios de SOLID es necesario comprender el paradigma de POO, tomando lo anterior en cuenta la pregunta que tenemos que hacernos es.
🤔, Pero ¿Qué rayos es POO?
Es un paradigma de programación que utiliza la abstracción para crear modelos de objetos basados en el mundo real. Aplicando este paradigma podemos conseguir desarrollos más robustos y organizados además de conseguir beneficios tales como.
El paradigma de POO es considerado como el diseño de Software a través de conjuntos que cooperan entre sí, lo cual es muy diferente al antiguo paradigma de programación estructurada.
Muy interesante… si POO se basa en objetos la pregunta que tenemos que hacernos es.
🔖 Nota: Todos los ejemplos de código utilizados están basados en JavaScript usando las especificaciones más actuales hasta el momento.
🤔, Pero ¿Cómo logro pensar en Objetos?
Pensar en objetos es muy sencillo ya que es muy parecido a cómo lo haríamos en la vida real. Por ejemplo, imaginemos un Pokémon el cual, para poder pasarlo a un modelo de POO, diríamos que el elemento principal (también conocido como clase) es Pokémon, tomando esto en cuenta podemos realizarnos las siguientes preguntas.
🤔 ¿Qué propiedades tiene un Pokémon?
Todas las propiedades y características de un Pokémon se conocen como atributos los cuales cuentan con un identificador (nombre de la propiedad) y un tipo (conocido como tipo de dato).
🤔 ¿Qué capacidades tiene un Pokémon?
Todas las capacidades que definan el posible comportamiento de nuestro Pokémon se conocen como métodos los cuales pueden modificar a los atributos o llamar a otros métodos.
🔖 Nota: Por cuestiones de practicidad solo tomaremos algunas de las capacidades y propiedades de un Pokémon.
🤔, Pero ¿Que rayos es una Clase?
Funciona como un molde que nos permite crear objetos individuales en este caso del tipo Pokémon permitiendo así definir los atributos y métodos que describen su comportamiento y estados.
¡Genial! Poco a poco esto toma forma… ¡Ey! un momento falta realizarnos una pregunta la cual es.
🤔 ¿Entonces qué es un Objeto en POO?
Es la representación abstracta de cualquier elemento de la vida real; mediante un componente de Software por lo que un objeto es una instancia de una clase.
🔖 Nota: Se conoce como instancia a todo objeto que derive de otro. De esta forma todos los objetos son instancias menos la Clase padre que es el origen.
¡Genial! ya conocemos algunos conceptos base del paradigma de POO es momento de aplicar lo aprendió y convertirlo en código, ¡Manos a la obra!
| /* | |
| Para definir una clase en JavaScript se utiliza | |
| la palabra reservada "class" seguida del nombre | |
| de la clase a crear, Como buena práctica el nombre | |
| de la clase inicia con mayúsculas y tenga el estilo | |
| "CanelCase". | |
| */ | |
| class Pokemon { | |
| /* | |
| Listado de atributos, como podemos apreciar | |
| se utiliza la sintaxis. | |
| [Identificador] = [tipo de dato]; | |
| */ | |
| name = ""; | |
| type = "" | |
| evolutions = []; | |
| /* | |
| Toda "clase" consta del método constructor el cual | |
| es llamado al momento de crear una instancia de la "clase", | |
| es utilizado para establecer las propiedades o llamar | |
| métodos que preparen al objeto para su uso, Este método | |
| es opcional, por ejemplo, en los casos que no sea necesario | |
| iniciar o llamar a otros métodos. | |
| 🔖 Nota: Al igual que cualquier funcion puede recibir parametros. | |
| */ | |
| constructor(name, type, evolutions) { | |
| /* | |
| Se utiliza "this" para hacer referencia al propietario | |
| de la función que la está invocando o en su defecto, al | |
| objeto donde dicha función es un método. | |
| */ | |
| this.name = name; | |
| this.type = type; | |
| this.evolutions = evolutions; | |
| } | |
| /* | |
| Listado de los mêtodos de la clase, dichos metodos constan | |
| de logica propia de la clase. | |
| */ | |
| attack() { | |
| // mostramos un mensaje se utuliza ` para poder | |
| // utilizar literalString. | |
| return `${this.name}, esta atacando`; | |
| } | |
| evolve(evolution = 0) { | |
| // Validamos que la opción exista | |
| const EVOLVE = this.evolutions[evolution] || ""; | |
| let message = "No puedo evolucionar"; | |
| // Si EVOLVE es diferente a "" cambiamos el nombre | |
| // del pokemon y mostramos un mensaje indicando la | |
| // evolución. | |
| if (EVOLVE) { | |
| message = `${this.name} esta evolucionando a ${EVOLVE}`; | |
| this.name = EVOLVE; | |
| } | |
| // mostramos un mensaje | |
| return message; | |
| } | |
| } | |
| // Creamos las instancias mostradas en el diagrama | |
| // Creando instancia para charmander | |
| const Charmander = new Pokemon("Charmander", "Fire", ["Charmeleon", "Charizar"]); | |
| // Creando instancia para Squirtle | |
| const Squirtle = new Pokemon("Squirtle", "Water", ["Wartortle", "Blastoise"]); | |
| /* | |
| Para llamar a un atributo o metodo de la cual quiera de las | |
| instancias creadas, se utilizan la sintaxis. | |
| [Nombre de la instancia].[Nombre del método](); | |
| [Nombre de la instancia].[Nombre del atributo]; | |
| */ | |
| // Charmander | |
| console.log(`${Charmander.name} es de tipo ${Charmander.type}`); | |
| console.log(Charmander.attack()); | |
| console.log(Charmander.evolve(0)); | |
| // output Charmander | |
| // Charmander es de tipo Fire | |
| // Charmander, esta atacando | |
| // Charmander esta evolucionando a Charmeleon | |
| // Squirtle | |
| console.log(`${Squirtle.name} es de tipo ${Squirtle.type}`); | |
| console.log(Squirtle.attack()); | |
| console.log(Squirtle.evolve(0)); | |
| // output Squirtle | |
| // Squirtle es de tipo Water | |
| // Squirtle, esta atacando | |
| // Squirtle esta evolucionando a Wartortle |
¡Genial! hasta este punto ya generamos nuestra primera Clase aplicando los conceptos básicos del paradigma de POO, el código generado está basado en los diagramas utilizados.
Si quiere aprender un poco más sobre el uso de clase en JavaScript te recomiendo leer el siguiente POST.
Medium
Conclusiones
Aprendimos los conceptos base del paradigma de POO y los beneficios que podemos obtener cuando se aplica en nuestros desarrollos, es importante saber que gracias a las nuevas características de JavaScript podemos utilizar dicho paradigma.
Iniciamos el camino para poder entender los cinco principios de SOLID, pero antes de poder pasar al tema tenemos que conocer los cuatro principios que le dan sentido a POO, este tema lo expondremos en el siguiente Articulo.
Top comments (0)