POO VS Programación Estructurada (Código Espagueti)

La programación orientada a objetos es un paradigma de la programación imperativa, puedes

averiguar más del método imperativo en este enlace. Pero existen más paradigmas de
programación, está el método estructurado que lo vamos a ver ahora y el anti-método, por
llamarlo de alguna manera, como código espagueti.

El código espagueti me enreda

Por eso se le denomina de forma despectiva el programar con este “estilo” o método. Realmente
es una forma de decir que tu código no es ordenado, no es depurable, no es escalable, etc etc.

Un ejemplo muy sencillo es cuando abusamos de los ifs anidados o los while. Por ejemplo, si
queremos evaluar una condición lo normal es usar el if, el problema viene cuando nos damos
cuenta de que no sólo vamos a tener una condición, sino muchas…

¿Y cómo se puede evitar anidar los if-elseif-else? Bueno, hay muchas formas, pero dentro del
espagueti lo puedes solucionar cambiándolos por un switch-case. Parece una tontería y puedes
rebatirme diciéndome que ambos funcionan igual. Te daré la razón en lo último, hacen lo mismo,
pero el cambiarlo a un switch hará que tu código sea más fácil de entender y a la postre más fácil
de editar/mejorar/corregir.

Programar al estilo espagueti no es malo cuando lo vas cambiando por otro paradigma o te vas
iniciando en la programación. El problema es que lo hagas en plan fideos y no lo cambies.
 Programación Estructurada (vamos mejorando)

La programación estructurada es un paradigma basado en el imperativo. Esto es algo obvio porque

le estamos diciendo a la máquina haz esto y haz esto otro y no me repliques.

Si comparamos el método espagueti con el estructurado es como si comparásemos la noche y el

día, no tienen nada que ver.

La programación estructurada se basa en funciones y está muy ligada a la programación antigua

donde no se generaban objetos. Hoy por hoy cualquier lenguaje de ahora permite programación
orientada a objetos y la estructurada está dejándose de usar (por supuesto esto no es aplicable a
todos los lenguajes).

En el siguiente ejemplo genero un fragmento de código donde creamos a dos perritos. Para crear a
los perritos necesito variables que serán matrices o arreglos con sus propieades. Como ves
necesito crear tantas matrices como perritos quiero mostrar y por último creo una función para
pasarlos por la pantalla.
1.
2. # Creamos primero una matriz o arreglo donde generamos una variable con la t
abla de datos
3. $dog1 = array(
4. 'name'=> 'Boby',
5. 'legs'=> 4,
6. 'hair'=> 'cortito',
7. 'years'=> 10
8. );
9.
10. # Creamos luego otra matriz o arreglo donde generamos una variable con la ta
bla de datos
11. $dog2 = array(
12. 'name'=> 'Frodo',
13. 'legs'=> 4,
14. 'hair'=> 'largo',
15. 'years'=> 5
16. );
17.
18. # Creamos tantas matrices como "perritos" necesitamos duplicando, triplicand
o, quintuplicando por ejemplo las propiedades del array
19.
20. # Generamos una función que muestre las propieades de la matriz de datos
21. function showDog($dog) {
22. echo "Mi nombre es ". $dog[name] . ", tengo " .$dog[years] ." anyos de e
dad y tengo el pelo " .$dog[hair] . "<br>";
23. }
24.
25. # Llamamos a la función y a la variable/matriz en cuestión para mostrar los
resultados en pantalla
26. showDog($dog1);
27. showDog($dog2);
28. ?>

POO: el objeto lo es todo

En la programación orientada a objetos la propia definición te dice el cómo programar: definiendo

una clase que se comportará literalmente como un objeto de la vida cotidiada.

Puedes crear una clase que se llame Perro (Dog en inglés) y que tenga una serie de propiedades
tales como las tendríamos en el mundo real: nombre, patas, pelo, años, etc. Estas propieades
también se definieron en el ejemplo anterior, pero no están ligadas de algún modo a ningún
objeto, sino que son del array que creamos.

Realmente cada matriz del ejemplo anterior es independiente el uno del otro. Pero con la clase
Perro podemos crear unas propieades que sean iguales a cada objeto que creamos.

En el siguiente ejemplo muestro lo mismo que en el anterior pero creando el objeto. Primero
creamos una clase llamada Dog. Esta clase tendrá unas propiedades y por último un método para
llamar al perro.
1. <?php
2.
3. # Una clase es un objeto abstracto con una serie de propiedades
4. # 1 - Encapsulación: reune al mismo nivel de abstracción todos los elementos
de una misma entidad (clase)
5. # 2 - Herencia: es la relación entre dos o más clases donde una es la princi
pal (padre) y el resto hijas
6. # 3 - Polimorfismo: posibilidad que tiene cada objeto de tener métodos, prop
iedades y atributos
7. # 4 - Abstracción: aisla el elemento en su contxto y define sus característi
cas esenciales
8.
9. Class Dog {
10.
11. # Propiedades: son las características que pueden tener un objeto
12. private $legs;
13. private $hair;
14. private $name;
15. private $years;
16.
17. # Método: son las funciones internas de la clase
18. # __construct lo que hace es generar un nuevo objeto de la clase
19. public function __construct($name, $legs, $hair, $years) {
20. $this->name = $name;
21. $this->legs = $legs;
22. $this->hair = $hair;
23. $this->years = $years;
24. }
25.
26. # Método llamar al perrito, es otra función de la clase
27. public function showDog() {
28. echo "Mi nombre es $this->name, tengo $this->years anyos de edad y t
engo el pelo $this->hair<br/>";
29. }
30. }
31.
32. # Creación e instanciación de un objeto nuevo llamado $dog1
33. $dog1 = New Dog("Boby", 4, "cortito", 10);
34. $dog2 = New Dog("Frodo", 4, "largo", 5);
35. # Llamada al método $showDog del objeto #dog1 de la clase Dog()
36. $dog1->showDog();
37. $dog2->showDog();
38.
39. ?>

Si os fijáis sólo creamos las propieades una vez, no varias. Comparten un método en común, que
pertenece a la clase que se llama showDog() y para acabar creamos dos objetos nuevos: $dog1 y
$dog2. Estos ya no son variables, son objetos que pertenecen a una clase y la cual instanciamos
para darles “valor”.
Ambos métodos hacen lo mismo pero la diferencia de la programación orientada a objetos es que:

Proporciona una capa de seguridad que no la hace la estructurada

Permite mantener el código de forma más limpia

Trata a los elementos como objetos facilitando no repetir código