Skip to first unread message
Oswaldo Hernández
Mar 9, 2016, 10:22:23 PM3/9/16
to UptosPNFI
PROGRAMACIÓN ORIENTADA A OBJETOS PARA PHP5
"Aprende de forma simple y definitiva POO para PHP5,
deja de ser Programador de Páginas Dinámicas y
empieza a convertirte en Desarrollador de Sistemas"
por Enrique Place
Contenido
Introducción: ............................................................................................................................................... 21
”Los Desarrolladores PHP debemos Profesionalizarnos” ........................................................................... 21
Esta reflexión se la escribo a todos los "Programadores PHP" ............................................................... 21
Enfrentar la realidad con madurez ......................................................................................................... 21
Mi experiencia personal .......................................................................................................................... 22
La culpa es enteramente nuestra ........................................................................................................... 23
Debemos pasar de los dichos a los hechos ............................................................................................. 24
Capitulo 1 - "Nuestros Principios como Desarrolladores" .......................................................................... 25
Principio 1: RTFM - "Lee el Maldito Manual" .......................................................................................... 27
Principio 2: DRY - "No Te Repitas" .......................................................................................................... 27
Principio 3: KISS - "Mantenlo Simple, Estúpido!" ................................................................................... 27
Principio 4: Estándar de Codificación PHP / Zend ................................................................................... 27
Capitulo 2 - “Introducción a los Objetos” ................................................................................................... 29
“Vacuidad: vaciar todos los conocimientos” .......................................................................................... 31
“La sencillez es la mejor arquitectura “ .................................................................................................. 31
“Lo más importante es detectar los objetos” ......................................................................................... 32
En resumen ............................................................................................................................................. 32
Capítulo 3 - “Cómo Pensar en Objetos” ...................................................................................................... 34
“Lo menos importante es el código” ...................................................................................................... 36
“Un niño pequeño” ................................................................................................................................. 36
“El medio de comunicación” ................................................................................................................... 37
Capítulo 4 - “POO según LOS MANUALES” ................................................................................................. 38
“La POO según Wikipedia” ...................................................................................................................... 39
“POO según el manual Oficial de PHP” ................................................................................................... 42
Capítulo 5 - “Empezar a plasmar los objetos en un diseNo” ...................................................................... 44
“Cómo representar la estructura de los objetos” .................................................................................. 46
En Resumen ............................................................................................................................................ 51
Capítulo 6 - “Introducción a UML” .............................................................................................................. 53
“UML, el medio y no el fin en sí mismo” ................................................................................................. 55
“UML y el público objetivo” .................................................................................................................... 55
“UML es independiente del lenguaje” .................................................................................................... 56
En resumen ............................................................................................................................................. 57
Capítulo 7 - “Cómo representar una clase en UML” ................................................................................... 58
“Conceptos Generales” ........................................................................................................................... 60
Mi primer diagrama UML ........................................................................................................................ 60
Cómo se traduce en código .................................................................................................................... 62
Sección #1 – nombre de la clase ......................................................................................................... 62
Sección #2 – los atributos de la clase .................................................................................................. 62
Sección #3 – los métodos de la clase .................................................................................................. 64
“El Constructor” ...................................................................................................................................... 64
Probando el objeto en un contexto determinado .................................................................................. 66
En Resumen ............................................................................................................................................ 67
Capítulo 8 - Ejercicio "Micaela y el Perro" .................................................................................................. 68
Requerimientos ....................................................................................................................................... 70
Solución ................................................................................................................................................... 71
Aplicación del “Principio KISS” ................................................................................................................ 72
Sugerencias para enfrentar los diseños .................................................................................................. 72
Propuesta de Diseño 1 ............................................................................................................................ 73
Diagrama UML .................................................................................................................................... 73
Traducción de UML a PHP ................................................................................................................... 74
Propuesta de Diseño 2 ............................................................................................................................ 76
Cambios ............................................................................................................................................... 76
Diagrama UML .................................................................................................................................... 76
Traducción UML a PHP ........................................................................................................................ 77
En Resumen ............................................................................................................................................ 79
Capítulo 9 - Los métodos "getter / setter" o "accesores / modificadores" ................................................ 80
Requerimiento 1 ..................................................................................................................................... 84
Requerimiento 4 .................................................................................................................................... 85
En Resumen ............................................................................................................................................ 88
Capítulo 10 - “Cómo representar las Relaciones entre clases en UML” ..................................................... 89
La Relación de Dependencia ................................................................................................................... 91
Representación UML ........................................................................................................................... 91
Cómo se traduce a código ................................................................................................................... 92
Caso 1 – instancio un objeto B dentro de un método de A .................................................................... 92
Caso 2 – recibo por parámetro de un método de A un objeto B ............................................................ 93
La Relación de Asociación ....................................................................................................................... 94
Representación UML ........................................................................................................................... 94
UML del ejemplo del Auto ...................................................................................................................... 96
Variaciones de Asociación: Relación de Agregación y Relación de Composición ................................... 97
Relación de Agregación ....................................................................................................................... 97
Relación de Composición .................................................................................................................... 97
Ejemplos de Agregación y de Composición ........................................................................................ 97
¿Qué relaciones se deberían evitar?....................................................................................................... 99
Ejemplo de relación cíclica .................................................................................................................. 99
Resumiendo rápidamente algunos conceptos complementarios ........................................................ 101
“Navegabilidad” ................................................................................................................................ 101
“Definición de Roles” ........................................................................................................................ 101
Resumen ............................................................................................................................................... 102
Capítulo 11 - Ejercicio "Micaela, el Perro y la Escuela” ............................................................................ 103
Requerimientos ..................................................................................................................................... 105
Solución ................................................................................................................................................. 106
“Errores Comunes” ............................................................................................................................... 107
Detalle importante a tener en cuenta con las relaciones ..................................................................... 111
El método público toString() ................................................................................................................. 113
Lo que dice el manual de toString() ..................................................................................................... 115
Agregando las relaciones que se ven desde Index ............................................................................... 116
Crear la clase Index a partir de la representación UML ........................................................................ 117
Segunda propuesta de diseño .............................................................................................................. 118
Diagrama UML .................................................................................................................................. 119
En Resumen .......................................................................................................................................... 120
Capítulo 12 - Ejercicio "La Escuela y los coches escolares" ....................................................................... 121
Requerimientos ..................................................................................................................................... 122
Guía ....................................................................................................................................................... 122
Solución ................................................................................................................................................. 123
“Errores Habituales” ............................................................................................................................ 123
“Comentarios Generales” ..................................................................................................................... 125
Navegabilidad ....................................................................................................................................... 126
Cómo deberían ser las búsquedas ........................................................................................................ 127
Diagrama UML ...................................................................................................................................... 128
Resumen ............................................................................................................................................... 129
Capítulo 13 - Ejercicio “Implementar diagrama de diseNo UML” ............................................................ 130
Requerimientos ..................................................................................................................................... 131
Solución ................................................................................................................................................. 132
¿Qué sucedería si se están usando mal las relaciones? ....................................................................... 133
Comentarios adicionales ....................................................................................................................... 134
Errores habituales ................................................................................................................................. 135
Consejos ................................................................................................................................................ 136
Diagrama UML ...................................................................................................................................... 137
Ejemplo codificado ................................................................................................................................ 138
Resumen ............................................................................................................................................... 139
Capítulo 14 - Ejercicio “Sistema para empresa que realiza encuestas” .................................................... 140
Requerimientos ..................................................................................................................................... 141
Solución ................................................................................................................................................. 142
Posibles dificultades .......................................................................................................................... 142
Requerimientos presentados ............................................................................................................ 142
Requerimientos Erróneos ................................................................................................................. 142
Muchos Diseños Posibles .................................................................................................................. 143
Paso 1 – “Crear las clases y atributos” .............................................................................................. 144
Paso 2 – “Relacionar las clases” ........................................................................................................ 145
“Receta de cocina” ................................................................................................................................ 149
“El código” ............................................................................................................................................. 150
Index creado a “prueba y error” ........................................................................................................... 155
Resumen ............................................................................................................................................... 158
Capítulo 15 - “Herencia, Interfaces y Polimorfismo” ................................................................................ 159
La Herencia............................................................................................................................................ 161
Representación UML ............................................................................................................................. 162
Cómo se traduce a código ..................................................................................................................... 163
Caso 1 –Usuario hereda de Persona ..................................................................................................... 164
Caso 2 –Persona agrega un constructor ............................................................................................... 166
Caso 3 –Persona agrega su toString ...................................................................................................... 167
Caso 4 – Los usuarios necesitan un id y una fecha de ingreso ............................................................. 169
Caso 5 – Los usuarios necesitan un id único “autogenerado” .............................................................. 170
Explicación sobre la visibilidad de los atributos y métodos .................................................................. 173
“Visibilidad Pública” .......................................................................................................................... 173
“Visibilidad Privada” .......................................................................................................................... 173
“Visibilidad Protegida” ...................................................................................................................... 173
Caso 6 – Ejemplos varios ....................................................................................................................... 174
Clase abstracta .................................................................................................................................. 175
Herencia Múltiple ............................................................................................................................. 176
“Sobre-escritura” de métodos .......................................................................................................... 177
Evitar la herencia y la “sobre-escritura” de métodos ....................................................................... 178
“Generalización” versus “Especialización” ........................................................................................... 179
Entonces, ¿qué es Polimorfismo? ......................................................................................................... 180
La implementación ............................................................................................................................ 181
“Diseño más robusto” ....................................................................................................................... 182
¿La herencia está limitada? .................................................................................................................. 182
Las interfaces: “el poder desconocido” ................................................................................................ 184
Implementación ................................................................................................................................ 185
Cómo funciona .................................................................................................................................. 186
Detalles importantes ......................................................................................................................... 186
Repaso de lo visto hasta el momento ................................................................................................... 187
Las interfaces son “contratos de implementación” .......................................................................... 188
Anexo ................................................................................................................................................ 188
Resumen ............................................................................................................................................... 189
Capítulo 16 - Ejercicio “Clase de Persistencia”......................................................................................... 190
Requerimientos ..................................................................................................................................... 191
Solución ................................................................................................................................................. 193
Primer escenario: “crear una conexión a la base de datos” ................................................................. 194
Segundo escenario: “crear una clase de persistencia” ......................................................................... 194
Tercer escenario: “abstraer el tipo de base de datos” ......................................................................... 194
Diseño UML ........................................................................................................................................... 195
Ejemplo codificado ................................................................................................................................ 196
Principio de diseño “Abierto / Cerrado” ............................................................................................... 200
Resumen ............................................................................................................................................... 201
Capítulo 17 - Ejercicio “Librería y la búsqueda de Libros” ........................................................................ 202
Requerimientos ..................................................................................................................................... 203
Solución ................................................................................................................................................. 204
Diseño “Borrador” (con partes incompletas) ....................................................................................... 205
Diseño “Final” cumpliendo con todos los requerimientos ................................................................... 206
Comentarios sobre el diseño ................................................................................................................ 208
Resumen ............................................................................................................................................... 214
Capítulo 18 - “Los Paquetes en UML” ....................................................................................................... 215
Cómo se representan ............................................................................................................................ 216
¿Qué es una Arquitectura de 3 capas? ................................................................................................. 217
¿Que son entonces los Namespaces? ................................................................................................... 218
PHP5: Diseño en 3 capas y problemas con subdirectorios ....................................................... 218
"Petición para soporte de Name Spaces en PHP5" ................................................................... 218
En Resumen .......................................................................................................................................... 219
Capítulo 19 - Ejercicio “Programación ‘Orientada a la Implementación’ vs ‘Orientada a la Interface’" .. 220
Requerimientos ..................................................................................................................................... 222
Solución ................................................................................................................................................. 224
Parte 1: hacer una “máquina de escribir” siguiendo el ejemplo del artículo ....................................... 225
Parte 2: Agregar interfaces al diseño propuesto en la parte 1 ............................................................. 229
Implementación .................................................................................................................................... 231
¿Y el Diagrama de Paquetes? ............................................................................................................ 234
El “Principio de Inversión de dependencias (DIP)” ............................................................................... 235
Resumen ............................................................................................................................................... 237
Comentarios adicionales ....................................................................................................................... 238
Capítulo 20 - Ejercicio “Desarrollar un sistema de ABM de usuarios”...................................................... 239
Requerimientos ..................................................................................................................................... 240
Solución ................................................................................................................................................. 243
Cambios que se aplicaron en la resolución ........................................................................................... 244
Diagrama tradicional de paquetes ........................................................................................................ 245
Diagramas de clases y sus paquetes de origen ..................................................................................... 246
Diagramas de Secuencia ....................................................................................................................... 247
Partes esenciales del código de la solución .......................................................................................... 249
Resumen ............................................................................................................................................... 257
Capítulo 21 - Anexo: “Manejo de excepciones” ....................................................................................... 258
Introducción .......................................................................................................................................... 259
Básicamente cómo funcionan las excepciones ..................................................................................... 261
Estructura interna de una clase Exception ........................................................................................... 262
Importante: PHP no tiene excepciones por defecto ............................................................................. 264
¿Cuan grave es no tener Excepciones predefinidas y por defecto? ................................................. 264
Ejemplo funcional de excepciones en PHP5 ......................................................................................... 265
Importante: el orden de las excepciones .............................................................................................. 266
Beneficios de las Excepciones ............................................................................................................... 267
En Resumen .......................................................................................................................................... 268
Capítulo 22 - Cierre del libro y reflexiones finales .................................................................................... 269
Anexo I: "Qué es lo nuevo en PHP5?" ....................................................................................................... 273
Características del Lenguaje ................................................................................................................. 274
1.Modificadores de acceso "public/private/protected" ....................................................................... 274
2. El método reservado __construct() .................................................................................................. 275
3. El método reservado __destructor() ................................................................................................. 275
4. Interfaces .......................................................................................................................................... 276
5. El operador "instance of" .................................................................................................................. 277
6. Operador "final" para los métodos ................................................................................................... 277
7. Operador "final" para la clase ........................................................................................................... 278
8. Método reservado __clone para clonado de objetos ....................................................................... 279
9. Atributos Constantes para las clases ................................................................................................ 281
10. Miembros estáticos o de clase (static) ............................................................................................ 282
11. Métodos estáticos o de clase (static) .............................................................................................. 284
12. Clases Abstractas ............................................................................................................................ 286
13. Métodos abstractos ........................................................................................................................ 286
14. Validación de Tipo a través de Clases ( type hints) ......................................................................... 287
15.Soporte a invocaciones anidadas de objetos retornados ................................................................ 288
16. Iteradores ........................................................................................................................................ 290
17. __autoload() .................................................................................................................................... 291
Anexo II: Recopilación de FRASES ............................................................................................................. 292
101 citas célebres del mundo de la informática ....................................................................... 294
Otras 101 citas célebres del mundo de la informática ............................................................. 294
Clave de Cifrado: !SZSaVO2R2RoyV6UhOyF2CNcs57wZnxgauwFe4-Dwhao
Reply all
Reply to author
Forward
0 new messages