Manual de prácticas y antología para POO
•
0 gostou•17 visualizações
Manual de prácticas y antología de la asignatura de Programación Orientada a Objetos, carrera: Ingeniería en Sistemas Computacionales del TecNM.
Recomendados
Mais conteúdo relacionado
Semelhante a Manual de prácticas y antología para POO
Semelhante a Manual de prácticas y antología para POO (20)
Mais de José Antonio Sandoval Acosta
Mais de José Antonio Sandoval Acosta (20)
Manual de prácticas y antología para POO
- 1. Tecnológico Nacional de México Instituto Tecnológico Superior de Guasave Ingeniería en Sistemas Computacionales Programación Orientada a Objetos Manual de Prácticas y Antología Autor M.S.I. José Antonio Sandoval Acosta Guasave, Sin. Junio de 2023
- 2. 2 Tecnológico Nacional de México Instituto Tecnológico Superior de Guasave Directorio Dr. José Lorenzo Meza García Director General del TecNM Campus ITS de Guasave Lic. Jaime Cabanillas Torres Subdirector Académico y de Investigación e Innovación Lic. Jesús Lizbette Félix Acosta Subdirectora de Extensión y Vinculación MAP. Celia Yudith Bea Berrelleza Subdirectora de Planeación y Desarrollo Lic. Martha Mayumy Ascárrega Armenta Subdirectora de Servicios Administrativos Ing. Manuel Alfredo Flores Rosales Jefe de División de Ciencias Computacionales Ing. Graciela Lugo Rubio Presidenta de Academia de Ingeniería en Sistemas Computacionales Mtro. José Antonio Sandoval Acosta Autor
- 3. 3 Tabla de Contenido Introducción............................................................................................................. 8 Unidad 1: Introducción al Paradigma de la Programación Orientada a Objetos...... 9 Competencia de la unidad....................................................................................... 9 Introducción a la unidad .......................................................................................... 9 ¿Qué significa paradigma? ..................................................................................... 9 Las ventajas de la POO ........................................................................................ 10 Los Objetos ........................................................................................................... 11 Las Clases............................................................................................................. 11 Ejercicio: Clases.................................................................................................... 12 Encapsulamiento................................................................................................... 12 Ejercicio: Encapsulamiento ................................................................................... 13 Herencia................................................................................................................ 13 Ejercicio: Herencia ................................................................................................ 13 Polimorfismo.......................................................................................................... 14 Ejercicio: Polimorfismo .......................................................................................... 14 Abstracción............................................................................................................ 14 Ejercicio: Abstracción ............................................................................................ 15 Práctica ................................................................................................................. 16 Modelado de Clases y Objetos con UML .............................................................. 17 Diagrama de Clases.............................................................................................. 17 Práctica ................................................................................................................. 20 Asociación (Conexión entre clases) ...................................................................... 21 Multiplicidad........................................................................................................... 21 Rangos.................................................................................................................. 21 Agregaciones (Posee/contiene) ............................................................................ 22 Ejercicio: Agregaciones (Posee/contiene) ............................................................. 22 Composición.......................................................................................................... 22
- 4. 4 Dependencia (relación de uso).............................................................................. 22 Representación UML............................................................................................. 23 Ejercicio: Dependencia (relación de uso) .............................................................. 23 Generalizaciones (Herencia/Especificación) ......................................................... 23 Ejercicio: Generalizaciones ................................................................................... 24 Práctica ................................................................................................................. 25 Unidad 2: Clases y Objetos................................................................................... 26 Competencia de la unidad..................................................................................... 26 Lenguaje de programación a utilizar ..................................................................... 26 C # (Visual Studio para trabajar en modo consola) ............................................... 26 Identificadores en C# ............................................................................................ 26 Tipos de Datos en C#............................................................................................ 26 Declaración de Variables....................................................................................... 27 Sentencias using................................................................................................... 27 Pedir Datos (captura en proyectos de consola)..................................................... 28 Cálculos y Asignaciones........................................................................................ 28 Operadores Aritméticos......................................................................................... 29 Jerarquías ............................................................................................................. 29 Operadores de asignación adicionales ................................................................. 29 Clases y objetos.................................................................................................... 30 Cómo declarar una clase ...................................................................................... 30 Modificadores de acceso....................................................................................... 31 Atributos o campos................................................................................................ 31 Creación de objetos .............................................................................................. 32 Instanciación ......................................................................................................... 32 Accediendo a los miembros de los objetos ........................................................... 32 Asignación............................................................................................................. 32 Métodos ................................................................................................................ 32 La referencia this................................................................................................... 33
- 5. 5 Sobrecarga............................................................................................................ 34 Método constructor................................................................................................ 35 ¿Qué es un constructor?....................................................................................... 35 Práctica ................................................................................................................. 37 Práctica ................................................................................................................. 38 Práctica ................................................................................................................. 39 Operadores en la POO.......................................................................................... 40 Operadores Relacionales...................................................................................... 40 Operadores Lógicos.............................................................................................. 40 Decisiones (if)........................................................................................................ 40 Selección Múltiple ................................................................................................. 41 Ciclo for() { } .......................................................................................................... 41 Ciclo while { }......................................................................................................... 42 Ciclo do { } while( ) ................................................................................................ 42 Práctica ................................................................................................................. 43 Práctica ................................................................................................................. 44 Sobrecarga de métodos ........................................................................................ 45 Ejercicio de sobrecarga......................................................................................... 45 Práctica ................................................................................................................. 46 Unidad 3: Herencia................................................................................................ 47 Competencia de la unidad..................................................................................... 47 Introducción........................................................................................................... 47 Redefinición de métodos....................................................................................... 47 Principio de subtipos ............................................................................................. 49 Herencia de variables y métodos .......................................................................... 50 Herencia en C# ..................................................................................................... 51 Ejercicio de herencia ............................................................................................. 51 Práctica ................................................................................................................. 53 Unidad 4: Polimorfismo ......................................................................................... 54
- 6. 6 Competencia de la unidad..................................................................................... 54 Introducción........................................................................................................... 54 Polimorfismo.......................................................................................................... 54 Ejercicio de polimorfismo ...................................................................................... 56 Mapa conceptual de Polimorfismo ........................................................................ 56 Diferencia entre Sobrecarga y Polimorfismo ......................................................... 58 Ejercicio................................................................................................................. 58 Práctica ................................................................................................................. 59 Unidad 5: Interrupciones ....................................................................................... 60 Competencia de la unidad..................................................................................... 60 ¿Qué son las Excepciones?.................................................................................. 60 El bloque catch...................................................................................................... 61 El bloque finally ..................................................................................................... 61 Tratamiento de las excepciones............................................................................ 62 Tipos de excepciones más comunes..................................................................... 63 Lanzamiento de una excepción throw()................................................................. 63 Práctica ................................................................................................................. 64 Unidad 6: Archivos ................................................................................................ 65 Competencia de la unidad:.................................................................................... 65 ¿Cómo surge la necesidad de utilizar archivos?................................................... 65 Definiciones básicas.............................................................................................. 66 Datos..................................................................................................................... 66 Registro................................................................................................................. 66 Archivo .................................................................................................................. 66 Clasificación de archivos por tipo de contenido..................................................... 66 Archivos de texto................................................................................................... 67 Archivos binarios................................................................................................... 67 Representación Lógica de un Archivo Binario Organizado en Renglones y Columnas .............................................................................................................................. 68
- 7. 7 Manejo de Archivos de Texto................................................................................. 68 Declaración del alias del archivo........................................................................... 68 Nombre del archivo que guardará la información en texto plano .......................... 69 Streams................................................................................................................. 69 BufferedStream ..................................................................................................... 70 Constructores de StreamReader........................................................................... 71 Lectura con StreamReader ................................................................................... 71 ReadLine()............................................................................................................. 71 ReadToEnd() ......................................................................................................... 72 Read() ................................................................................................................... 72 Escritura: StreamWriter ......................................................................................... 72 Constructores de StreamWriter............................................................................. 73 Escritura con StreamWriter ................................................................................... 73 WriteLine()............................................................................................................. 73 Write().................................................................................................................... 74 Práctica ................................................................................................................. 75 Archivos Binarios................................................................................................... 76 BinaryWriter........................................................................................................... 76 Binaryreader.......................................................................................................... 77 Acceso Aleatorio.................................................................................................... 78 Práctica ................................................................................................................. 81
- 8. 8
- 9. 9
- 10. 10 • • •
- 11. 11 • • • •
- 12. 12
- 13. 13
- 14. 14
- 15. 15
- 16. 16 • •
- 17. 17 • • • • • • •
- 18. 18
- 19. 19
- 20. 20 • •
- 21. 21
- 22. 22
- 23. 23
- 24. 24
- 25. 25 • •
- 28. 28 Parámetros de sustitución Concatenación El resultado se almacena en esta variable Conversión de String a Entero TAMBIEN puede hacerse así: Pedir un dato String Asignación Cálculos
- 29. 29 • • • • • → • → • → • →
- 31. 31 • • • • •
- 32. 32 • •
- 33. 33 • • • •
- 34. 34
- 35. 35 • • •
- 36. 36
- 37. 37 • •
- 38. 38 • • •
- 39. 39 • • • •
- 40. 40
- 41. 41
- 42. 42
- 43. 43 •
- 44. 44 •
- 45. 45 • • • • • • •
- 46. 46 • • • • •
- 47. 47 • • •
- 48. 48
- 49. 49 • • • •
- 50. 50
- 52. 52 • • •
- 53. 53 • • • • •
- 54. 54
- 55. 55
- 56. 56 • • • •
- 57. 57 • • • • •
- 58. 58 • • • • • • •
- 59. 59 • • • • •
- 60. 60 ‐
- 61. 61
- 62. 62 • • •
- 64. 64 •
- 65. 65
- 66. 66
- 67. 67
- 68. 68
- 69. 69 •
- 71. 71
- 72. 72 • • •
- 73. 73
- 74. 74
- 75. 75 • • • •
- 76. 76 • •
- 77. 77
- 78. 78
- 79. 79
- 80. 80
- 81. 81 •
- 82. 82