├── 2022 ├── README.md └── \ ├── 2019agosto └── README.md ├── 2020enero └── README.md ├── README.md ├── ambiente └── ambiente.md ├── clases ├── clases.md └── params.md └── imgs ├── agg.png └── card.png /2019agosto/README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | ## Lista de Alumnos 4 | 5 | | Nombre | Repositorio | 6 | | -------------------|--------------------------------------------| 7 | |AGUAYO AGUAYO YAEL | [Yaguay](https://github.com/Yaguay/POO)| 8 | |ALEMAN URETA ENRIQUE | [EchoWitcher](https://github.com/EchoWitcher/POO)| 9 | |ANGULO GOMEZ CRISTO ABELARDO | | 10 | |CHAVEZ ARROYO MAURICIO | [Mauricio2110](https://github.com/Mauricio2110/Poo)| 11 | |CHAVEZ TRINIDAD RUBEN FELIX | [rwb3x](https://github.com/rwb3x/POO)| 12 | |DE LUNA CORRAL JESUS RODRIGO | [Rodrigo-deluna](https://github.com/Rodrigo-deluna)| 13 | |DIAZ CORONA ASHLEY YEDITH | | 14 | |ESPINOZA RUIZ PABLO ALBERTO | [pabloalber84](https://github.com/pabloalber84)| 15 | |FLORES VELEZ ERNESTO RAMSES | [ernestoramflovlz](https://github.com/ernestoramflovlz/POO.)| 16 | |GARCIA LARES MIGUEL ANGEL | [Miguel2496](https://github.com/Miguel2496/OOP-MI)| 17 | |GARCIA PEREZ GABRIEL | [GarciaG1](https://github.com/GarciaG1/POO1)| 18 | |GUERRERO AGUILAR ELIGIO GUADALUPE | [EligioGA](https://github.com/EligioGA/POO)| 19 | |GUTIERREZ LOZANO JUAN PABLO | [DigitalSnakedotexe](https://github.com/DigitalSnakedotexe/POO)| 20 | |HERNANDEZ QUIROZ RODOLFO IVAN | [Rodolfo-hernandez1](https://github.com/Rodolfo-hernandez1/CursoOOP) | 21 | |JIMENEZ GONZALEZ MANUEL| 22 | |LEON MOLINA FELIX ENRIQUE | [FelixELM](https://github.com/FelixELM/POO)| 23 | |LOPEZ ESQUERRA JONATHAN DANIEL | [PhantompD](https://github.com/PhantompD/OOP)| 24 | |LOPEZ ROBLERO CESAR HUMBERTO | [CesarHLR](https://github.com/CesarHLR/POO)| 25 | |LOZANO ALVAREZ MARCO POLO | [zefra](https://github.com/zefra/p.oo) | 26 | |LUIS CASTILLO VALERIA | [valeria1703](https://github.com/valeria1703/POO)| 27 | |MARTINEZ MURRIETA CHRISTIAN ANDRES | [ChrisHomeless](https://github.com/ChrisHomeless/HomelessPOO)| 28 | |MEDINA MAGAÑA HECTOR MANUEL | [M3D1N4](https://github.com/M3D1N4/Dorya-poo)| 29 | |MERCADO CRUZ ARTURO | [Arturo-M](https://github.com/Arturo-M/OOP)| 30 | |ORDAZ MEDINA RICARDO DANIEL| | 31 | |PAEZ RENTERIA DAVID ARMANDO | [foxsok](http://github.com/foxsok)| 32 | |PANIAGUA GUTIERREZ CARLOS ADRIAN | [CarlosGtzOf](https://github.com/CarlosGtzOf)| 33 | |PEREZ ROJAS JAIRO JAZIEL | [jairo570](https://github.com/jairo570/POO)| 34 | |PICOS QUEZADA ERICK DANIEL| | 35 | |PORTUGAL QUINTERO ADOLFO | [4DownPortu](https://github.com/4DownPortu/POO)| 36 | |QUINTERO MONTALVO LUIS ENRIQUE | [luisqm](http://github.com/luisqm/POO)| 37 | |RAMIREZ CORONEL ALBERTO | [AlbertoRaCa](https://github.com/AlbertoRaCa/OOP)| 38 | |REYES CARO MARCO ANTONIO | [marcoreyes666](https://github.com/marcoreyes666/POO)| 39 | |RIVERA MARTINEZ MARCO ANTONIO | [MarcoRivera21](https://github.com/MarcoRivera21/Marco-Rivera/blob/master/README.md)| 40 | |RUIZ VILLEGAS JAVIER YOEL | [YoelRuiz](https://github.com/YoelRuiz)| 41 | |SILVA REYES LUIS ADRIAN | [Luissf1](https://github.com/Luissf1/POO) | 42 | |TECUAPA GALLARDO ARTURO | [ArturoTecuapa50](https://github.com/ArturoTecuapa50)| 43 | |TEJEDA COTA ERICK | [iwanttacos](https://github.com/iwanttacos/POO)| 44 | |TRUJILLO GARAY CESAR ANDRES | [kikhi](https://github.com/kikhi/POO) | 45 | |VALADEZ CORRALES SAUL ALEJANDRO | [saulvaladez18](https://github.com/saulvaladez18/ShaggyPOO)| 46 | 47 | # Actividades 48 | También pueden hacer pull-request siguiendo las instrucciones adicionales en el [repositorio correspondiente](https://github.com/mariosky/EjerciciosOPP). 49 | 50 | 51 | ## Generics (20 de Noviembre) 52 | ### Stack 53 | Implementa la clase **generica** Stack, la cual sea eso una Pila. 54 | Debe incluir los métodos push() y pop() y marcar error en caso de que la pila 55 | se desborde o se intente hacer pop() a una pila vacía. Básate en el ejercicio 56 | visto en clase. 57 | Prueba tu clase, con varios tipos de dato. 58 | 59 | ### Cola 60 | Utilizando las ideas vistas en la clase Stack ahora intenta hacer 61 | una cola. La cola tiene funciona como FIFO, es decir el primero que 62 | entra es el primero que sale. Puedes utilizar un arreglo y recorrer los 63 | elementos como en una fila del mundo real. 64 | 65 | ## Clases Abstractas (24 de Octubre) 66 | 67 | ### Ilustrador 68 | Basándote en el programa que iniciamos en clase (a continuación), términa el programa 69 | utilizando el concepto de clases abstractas. 70 | 71 | ```csharp 72 | using System; 73 | using System.Collections.Generic; 74 | 75 | namespace figura 76 | { 77 | class Figura 78 | { 79 | protected int x; 80 | protected int y; 81 | protected string color; 82 | 83 | public Figura(int x, int y, string c){ 84 | this.x = x; this.y = y; color = c; 85 | } 86 | 87 | public void dibuja() 88 | { 89 | Console.WriteLine("Se dibuja una figura color {0}", 90 | color); 91 | } 92 | 93 | public void printColor() { 94 | Console.WriteLine(color); 95 | } 96 | } 97 | 98 | class Circulo : Figura { 99 | public Circulo(int x, int y, string c):base(x , y, c){ 100 | } 101 | 102 | public new void dibuja(){ 103 | Console.WriteLine("Se dibuja un circulo {0}", color); 104 | } 105 | } 106 | 107 | class Rect : Figura { 108 | public Rect(int x, int y, string c):base(x , y, c){ 109 | } 110 | } 111 | class Program{ 112 | static void Main(string[] args){ 113 | List figuras = new List(); 114 | figuras.Add(new Circulo(12,13,"verde")) ; 115 | figuras.Add(new Rect(12,13,"azul")) ; 116 | figuras.Add(new Rect(12,13,"rojo")) ; 117 | figuras.Add(new Circulo(12,13,"rojo")) ; 118 | foreach (var item in figuras){ 119 | item.dibuja(); 120 | } 121 | Circulo r = new Circulo(10,10,"rojo"); 122 | r.dibuja(); 123 | } 124 | } 125 | } 126 | ``` 127 | 128 | ### Músicos Abstractos 129 | Implementa el programa de **Músico** que hiciste en el tema de Herencia pero con clases abstractas. 130 | 131 | ## Herencia (23 de Octubre) 132 | ### Alumnos 133 | Debes hacer un programa dónde utilices la siguiente jerarquía de clases: **Alumno**, **Licenciatura**, 134 | y **Posgrado**. La diferencia entre un alumno de Licenciatura y de Posgrado es que los alumnos de 135 | Licenciatrua hacen servicio social y residencias, y el alumno de posgrado tiene un tema de investigación. 136 | Debes: 137 | 138 | 1. Utilizar herencia. 139 | 2. Utilizar la referencia **base** y miembros de la clase base. 140 | 3. Redefinir un método en la clase derivada utilizando el modificador **new**. 141 | 4. Prueba la diferencia entre **private** y **protected** para los campos de la clase **Alumno**. 142 | 143 | ### Músicos 144 | Escribe un programa dónde utilices la siguiente jerarquía de clases: **Músico**, **Baterista**, 145 | **Bajista** y **Guitarrista**. En el método **Main()** debes crear una lista de músicos 146 | (**List**) y utilizando métodos virtuales hacer que los músicos ejecuten los métodos: 147 | **afina()**,**saluda()**,**toca()**. Básate en el ejemplo que vimos en clase. 148 | 149 | ## Sobrecargado de Operadores, ejercicios en clase (23 de Octubre) 150 | ### Duración 151 | Implementa la clase **Duración** siguiendo los pasos: 152 | 153 | 1. Declara la clase **Duración** con los atributos: *horas*, *minutos* y *segundos*. Estos atributos puden ser propiedades. Por ejemplo, pudes guardar todo en segundos y calcular como paramentres las *horas* y *minutos*. Implementa un método para imprimir la duración en el formato *HH:MM:SS*. 154 | 2. Sobrecarga el constructor **Duración(int h, int m, int s)**. 155 | 2. Sobrecarga el constructor **Duración(int segundos)**. Dependiendo de la implementación del paso 1, puede ser que debas extraer las horas y los minutos. 156 | 3. Sobrecarga el operador **+** para que puedas sumar dos objetos tipo **Duración**. 157 | 158 | ### Dominó 159 | Implementa la clase **Domino** siguiendo los pasos: 160 | 161 | 1. Declara la clase **Domino** con los atributos: *Espacio1* y *Espacio2*. 162 | 2. Sobrecarga el operador **+** para que puedas sumar dos objetos tipo **Domino**. El resultado debe ser un entero, con la suma de los puntos de ambas piezas. 163 | 164 | ## Paso de parámetros (30 de Septiembre) 165 | 166 | 1. Lee el texto de [pase de parametros](../clases/params.md). 167 | 1. Escribe un programa en el cual ejemplifiques el paso de parámetros 168 | **por valor** y **por referencia** utilizando los modificadores **ref**, **out** e **in**. 169 | 170 | 171 | ## Crear Repositorio en Github (18 de Septiembre) 172 | 173 | 1. Debes crear una cuenta en GitHub e instalar git localmente. 174 | 2. Crea un repositorio público llamado POO. Agrega los archivos *.gitignore* y *README.md*. 175 | 3. Incluye una portada en el archivo README.md. Este archivo será la portada e índice de tus evidencias. Debes agregar vínculos a las actividades del curso. Debes organizar el portafolio utilizando subdirectorios. 176 | 4. Envía un correo o mensaje al profesor con tu nombre completo y usuario de GitHub. 177 | 178 | 5. **Opcional** Haz un fork de este repositorio y agrega tu mismo el nombre a este archivo, solicita un pull request para que se actualize. 179 | 180 | Crear un repositorio [GitHub Help](https://help.github.com/en/articles/create-a-repo) 181 | Crear un pull request [GitHub Help](https://help.github.com/en/articles/creating-a-pull-request-from-a-fork) 182 | 183 | 184 | ## Ejercicio de Markdown en Github (19 de Septiembre) 185 | 186 | Crea un nueva carpeta en el repositorio *POO* llamada *Setup* la cual incluya un archivo *README.md* En el cual se describan los pasos para instalar el ambiente de desarrollo para aplicaciones de consola en C#. Debes de utilizar imágenes,hipervínculos a archivos dentro de tu repositorio. Se deben incluir detalles de: 187 | 188 | 1. Instalación de dotnet core 2.2. 189 | 2. Instalación y configuración de Visual Studio Code para C#. 190 | 3. Instalación de git. conectado a tu cuenta de GitHub y VSC. 191 | 192 | [Documento de Apoyo](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) 193 | 194 | ## Programa básico Películas (20 de Septiembre) 195 | 196 | De acuerdo a los ejemplos vistos en clase y la lectura. Implementa en c# la clase *Pelicula* con los siguientes atributos **publicos**: 197 | 198 | 199 | ### Pelicula 200 | | atributo | tipo | 201 | | ---------------------|----------------| 202 | | titulo | String | 203 | | año | Int16 | 204 | | país | String | 205 | | director | String | 206 | 207 | 208 | 1. Como primer paso crea solo la clase con los atributos públicos e inicializalos en **Program.Main()** directamente. 209 | 2. Crea dos objetos tipo Pelicula con dos peliculas ganadoras de un Oscar. 210 | 3. Imprime en la consola el titulo y año de las peliculas. 211 | Sube la primera versión a GitHub. 212 | 4. Ahora cambia los atributos a **private**. Agrega los métodos necesarios para crear los objetos de la siguiente manera: 213 | 214 | ```csharp 215 | class Program 216 | { 217 | static void Main(){ 218 | 219 | Pelicula p1 = new Pelicula(); 220 | p1.SetTitulo("La La Land"); 221 | p1.SetAño(2016); 222 | Console.WriteLine("{0}({1})", p1.GetTitulo(), p1.GetAño()); 223 | 224 | } 225 | } 226 | ``` 227 | Actualiza la versión a GitHub. 228 | 229 | 5. Por último agrega dos constructores: *Pelicula()* y *Pelicula(string titulo, Int16 año )* y el método imprime(). 230 | Actualiza la versión a GitHub. 231 | 232 | ## Lista de Películas (21 de Septiembre) 233 | 234 | Utilizando la bibliteca *System.Collections.Generic* crea una lista de 5 peliculas. Utilizando la lista genérica **List**. 235 | 1. Crea la lista en *Main()* y agrega directamente las peliculas a la lista, por ejemplo para la clase **Persona** sería de esta manera (fragmento): 236 | 237 | ```csharp 238 | List personas = new List(); 239 | 240 | persona.Add(new Persona ("pam")); 241 | persona.Add(new Persona ("tom")); 242 | persona.Add(new Persona ("jim")); 243 | 244 | ``` 245 | 2. Utiliza un ciclo **foreach** para iterar por la lista e imprimir las peliculas. 246 | 247 | ## Actores (22 de Septiembre) 248 | 249 | Agrega a tu clase **Pelicula** un atributo **actores** de tipo **List** 250 | Tu clase debe permitir el siguiente funcionamiento: 251 | 252 | ```csharp 253 | class Program 254 | { 255 | static void Main(){ 256 | 257 | Pelicula p1 = new Pelicula("La La Land", 2016); 258 | p1.AgregarActor(new Actor("Ryan Gosling", 1980)); 259 | p1.AgregarActor(new Actor("Emma Stone", 1988)); 260 | 261 | p1.ImprimeActores(); 262 | 263 | } 264 | } 265 | ``` 266 | 267 | -------------------------------------------------------------------------------- /2020enero/README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | ## Evaluación 4 | 5 | | Unidadades | Examen | Actividades/Tareas| Proyecto | Asistencia | 6 | | ---------------------|---------------|-------------------|----------|-------------| 7 | | Unidad 1 a Unidad 4 | 40 | 50 | - | 10 | 8 | | Unidad 5 y Unidad 6 | 10 | 5 | 80 | 5 | 9 | 10 | ## Lista de Alumnos 11 | 12 | |# | Nombre | Repositorio | 13 | |--|-------------------|--------------------------------------------| 14 | |01| Luevano Gomez Brayan Alberto | [BrayanLuevano](https://github.com/BrayanLuevano) | 15 | |02| Israel Felix Bojorquez | [israeleslegitimo](https://github.com/israeleslegitimo) | 16 | |03| Ernesto Vazquez | [ErnestoVazquez94/](https://github.com/ErnestoVazquez94/) | 17 | |04| Figueroa Parra Francisco Manuel | [FranFig1310](https://github.com/FranFig1310) | 18 | |05| Sebastian Hernandez | [Sebashhdez13](https://github.com/Sebashhdez13) | 19 | |06| Juan Luis García | [ Juannino27](https://github.com/Juannino27) | 20 | |07| Callejas Valdez Jesús | [FutureOfOrlando](https://github.com/FutureOfOrlando) | 21 | |08| Izabal Guerrero Andrea Fernanda | [AndreaIzabal](https://github.com/AndreaIzabal) | 22 | |09| Jesús Alfaro Angulo | [Likulau](https://github.com/Likulau) | 23 | |10| HUERTA MIRELES ROBERTO MANUEL | [elrowber21](https://github.com/elrowber21) | 24 | |11| Olea León Jonhy | [MrPandaIce](https://github.com/MrPandaIce) | 25 | |12| Gutierrez Mora Karime Isabel | [KarimeIsabel](https://github.com/KarimeIsabel) | 26 | |13| Iván Jiménez Castillo | [ivanjimc](https://github.com/ivanjimc) | 27 | |14| Andres Ponce Garibay | [P-once](https://github.com/P-once) | 28 | |15| Jose Angel Flores Gomez |[AngelFloresMrDarkSoul](https://github.com/AngelFloresMrDarkSoul)| 29 | |16| Garay Reyes Lizeth | [LizethG0219](https://github.com/LizethG0219)| 30 | |17| ERIC KARIM CERVANTES ORTIZ | [Rasblue](https://github.com/Rasblue) | 31 | |18| JONATHAN JAFET MOJICA VIDA| [JonathanMov](https://github.com/JonathanMov) | 32 | |19| Jorge Arturo Copado Luna| [Atxi0nBre4k](https://github.com/Atxi0nBre4k) | 33 | |20| López Rivera Vanessa Elizabeth| [Chita15](https://github.com/Chita15) | 34 | |21| Axel Josue De La Rosa López | [Latzel](https://github.com/Latzel) | 35 | |22| Bautista Domínguez Miguel Ángel | [MigBau2001](https://github.com/MigBau2001) | 36 | |23| Marlon Zarif Callado Esquivel | [Marlonc137](https://github.com/Marlonc137) | 37 | |24| Alex Romo García | [AlexRomoG24](https://github.com/AlexRomoG24) | 38 | |25| BRYANT FERRER TINOCO | [KobeBryant24-rgb](https://github.com/KobeBryant24-rgb) | 39 | |26| David Nuñez Cano | [Churro696](https://github.com/Churro696) | 40 | |27| Ruiz Pacheco Daniel Ivan | [BICI227](https://github.com/BICI227) | 41 | |28| MANUEL ENRIQUE TOLEDO RAMIREZ | [ManuelETR](https://github.com/ManuelETR) | 42 | |29| Alejandro Manuel Carrillo Romero | [Ale-NHK](https://github.com/Ale-NHK) | 43 | |30| MIGUEL ARTURO TERRAZAS ROJO | [Mike-gg](https://github.com/Mike-gg) | 44 | |31| KENNY ZHENG HU | [KennyKZH](https://github.com/KennyKZH) | 45 | |32| ALESSA NICASIO ESPINOZA | [AlessaNicasio](https://github.com/AlessaNicasio) | 46 | |33| ALAN RODRIGUEZ CAMACHO | [errror-404](https://github.com/errror-404) | 47 | |34| ROGELIO CARRILLO REYES | [RogelioCR03](https://github.com/RogelioCR03) | 48 | |35| Daniel Gonzalez Saldaña | [DanielOwO](https://github.com/DanielOwO) | 49 | |36| Garay Reyes Lizeth | [LizethG0219](https://github.com/LizethG0219) | 50 | |37| ESTEBAN IVAN LOPEZ LOPEZ | [ElPandaDeLa13](https://github.com/ElPandaDeLa13) | 51 | |38| LUIS GERARDO NAVARRETE SILVA | [Pepelote12](https://github.com/Pepelote12) | 52 | |39| GUSTAVO NICOLAS GARCIA | [CamaradaNicolas](https://github.com/CamaradaNicolas) | 53 | 54 | 55 | # Actividades 56 | También pueden hacer pull-request siguiendo las instrucciones adicionales en el [repositorio correspondiente](https://github.com/mariosky/EjerciciosOPP). 57 | 58 | 59 | ## Crear Repositorio en Github 60 | 61 | 1. Debes crear una cuenta en GitHub e instalar git localmente. 62 | 2. Crea un repositorio público llamado POO. Agrega los archivos *.gitignore* y *README.md*. 63 | 3. Incluye una portada en el archivo README.md. Este archivo será la portada e índice de tus evidencias. Debes agregar vínculos a las actividades del curso. Debes organizar el portafolio utilizando subdirectorios. 64 | 4. Envía un correo o mensaje al profesor con tu nombre completo y usuario de GitHub. 65 | 66 | 5. **Opcional** Haz un fork de este repositorio y agrega tu mismo el nombre a este archivo, solicita un pull request para que se actualize. 67 | 68 | Crear un repositorio [GitHub Help](https://help.github.com/en/articles/create-a-repo) 69 | Crear un pull request [GitHub Help](https://help.github.com/en/articles/creating-a-pull-request-from-a-fork) 70 | 71 | 72 | ## Ejercicio de Markdown en Github 73 | Crea un nueva carpeta en el repositorio *POO* llamada *Setup* la cual incluya un archivo *README.md* En el cual se describan los pasos para instalar el ambiente de desarrollo para aplicaciones de consola en C#. Debes de utilizar imágenes,hipervínculos a archivos dentro de tu repositorio. Se deben incluir detalles de: 74 | 75 | 1. Instalación de dotnet core úlitima versión. 76 | 2. Instalación y configuración de Visual Studio Code para C#. 77 | 3. Instalación de git. conectado a tu cuenta de GitHub y VSC. 78 | 79 | [Documento de Apoyo](https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet) 80 | 81 | ## Programa básico Películas 82 | 83 | De acuerdo a los ejemplos vistos en clase y la lectura. Implementa en c# la clase *Pelicula* con los siguientes atributos **publicos**: 84 | 85 | 86 | ### Pelicula 87 | | atributo | tipo | 88 | | ---------------------|----------------| 89 | | titulo | String | 90 | | año | Int16 | 91 | | país | String | 92 | | director | String | 93 | 94 | 95 | 1. Como primer paso crea solo la clase con los atributos públicos e inicializalos en **Program.Main()** directamente. 96 | 2. Crea dos objetos tipo Pelicula con dos peliculas ganadoras de un Oscar. 97 | 3. Imprime en la consola el titulo y año de las peliculas. 98 | Sube la primera versión a GitHub. 99 | 4. Ahora cambia los atributos a **private**. Agrega los métodos necesarios para crear los objetos de la siguiente manera: 100 | 101 | ```csharp 102 | class Program 103 | { 104 | static void Main(){ 105 | 106 | Pelicula p1 = new Pelicula(); 107 | p1.SetTitulo("La La Land"); 108 | p1.SetAño(2016); 109 | Console.WriteLine("{0}({1})", p1.GetTitulo(), p1.GetAño()); 110 | 111 | } 112 | } 113 | ``` 114 | Actualiza la versión a GitHub. 115 | 116 | 5. Por último agrega dos constructores: *Pelicula()* y *Pelicula(string titulo, Int16 año )* y el método imprime(). 117 | Actualiza la versión a GitHub. 118 | 119 | ## Lista de Películas 120 | 121 | Utilizando la bibliteca *System.Collections.Generic* crea una lista de 5 peliculas. Utilizando la lista genérica **List**. 122 | 1. Crea la lista en *Main()* y agrega directamente las peliculas a la lista, por ejemplo para la clase **Persona** sería de esta manera (fragmento): 123 | 124 | ```csharp 125 | List personas = new List(); 126 | 127 | persona.Add(new Persona ("pam")); 128 | persona.Add(new Persona ("tom")); 129 | persona.Add(new Persona ("jim")); 130 | 131 | ``` 132 | 2. Utiliza un ciclo **foreach** para iterar por la lista e imprimir las peliculas. 133 | 134 | ## Actores 135 | Agrega a tu clase **Pelicula** un atributo **actores** de tipo **List** 136 | Tu clase debe permitir el siguiente funcionamiento: 137 | 138 | ```csharp 139 | class Program 140 | { 141 | static void Main(){ 142 | 143 | Pelicula p1 = new Pelicula("La La Land", 2016); 144 | p1.AgregarActor(new Actor("Ryan Gosling", 1980)); 145 | p1.AgregarActor(new Actor("Emma Stone", 1988)); 146 | 147 | p1.ImprimeActores(); 148 | 149 | } 150 | } 151 | ``` 152 | 153 | ## UML 154 | 155 | 1. Agrega la cardinalidad o multiplicidad para las asociaciones del siguiente diagrama de clases, justifica tus decisiones: 156 | 157 | ![Documento de Apoyo](../imgs/card.png) 158 | 159 | 2. Completa los tipos de asociación (Agregación y Composición) y multiplicidad que hay entre las clases siguientes y explica porque es de ese tipo. 160 | 161 | ![Documento de Apoyo](../imgs/agg.png) 162 | 163 | 3. Haz el diagrama de clases del siguiente sistema: 164 | ``` 165 | Nos piden hacer una aplicación para llevar una bitácora de los libros 166 | que estamos leyendo y aquellos que ya hemos terminado de leer. 167 | En la App podemos buscar libros por autor, categoría, título y calificación. 168 | Una vez que encontramos un libro, podemos agregarlo a nuestra biblioteca e indicar 169 | si lo estamos leyendo o ya terminamos de leer y lo podemos poner una calificación. 170 | Los libros pueden tener más de un autor, si buscamos un autor podemos ver la 171 | lista de los libros que ha escrito. En caso de que haya traducciones o reediciones 172 | se consideran como el mismo libro. 173 | 174 | OPCIONAL: Podemos indicar si un libro se lo prestamos a un amigo, desde que fecha y 175 | tenemos su correo para recordarle que nos lo regrese. 176 | ``` 177 | 178 | 179 | ## Paso de parámetros 180 | 181 | 1. Lee el texto de [pase de parametros](../clases/params.md). 182 | 1. Escribe un programa en el cual ejemplifiques el paso de parámetros 183 | **por valor** y **por referencia** utilizando los modificadores **ref**, **out** e **in**. 184 | 185 | ### Dominó 186 | Implementa la clase **Domino** siguiendo los pasos: 187 | 188 | 1. Declara la clase **Domino** con los atributos: *Espacio1* y *Espacio2*. 189 | 2. Sobrecarga el operador **+** para que puedas sumar dos objetos tipo **Domino**. El resultado debe ser un entero, con la suma de los puntos de ambas piezas. 190 | 191 | ## Sobrecargado de Operadores, ejercicios en clase 192 | ### Duración 193 | Implementa la clase **Duración** siguiendo los pasos: 194 | 195 | 1. Declara la clase **Duración** con los atributos: *horas*, *minutos* y *segundos*. Estos atributos puden ser propiedades. Por ejemplo, pudes guardar todo en segundos y calcular como paramentres las *horas* y *minutos*. Implementa un método para imprimir la duración en el formato *HH:MM:SS*. 196 | 2. Sobrecarga el constructor **Duración(int h, int m, int s)**. 197 | 2. Sobrecarga el constructor **Duración(int segundos)**. Dependiendo de la implementación del paso 1, puede ser que debas extraer las horas y los minutos. 198 | 3. Sobrecarga el operador **+** para que puedas sumar dos objetos tipo **Duración**. 199 | 200 | 201 | 202 | ## Herencia 203 | ### Alumnos 204 | Debes hacer un programa dónde utilices la siguiente jerarquía de clases: **Alumno**, **Licenciatura**, 205 | y **Posgrado**. La diferencia entre un alumno de Licenciatura y de Posgrado es que los alumnos de 206 | Licenciatrua hacen servicio social y residencias, y el alumno de posgrado tiene un tema de investigación. 207 | Debes: 208 | 209 | 1. Utilizar herencia. 210 | 2. Utilizar la referencia **base** y miembros de la clase base. 211 | 3. Redefinir un método en la clase derivada utilizando el modificador **new**. 212 | 4. Prueba la diferencia entre **private** y **protected** para los campos de la clase **Alumno**. 213 | 214 | ### Músicos 215 | Escribe un programa dónde utilices la siguiente jerarquía de clases: **Músico**, **Baterista**, 216 | **Bajista** y **Guitarrista**. En el método **Main()** debes crear una lista de músicos 217 | (**List**) y utilizando métodos virtuales hacer que los músicos ejecuten los métodos: 218 | **afina()**,**saluda()**,**toca()**. Básate en el ejemplo que vimos en clase. 219 | 220 | 221 | 222 | ## Clases Abstractas 223 | ### Ilustrador 224 | Basándote en el programa que iniciamos en clase (a continuación), términa el programa 225 | utilizando el concepto de clases abstractas. 226 | 227 | ```csharp 228 | using System; 229 | using System.Collections.Generic; 230 | 231 | namespace figura 232 | { 233 | class Figura 234 | { 235 | protected int x; 236 | protected int y; 237 | protected string color; 238 | 239 | public Figura(int x, int y, string c){ 240 | this.x = x; this.y = y; color = c; 241 | } 242 | 243 | public void dibuja() 244 | { 245 | Console.WriteLine("Se dibuja una figura color {0}", 246 | color); 247 | } 248 | 249 | public void printColor() { 250 | Console.WriteLine(color); 251 | } 252 | } 253 | 254 | class Circulo : Figura { 255 | public Circulo(int x, int y, string c):base(x , y, c){ 256 | } 257 | 258 | public new void dibuja(){ 259 | Console.WriteLine("Se dibuja un circulo {0}", color); 260 | } 261 | } 262 | 263 | class Rect : Figura { 264 | public Rect(int x, int y, string c):base(x , y, c){ 265 | } 266 | } 267 | class Program{ 268 | static void Main(string[] args){ 269 | List figuras = new List(); 270 | figuras.Add(new Circulo(12,13,"verde")) ; 271 | figuras.Add(new Rect(12,13,"azul")) ; 272 | figuras.Add(new Rect(12,13,"rojo")) ; 273 | figuras.Add(new Circulo(12,13,"rojo")) ; 274 | foreach (var item in figuras){ 275 | item.dibuja(); 276 | } 277 | Circulo r = new Circulo(10,10,"rojo"); 278 | r.dibuja(); 279 | } 280 | } 281 | } 282 | ``` 283 | 284 | ### Músicos Abstractos 285 | Implementa el programa de **Músico** que hiciste en el tema de Herencia pero con clases abstractas. 286 | 287 | 288 | ## Generics 289 | ### Stack 290 | Implementa la clase **generica** Stack, la cual sea eso una Pila. 291 | Debe incluir los métodos push() y pop() y marcar error en caso de que la pila 292 | se desborde o se intente hacer pop() a una pila vacía. Básate en el ejercicio 293 | visto en clase. 294 | Prueba tu clase, con varios tipos de dato. 295 | 296 | ### Cola 297 | Utilizando las ideas vistas en la clase Stack ahora intenta hacer 298 | una cola. La cola tiene funciona como FIFO, es decir el primero que 299 | entra es el primero que sale. Puedes utilizar un arreglo y recorrer los 300 | elementos como en una fila del mundo real. 301 | 302 | 303 | 304 | -------------------------------------------------------------------------------- /2022/README.md: -------------------------------------------------------------------------------- 1 | 2 | # Tareas de Programación Orientada a Objetos 3 | 4 | # Unidad 1: El Paradigma Orientado a Objetos 5 | 6 | ## UML 7 | 8 | 1. Agrega la cardinalidad o multiplicidad para las asociaciones del siguiente diagrama de clases, justifica tus decisiones: 9 | 10 | ![Documento de Apoyo](../imgs/card.png) 11 | 12 | 2. Completa los tipos de asociación (Agregación y Composición) y multiplicidad que hay entre las clases siguientes y explica porque es de ese tipo. 13 | 14 | ![Documento de Apoyo](../imgs/agg.png) 15 | 16 | 3. Haz el diagrama de clases del siguiente sistema: 17 | ``` 18 | Nos piden hacer una aplicación para llevar una bitácora de libros 19 | que estamos leyendo y los que ya terminamos de leer. 20 | En la App podemos buscar libros por autor, categoría, título y calificación. 21 | Una vez que encontramos un libro, podemos agregarlo a nuestra biblioteca e indicar 22 | si lo estamos leyendo o ya terminamos de leer. También le podemos poner una calificación. 23 | Los libros pueden tener más de un autor, si buscamos un autor podemos ver la 24 | lista de los libros que ha escrito. En caso de que haya traducciones o reediciones 25 | se consideran como el mismo libro. 26 | 27 | OPCIONAL: Podemos indicar si un libro se lo prestamos a un amigo, desde que fecha y 28 | tenemos su contacto para recordarle que nos lo regrese. 29 | ``` 30 | 31 | # Unidad 2: Clases y Objetos 32 | ## Programa básico Películas 33 | 34 | De acuerdo a los ejemplos vistos en clase y la lectura. Implementa en c# la 35 | clase *Pelicula* con los siguientes atributos **públicos**: 36 | 37 | ### Pelicula 38 | | atributo | tipo | 39 | | ---------------------|----------------| 40 | | titulo | String | 41 | | año | Int16 | 42 | | país | String | 43 | | director | String | 44 | 45 | 46 | 1. Como primer paso crea solo la clase con los atributos públicos e 47 | inicializalos en **Program.Main()** directamente. 48 | 2. Crea dos objetos tipo Pelicula con dos peliculas ganadoras de un Oscar. 49 | 3. Ahora modifica el programa para que imprima en la consola el titulo y año de las peliculas. 50 | Para esto, agrega un método llamado Imprime() a la clase Pelicula. 51 | Sube la primera versión a GitHub. 52 | 4. Ahora cambia los atributos a **private**. Agrega los métodos necesarios para 53 | crear los objetos y acceder a los atributos (campos en C#) de la siguiente manera: 54 | 55 | ```csharp 56 | class Program 57 | { 58 | static void Main(){ 59 | 60 | Pelicula p1 = new Pelicula(); 61 | p1.SetTitulo("La La Land"); 62 | p1.SetAño(2016); 63 | Console.WriteLine("{0}({1})", p1.GetTitulo(), p1.GetAño()); 64 | } 65 | } 66 | ``` 67 | Sube esta nueva versión a GitHub. 68 | 69 | 5. Por último agrega dos constructores sobrecargados: *Pelicula()* y 70 | *Pelicula(string titulo, Int16 año )*. Actualiza la 71 | versión a GitHub. 72 | 73 | 74 | ## Lista de Películas 75 | 76 | Utilizando la bibliteca *System.Collections.Generic* crea una lista de 5 peliculas. Utilizando la lista genérica **List**. 77 | 1. Crea la lista en *Main()* y agrega directamente las peliculas a la lista, por ejemplo para la clase **Persona** sería de esta manera (fragmento): 78 | 79 | ```csharp 80 | List personas = new List(); 81 | 82 | persona.Add(new Persona ("pam")); 83 | persona.Add(new Persona ("tom")); 84 | persona.Add(new Persona ("jim")); 85 | 86 | ``` 87 | 2. Utiliza un ciclo **foreach** para iterar por la lista e imprimir las peliculas. 88 | 89 | ## Actores 90 | Agrega a tu clase **Pelicula** un atributo **actores** de tipo **List** 91 | Tu clase debe permitir el siguiente funcionamiento: 92 | 93 | ```csharp 94 | class Program 95 | { 96 | static void Main(){ 97 | 98 | Pelicula p1 = new Pelicula("La La Land", 2016); 99 | p1.AgregarActor(new Actor("Ryan Gosling", 1980)); 100 | p1.AgregarActor(new Actor("Emma Stone", 1988)); 101 | 102 | p1.ImprimeActores(); 103 | 104 | } 105 | } 106 | ``` 107 | 108 | ## Paso de parámetros 109 | 1. Lee el texto de [pase de parametros](../clases/params.md). 110 | 1. Escribe un programa en el cual ejemplifiques el paso de parámetros 111 | **por valor** y **por referencia** utilizando los modificadores **ref**, **out** e **in**. 112 | 113 | ## Sobrecargado de Operadores 114 | ### Dominó 115 | Implementa la clase **Domino** siguiendo los pasos: 116 | 117 | 1. Declara la clase **Domino** con los atributos: *Espacio1* y *Espacio2*. 118 | 2. Sobrecarga el operador **+** para que puedas sumar dos objetos tipo **Domino**. 119 | El resultado debe ser un entero, con la suma de los puntos de ambas piezas. 120 | 121 | ### Duración 122 | Implementa la clase **Duración** siguiendo los pasos: 123 | 1. Declara la clase **Duración** con los atributos: *horas*, *minutos* y *segundos*. Estos atributos puden ser propiedades. Por ejemplo, pudes guardar todo en segundos y calcular como paramentres las *horas* y *minutos*. Implementa un método para imprimir la duración en el formato *HH:MM:SS*. 124 | 2. Sobrecarga el constructor **Duración(int h, int m, int s)**. 125 | 2. Sobrecarga el constructor **Duración(int segundos)**. Dependiendo de la implementación del paso 1, puede ser que debas extraer las horas y los minutos. 126 | 3. Sobrecarga el operador **+** para que puedas sumar dos objetos tipo **Duración**. 127 | 128 | 129 | # Unidad 3: Herencia 130 | ## Alumnos 131 | Debes hacer un programa dónde utilices la siguiente jerarquía de clases: **Alumno**, **Licenciatura**, 132 | y **Posgrado**. La diferencia entre un alumno de Licenciatura y de Posgrado es que los alumnos de 133 | Licenciatrua hacen servicio social y residencias, y el alumno de posgrado tiene un tema de investigación. 134 | Debes: 135 | 136 | 1. Utilizar herencia. 137 | 2. Utilizar la referencia **base** y miembros de la clase base. 138 | 3. Redefinir un método en la clase derivada utilizando el modificador **new**. 139 | 4. Prueba la diferencia entre **private** y **protected** para los campos de la clase **Alumno**. 140 | 141 | ## Músicos 142 | Escribe un programa dónde utilices la siguiente jerarquía de clases: **Músico**, **Baterista**, 143 | **Bajista** y **Guitarrista**. En el método **Main()** debes crear una lista de músicos 144 | (**List**) y utilizando métodos **virtuales** hacer que los músicos ejecuten los métodos: 145 | **afina()**,**saluda()**,**toca()**. Básate en el ejemplo que vimos en clase. Importante: 146 | no debes utilizar clases abstractas ni interfaces. 147 | 148 | 149 | # Unidad 4: Polimorfismo 150 | ## Clases Abstractas 151 | 152 | ### Músicos Abstractos 153 | Implementa el programa de **Músico** que hiciste en el tema de Herencia pero con clases abstractas. 154 | Los métodos Saluda(), Afina(), Toca() ahora deben ser **abstract**. 155 | 156 | ### Ilustrador 157 | Basándote en el programa a continuación, terminalo pero 158 | utilizando el concepto de clases abstractas. 159 | 160 | ```csharp 161 | using System; 162 | using System.Collections.Generic; 163 | 164 | namespace figura 165 | { 166 | class Figura 167 | { 168 | protected int x; 169 | protected int y; 170 | protected string color; 171 | 172 | public Figura(int x, int y, string c){ 173 | this.x = x; this.y = y; color = c; 174 | } 175 | 176 | public void dibuja() 177 | { 178 | Console.WriteLine("Se dibuja una figura color {0}", 179 | color); 180 | } 181 | 182 | public void printColor() { 183 | Console.WriteLine(color); 184 | } 185 | } 186 | 187 | class Circulo : Figura { 188 | public Circulo(int x, int y, string c):base(x , y, c){ 189 | } 190 | 191 | public new void dibuja(){ 192 | Console.WriteLine("Se dibuja un circulo {0}", color); 193 | } 194 | } 195 | 196 | class Rect : Figura { 197 | public Rect(int x, int y, string c):base(x , y, c){ 198 | } 199 | } 200 | class Program{ 201 | static void Main(string[] args){ 202 | List figuras = new List(); 203 | figuras.Add(new Circulo(12,13,"verde")) ; 204 | figuras.Add(new Rect(12,13,"azul")) ; 205 | figuras.Add(new Rect(12,13,"rojo")) ; 206 | figuras.Add(new Circulo(12,13,"rojo")) ; 207 | foreach (var item in figuras){ 208 | item.dibuja(); 209 | } 210 | Circulo r = new Circulo(10,10,"rojo"); 211 | r.dibuja(); 212 | } 213 | } 214 | } 215 | ``` 216 | 217 | ## Interfaces 218 | Debes hacer que tu clase abstracta **Figura** implemente la interfaz **IComparable** como vimos en clase. 219 | En este caso las figuras se van a comparar por su area. Para esto debes agregar el método 220 | abastracto **public abstract decimal Área()** a la clase Figura. Ya con el método implementado 221 | en las clases derivadas, ahora si, compara las áreas e implementa el método **CompareTo**. 222 | [Aquí esta la documentación de IComparable](https://learn.microsoft.com/es-mx/dotnet/api/system.icomparable?view=net-6.0). 223 | Una vez implementada la interfaz, haz una lista de figuras con distintas áreas, ordénalas y mustra sus datos. 224 | 225 | 226 | ## Generics 227 | ### Stack 228 | Implementa la clase **genérica** Stack, la cual sea eso una Pila. Debe 229 | incluir los métodos push() y pop() y debe lanzar una excepción en caso de que 230 | la pila se desborde o se intente hacer pop() a una pila vacía. Básate en el 231 | ejercicio visto en clase. Prueba tu clase con varios tipos de datos. 232 | 233 | 234 | ### Cola 235 | *Reto OPCIONAL:* 236 | 237 | Utilizando las ideas vistas en la clase **Stack\** ahora intenta hacer 238 | una Cola. La cola funciona como una estructura FIFO (First In, First Out), 239 | es decir, el primero que entra es el primero que sale. Puedes utilizar un arreglo y recorrer los 240 | elementos como en una fila del mundo real. A diferencia de la Pila, ahora necesitamos 241 | dos apuntadores, uno que nos indica dónde esta el inicio de la fila (el último que se formó) 242 | y otro que indique quien es el que sigue en el turno. Los métodos ahora son **EnQueue** y 243 | **DeQueue()**. 244 | 245 | 246 | # Unidad 5: Excepciones 247 | En la tarea de la Unidad 6, debes agregar las excepciones necesarias, por ejemplo 248 | cuando el archivo que deseamos abrir no exista. También cuando haya algún error 249 | en el procesamiento del archivo. 250 | 251 | # Unidad 6: Archivos 252 | 253 | Crea una clase llamada **Producto** y otra **ProductoDB** la cual lea y escriba 254 | objetos tipo **Producto** a un archivo, similar a lo visto en clase. Debes de 255 | atrapar las posibles excepciones, como se vió en clase. 256 | 257 | La clase **Producto** debe tener los siguientes atributos: 258 | 259 | | atributo | tipo | 260 | | ---------------------|----------------| 261 | | Código | String | 262 | | Descripción | Decimal | 263 | | Departamento | Int | 264 | | Likes | Int | 265 | | Precio | Decimal | 266 | 267 | 1. Debes guardar los datos en un archivo tipo TEXTO. 268 | 2. También en un archivo tipo BINARIO. 269 | 3. Haz un método llamado GetDepartment(int Depto) que lea los productos del 270 | archivo, pero muestre en pantalla solo los productos de un departamento. 271 | Digamos filtra los productos por departamento. 272 | 4. Haz un método que lea los **Productos** de un archivo y los ordene por Likes, 273 | después los muestre en la consola. Para esto puedes utilizar el método de interfaces 274 | o investigar otros métodos como Delegados o LINQ, si es así, debes poder explicar su 275 | funcionamiento. 276 | 5. Escibe otro programa que agregue (Append) los productos de un archivo a otro archivo 277 | ya existente. 278 | -------------------------------------------------------------------------------- /2022/\: -------------------------------------------------------------------------------- 1 | 2 | # Tareas de Programación Orientada a Objetos 3 | 4 | # Unidad 1: El Paradigma Orientado a Objetos 5 | 6 | ## UML 7 | 8 | 1. Agrega la cardinalidad o multiplicidad para las asociaciones del siguiente diagrama de clases, justifica tus decisiones: 9 | 10 | ![Documento de Apoyo](../imgs/card.png) 11 | 12 | 2. Completa los tipos de asociación (Agregación y Composición) y multiplicidad que hay entre las clases siguientes y explica porque es de ese tipo. 13 | 14 | ![Documento de Apoyo](../imgs/agg.png) 15 | 16 | 3. Haz el diagrama de clases del siguiente sistema: 17 | ``` 18 | Nos piden hacer una aplicación para llevar una bitácora de libros 19 | que estamos leyendo y los que ya terminamos de leer. 20 | En la App podemos buscar libros por autor, categoría, título y calificación. 21 | Una vez que encontramos un libro, podemos agregarlo a nuestra biblioteca e indicar 22 | si lo estamos leyendo o ya terminamos de leer. También le podemos poner una calificación. 23 | Los libros pueden tener más de un autor, si buscamos un autor podemos ver la 24 | lista de los libros que ha escrito. En caso de que haya traducciones o reediciones 25 | se consideran como el mismo libro. 26 | 27 | OPCIONAL: Podemos indicar si un libro se lo prestamos a un amigo, desde que fecha y 28 | tenemos su contacto para recordarle que nos lo regrese. 29 | ``` 30 | 31 | # Unidad 2: Clases y Objetos 32 | ## Programa básico Películas 33 | 34 | De acuerdo a los ejemplos vistos en clase y la lectura. Implementa en c# la 35 | clase *Pelicula* con los siguientes atributos **públicos**: 36 | 37 | ### Pelicula 38 | | atributo | tipo | 39 | | ---------------------|----------------| 40 | | titulo | String | 41 | | año | Int16 | 42 | | país | String | 43 | | director | String | 44 | 45 | 46 | 1. Como primer paso crea solo la clase con los atributos públicos e 47 | inicializalos en **Program.Main()** directamente. 48 | 2. Crea dos objetos tipo Pelicula con dos peliculas ganadoras de un Oscar. 49 | 3. Ahora modifica el programa para que imprima en la consola el titulo y año de las peliculas. 50 | Para esto, agrega un método llamado Imprime() a la clase Pelicula. 51 | Sube la primera versión a GitHub. 52 | 4. Ahora cambia los atributos a **private**. Agrega los métodos necesarios para 53 | crear los objetos y acceder a los atributos (campos en C#) de la siguiente manera: 54 | 55 | ```csharp 56 | class Program 57 | { 58 | static void Main(){ 59 | 60 | Pelicula p1 = new Pelicula(); 61 | p1.SetTitulo("La La Land"); 62 | p1.SetAño(2016); 63 | Console.WriteLine("{0}({1})", p1.GetTitulo(), p1.GetAño()); 64 | } 65 | } 66 | ``` 67 | Sube esta nueva versión a GitHub. 68 | 69 | 5. Por último agrega dos constructores sobrecargados: *Pelicula()* y 70 | *Pelicula(string titulo, Int16 año )*. Actualiza la 71 | versión a GitHub. 72 | 73 | 74 | ## Lista de Películas 75 | 76 | Utilizando la bibliteca *System.Collections.Generic* crea una lista de 5 peliculas. Utilizando la lista genérica **List**. 77 | 1. Crea la lista en *Main()* y agrega directamente las peliculas a la lista, por ejemplo para la clase **Persona** sería de esta manera (fragmento): 78 | 79 | ```csharp 80 | List personas = new List(); 81 | 82 | persona.Add(new Persona ("pam")); 83 | persona.Add(new Persona ("tom")); 84 | persona.Add(new Persona ("jim")); 85 | 86 | ``` 87 | 2. Utiliza un ciclo **foreach** para iterar por la lista e imprimir las peliculas. 88 | 89 | ## Actores 90 | Agrega a tu clase **Pelicula** un atributo **actores** de tipo **List** 91 | Tu clase debe permitir el siguiente funcionamiento: 92 | 93 | ```csharp 94 | class Program 95 | { 96 | static void Main(){ 97 | 98 | Pelicula p1 = new Pelicula("La La Land", 2016); 99 | p1.AgregarActor(new Actor("Ryan Gosling", 1980)); 100 | p1.AgregarActor(new Actor("Emma Stone", 1988)); 101 | 102 | p1.ImprimeActores(); 103 | 104 | } 105 | } 106 | ``` 107 | 108 | ## Paso de parámetros 109 | 1. Lee el texto de [pase de parametros](../clases/params.md). 110 | 1. Escribe un programa en el cual ejemplifiques el paso de parámetros 111 | **por valor** y **por referencia** utilizando los modificadores **ref**, **out** e **in**. 112 | 113 | ## Sobrecargado de Operadores 114 | ### Dominó 115 | Implementa la clase **Domino** siguiendo los pasos: 116 | 117 | 1. Declara la clase **Domino** con los atributos: *Espacio1* y *Espacio2*. 118 | 2. Sobrecarga el operador **+** para que puedas sumar dos objetos tipo **Domino**. 119 | El resultado debe ser un entero, con la suma de los puntos de ambas piezas. 120 | 121 | ### Duración 122 | Implementa la clase **Duración** siguiendo los pasos: 123 | 1. Declara la clase **Duración** con los atributos: *horas*, *minutos* y *segundos*. Estos atributos puden ser propiedades. Por ejemplo, pudes guardar todo en segundos y calcular como paramentres las *horas* y *minutos*. Implementa un método para imprimir la duración en el formato *HH:MM:SS*. 124 | 2. Sobrecarga el constructor **Duración(int h, int m, int s)**. 125 | 2. Sobrecarga el constructor **Duración(int segundos)**. Dependiendo de la implementación del paso 1, puede ser que debas extraer las horas y los minutos. 126 | 3. Sobrecarga el operador **+** para que puedas sumar dos objetos tipo **Duración**. 127 | 128 | 129 | # Unidad 3: Herencia 130 | ## Alumnos 131 | Debes hacer un programa dónde utilices la siguiente jerarquía de clases: **Alumno**, **Licenciatura**, 132 | y **Posgrado**. La diferencia entre un alumno de Licenciatura y de Posgrado es que los alumnos de 133 | Licenciatrua hacen servicio social y residencias, y el alumno de posgrado tiene un tema de investigación. 134 | Debes: 135 | 136 | 1. Utilizar herencia. 137 | 2. Utilizar la referencia **base** y miembros de la clase base. 138 | 3. Redefinir un método en la clase derivada utilizando el modificador **new**. 139 | 4. Prueba la diferencia entre **private** y **protected** para los campos de la clase **Alumno**. 140 | 141 | ## Músicos 142 | Escribe un programa dónde utilices la siguiente jerarquía de clases: **Músico**, **Baterista**, 143 | **Bajista** y **Guitarrista**. En el método **Main()** debes crear una lista de músicos 144 | (**List**) y utilizando métodos **virtuales** hacer que los músicos ejecuten los métodos: 145 | **afina()**,**saluda()**,**toca()**. Básate en el ejemplo que vimos en clase. Importante: 146 | no debes utilizar clases abstractas ni interfaces. 147 | 148 | 149 | # Unidad 4: Polimorfismo 150 | ## Clases Abstractas 151 | 152 | ### Músicos Abstractos 153 | Implementa el programa de **Músico** que hiciste en el tema de Herencia pero con clases abstractas. 154 | Los métodos Saluda(), Afina(), Toca() ahora deben ser **abstract**. 155 | 156 | ### Ilustrador 157 | Basándote en el programa a continuación, terminalo pero 158 | utilizando el concepto de clases abstractas. 159 | 160 | ```csharp 161 | using System; 162 | using System.Collections.Generic; 163 | 164 | namespace figura 165 | { 166 | class Figura 167 | { 168 | protected int x; 169 | protected int y; 170 | protected string color; 171 | 172 | public Figura(int x, int y, string c){ 173 | this.x = x; this.y = y; color = c; 174 | } 175 | 176 | public void dibuja() 177 | { 178 | Console.WriteLine("Se dibuja una figura color {0}", 179 | color); 180 | } 181 | 182 | public void printColor() { 183 | Console.WriteLine(color); 184 | } 185 | } 186 | 187 | class Circulo : Figura { 188 | public Circulo(int x, int y, string c):base(x , y, c){ 189 | } 190 | 191 | public new void dibuja(){ 192 | Console.WriteLine("Se dibuja un circulo {0}", color); 193 | } 194 | } 195 | 196 | class Rect : Figura { 197 | public Rect(int x, int y, string c):base(x , y, c){ 198 | } 199 | } 200 | class Program{ 201 | static void Main(string[] args){ 202 | List figuras = new List(); 203 | figuras.Add(new Circulo(12,13,"verde")) ; 204 | figuras.Add(new Rect(12,13,"azul")) ; 205 | figuras.Add(new Rect(12,13,"rojo")) ; 206 | figuras.Add(new Circulo(12,13,"rojo")) ; 207 | foreach (var item in figuras){ 208 | item.dibuja(); 209 | } 210 | Circulo r = new Circulo(10,10,"rojo"); 211 | r.dibuja(); 212 | } 213 | } 214 | } 215 | ``` 216 | 217 | ## Interfaces 218 | Debes hacer que tu clase abstracta **Figura** implemente la interfaz **IComparable** como vimos en clase. 219 | En este caso las figuras se van a comparar por su area. Para esto debes agregar el método 220 | abastracto **public abstract decimal Área()** a la clase Figura. Ya con el método implementado 221 | en las clases derivadas, ahora si, compara las áreas e implementa el método **CompareTo**. 222 | [Aquí esta la documentación de IComparable](https://learn.microsoft.com/es-mx/dotnet/api/system.icomparable?view=net-6.0). 223 | 224 | 225 | ## Generics 226 | ### Stack 227 | Implementa la clase **genérica** Stack, la cual sea eso una Pila. Debe 228 | incluir los métodos push() y pop() y debe lanzar una excepción en caso de que 229 | la pila se desborde o se intente hacer pop() a una pila vacía. Básate en el 230 | ejercicio visto en clase. Prueba tu clase con varios tipos de datos. 231 | 232 | 233 | ### Cola 234 | *Reto Adicional OPCIONAL:* 235 | 236 | Utilizando las ideas vistas en la clase **Stack\** ahora intenta hacer 237 | una Cola. La cola funciona como una estructura FIFO (First In, First Out), 238 | es decir, el primero que entra es el primero que sale. Puedes utilizar un arreglo y recorrer los 239 | elementos como en una fila del mundo real. A diferencia de la Pila, ahora necesitamos 240 | dos apuntadores, uno que nos indica dónde esta el inicio de la fila (el último que se formó) 241 | y otro que indique quien es el que sigue en el turno. Los métodos ahora son **EnQueue** y 242 | **DeQueue()**. 243 | 244 | 245 | # Unidades 5 y 6 Excepciones y Archivos 246 | 247 | Crea una clase llamada **Producto** y otra **ProductoDB** la cual lea y escriba 248 | objetos tipo **Producto** a un archivo, similar a lo visto en clase. Debes de 249 | atrapar las posibles excepciones, como se vió en clase. 250 | 251 | La clase **Producto** debe tener los siguientes atributos: 252 | 253 | | atributo | tipo | 254 | | ---------------------|----------------| 255 | | Código | String | 256 | | Descripción | Decimal | 257 | | Departamento | Int | 258 | | Likes | Int | 259 | | Precio | Decimal | 260 | 261 | 1. Debes guardar los datos en un archivo tipo TEXTO. 262 | 2. También en un archivo tipo BINARIO. 263 | 3. Haz un método llamado GetDepartment(int Depto) que lea los productos del 264 | archivo, pero muestre en pantalla solo los productos de un departamento. 265 | Digamos filtra los productos por departamento. 266 | 4. Haz un método que lea los **Productos** de un archivo y los ordene por Likes, 267 | después los muestre en la consola. Para esto puedes utilizar el método de interfaces 268 | o investigar otros métodos como Delegados o LINQ, si es así, debes poder explicar su 269 | funcionamiento. 270 | 5. Escibe otro programa que agregue (Append) los productos de un archivo a otro archivo 271 | ya existente. 272 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | ## Programación Orientada a Objetos 4 | 5 | El estilo de programación orientada a objetos sigue vigente aun 6 | después de más de cincuenta años de su origen. El paradigma, propuesto en 1967, ha influido a los diseñadores de lenguajes de programción desde entonces y actualmente se incluye en lenguajes populares, como Java, C#, Kotlin, Javascript o Python. 7 | 8 | Este curso básico de programación orientada a objetos lo abordaremos con una perspectiva moderna, incluyendo algunos elementos de programación funcional y dinámica los cuales también han sido adoptados por lenguajes recientes. 9 | 10 | Los lenguajes que utilizaremos en el curso serán C# y Javascript. 11 | 12 | ## Temario. 13 | 0. [Ambiente de desarrollo](./ambiente/ambiente.md) 14 | 1. [.net core](./ambiente/ambiente.md#net-core) 15 | 2. Visual Studio Code 16 | 3. git 17 | 4. GitHub 18 | 19 | 1. Introducción al paradigma de la programación orientado a objetos 20 | 1. Elementos del modelo de objetos: clases, objetos, abstracción, modularidad, encapsulamiento, herencia y polimorfismo. 21 | 2. Lenguaje de modelado unificado: diagrama de clases. 22 | 23 | 2. Clases y objetos 24 | 1. Declaración de [clases](./clases/clases.md): atributos, métodos, encapsulamiento. 25 | 2. Instanciación de una clase. 26 | 3. Referencia al objeto actual. 27 | 4. Métodos: declaración, mensajes, [paso de parámetros](./clases/params.md), retorno de valores. 28 | 5. Constructores y destructores: declaración, uso y aplicaciones. 29 | 6. Sobrecarga de métodos. 30 | 7. Sobrecarga de operadores: Concepto y utilidad, operadores unarios y binarios. 31 | 32 | 3. Herencia 33 | 1. Definición: clase base, clase derivada. 34 | 2. Clasificación. herencia simple, herencia múltiple. 35 | 3. Reutilización de miembros heredados. 36 | 4. Referencia al objeto de la clase base. 37 | 5. Constructores y destructores en clases derivadas. 38 | 6. Redefinición de métodos en clases derivadas. 39 | 40 | 4. Polimorfismo 41 | 1. Definición. 42 | 2. Clases abstractas: definición, métodos abstractos, implementación de clases abstractas, modelado de clases abstractas. 43 | 3. Interfaces: definición, implementación de interfaces, herencia de interfaces. 44 | 4. Variables polimórficas (plantillas): definición, uso y aplicaciones. 45 | 5. Reutilización de código. 46 | 47 | 5. Excepciones 48 | 1. Definición. 49 | 2. Tipos de excepciones. 50 | 3. Propagación de excepciones. 51 | 4. Gestión de excepciones: manejo de excepciones, lanzamiento de excepciones. 52 | 5. Creación y manejo de excepciones definidas por el usuario. 53 | 54 | 6. Flujos y Archivos. 55 | 1. Definición. 56 | 2. Clasificación: Archivos de texto y binarios. 57 | 3. Operaciones básicas y tipos de acceso. 58 | 4. Manejo de objetos persistentes. 59 | -------------------------------------------------------------------------------- /ambiente/ambiente.md: -------------------------------------------------------------------------------- 1 | # Ambiente de desarrollo 2 | 3 | ## .NET Core 4 | .NET Core es una versión multi-plataforma y de código libre de .NET. Se incluyen bibliotecas para programar sitios web, servicios web y aplicaciones de consola. El lenguaje de programación nativo es C#. 5 | 6 | Como primer paso vamos a instalar el SDK de .NET Core versión 2.2, el cual puedes bajar directamente de [dotnet.microsoft.com](https://dotnet.microsoft.com/download/dotnet-core/2.2). Elige la instalación para tu sistema operativo y arquitectura (64 o 32 bits). 7 | 8 | El **framework**, incluye un programa de línea de comandos (en inglés CLI) llamado *dotnet* con el cual vamos a administrar nuestro código y los ejecutables de **.NET**. Vamos a revisar que esté instalado, para esto abre una terminal. En windows se tienen **cmd.exe** y **Power Shell**, en macOS y Linux tenemos la **Terminal**. 9 | 10 | Vamos a ver que versiones del **.NET Core** tenemos instalado en nuestra computadora: 11 | 12 | ``` 13 | dotnet --info 14 | ``` 15 | 16 | Al ejecutar el comando debemos ver un listado de los que tenemos instalado localmente. 17 | 18 | ### Comandos de todos los días 19 | 20 | #### Crear un proyecto de consola 21 | El comando **dotnet new** ([documentación](https://docs.microsoft.com/en-us/dotnet/core/tools/dotnet-new?tabs=netcore22)) nos permite crear un nuevo proyecto, archivo de configuración o solución a partir de una plantilla. La plantilla **console** nos permite crear un proyecto tipo consola. Es importante especificar **-o ** para que se cree un nuevo directorio llamado **** y se genere el nuevo proyecto dentro de el. El modificador **-o** también se puede indicar como **--output**. El comando crea un nuevo directorio llamdo **obj**, un archivo de configuración **.csproj** y un programa de ejemplo llamado **Program.cs**. 22 | 23 | Vamos a crear un nuevo proyecto dentro del directorio **OOP**, si no haz creado este directorio lo creamos primero y no movemos a el. En Windows: 24 | 25 | ``` 26 | mkdir OOP 27 | cd OOP 28 | ``` 29 | 30 | Ahora creamos un proyecto llamado **prueba**: 31 | 32 | ``` 33 | dotnet new console -o prueba 34 | ``` 35 | 36 | El comando nos muestra la siguiente información: 37 | 38 | ``` 39 | The template "Console Application" was created successfully. 40 | 41 | Processing post-creation actions... 42 | Running 'dotnet restore' on prueba\prueba.csproj... 43 | Restore completed in 81.52 ms for 44 | D:\OOP\prueba\prueba.csproj. 45 | Restore succeeded. 46 | ``` 47 | 48 | Vamos a cambiarnos al directorio donde se generó el proyecto. 49 | Veamos también el contenido del directorio. 50 | 51 | ``` 52 | cd prueba 53 | dir 54 | ``` 55 | El comando *dir* nos muestra el contenido del directorio: 56 | ``` 57 | Directory: D:\OOP\prueba 58 | 59 | Mode LastWriteTime Length Name 60 | ---- ------------- ------ ---- 61 | d----- 8/27/2019 1:19 PM obj 62 | -a---- 8/27/2019 1:19 PM 188 Program.cs 63 | -a---- 8/27/2019 1:19 PM 178 prueba.csproj 64 | 65 | ``` 66 | Podemos ver el programa que se hemos generado con el comando **more**: 67 | ``` 68 | more .\Program.cs 69 | ``` 70 | ``` 71 | using System; 72 | namespace prueba 73 | { 74 | class Program 75 | { 76 | static void Main(string[] args) 77 | { 78 | Console.WriteLine("Hello World!"); 79 | } 80 | } 81 | } 82 | ``` 83 | 84 | En la siguiente sección vamos a editar el programa utilizando el editor **Visual Studio Code**, por lo pronto simplemente lo vamos a ejecutar. 85 | 86 | #### Compilar y ejecutar un proyecto 87 | 88 | Para compilar y ejecutar el programa utilizamos el comando **run**: 89 | 90 | ``` 91 | dotnet run 92 | ``` 93 | Vemos como resultado: 94 | 95 | ``` 96 | Hello World! 97 | ``` 98 | 99 | Al compilar se genera un archivo ejecutable llamado *prueba.exe* el cual se guarda dentro de un nuevo directorio llamado *bin*. Como ejercicio busca el directorio donde se encuentra el archivo ejectable. 100 | 101 | ## Visual Studio Code 102 | 103 | Aunque vamos a utilizar el comando *dotnet* para la gestión de nuestros proyectos necesitamos un editor de texto para la edición de nuestro código. Un buena opción el editor **Visual Studio Code** el cual es un editor desarrollado por Microsoft con extensiones para programar en C# y muchos otros lenguajes. Lo bajamos de [code.visualstudio.com](https://code.visualstudio.com/). 104 | 105 | ## git 106 | 107 | ## GitHub 108 | 109 | 110 | -------------------------------------------------------------------------------- /clases/clases.md: -------------------------------------------------------------------------------- 1 | 2 | ## Declaración de una clase 3 | 4 | Una *clase* nos permite especificar que atributos y comportamiento tendrán los 5 | objetos definidos por ella. 6 | 7 | Por ejemplo, si desamos tener objetos tipo *Bicicleta*, debemos definir la 8 | clase *Bicicleta* con atributos que para nuestro programa representen a una 9 | bicileta: 10 | 11 | | atributo | tipo | 12 | | ---------------------|----------------| 13 | | marca | String | 14 | | color | String | 15 | | velocidad_actual | Int16 | 16 | 17 | En la clase también especificamos el comportamiento que tendrán los objetos 18 | tipo *Bicicleta*. Esto lo hacemos declarando ciertos métodos dentro de la 19 | clase: 20 | 21 | | método | tipo-regreso | argumentos | descripción | 22 | | --------------------------|----------------|----------------|-------------------------------------------------| 23 | | imprime() | void | | imprime en consola el estado actual del objeto | 24 | | velocidad_actual() | Int16 | | velocidad actual de la bicicleta | 25 | | incrementa_velocidad() | void | | incrementa la velocidad actual de la bicicleta | 26 | 27 | 28 | En C# le damos el nombre de **métodos instancia**, a estos métodos, ya que no 29 | tiene sentido llamar al método **imprime()** si no está asociado a un objeto. 30 | Primero debemos crear un objeto, para luego pedirle que imprima sus datos. 31 | 32 | Una clase es un contenedor donde especificamos aquellos atributos y métodos 33 | que hemos decidido tendrán un nuevo tipo de objetos. 34 | 35 | Decimos que una clase es una **abstracción**, por que nos permite primero 36 | seleccionar que atributos y métodos nos interesa que tengan nuestras bicicletas 37 | para una aplicación determinada. Por ejemplo, en este caso ignoramos 38 | atributos como el precio, altura del asiento, etc. que en otras aplicaciones 39 | podrían ser importantes. También podemos utilizar y pensar en los objetos tipo 40 | bicicleta sin entrar en detalles de como se programó el método *imprime()* o 41 | **incrementa_velocidad()**. 42 | 43 | Vamos a definir una nueva clase. Empezamos por declarar un nuevo contenedor 44 | o bloque **{ }**, especificando antes que es una clase y dándole un nombre: 45 | 46 | ```csharp 47 | class Bicicleta 48 | { 49 | 50 | } 51 | ``` 52 | 53 | El bloque **{ }** es *muy* importante, en este caso está vacio. Vamos a 54 | agregar dentro del bloque algunos atributos: 55 | 56 | ```csharp 57 | class Bicicleta 58 | { 59 | public String marca; 60 | public String color; 61 | public Int16 velocidad_actual; 62 | } 63 | ``` 64 | 65 | Listo, hemos especificado que atributos tendrán nuestras bicicletas, aunque 66 | no tengan ningún comportamiento todavía. Vamos a *instanciar* o crear objetos 67 | del tipo *Bicicleta*. Esto lo vamos hacer dentro del método **Main()** de la clase 68 | **Program**. 69 | 70 | 71 | ```csharp 72 | using System; 73 | using System.Collections.Generic; 74 | 75 | class Bicicleta 76 | { 77 | public String marca; 78 | public String color; 79 | public Int16 velocidad_actual; 80 | } 81 | 82 | class Program 83 | { 84 | static void Main(string[] args) 85 | { 86 | Bicicleta bici = new Bici(); 87 | bici.marca = "Huffy"; 88 | bici.color = "Rojo"; 89 | bici.velocidad_actual = 2; 90 | 91 | Console.WriteLine("Marca:{0}, Color:{1}, Velocidad actual:{2}",bici.marca, bici.color, bici.velocidad_actual ); 92 | } 93 | } 94 | 95 | ``` 96 | 97 | 98 | 99 | 100 | 101 | 102 | -------------------------------------------------------------------------------- /clases/params.md: -------------------------------------------------------------------------------- 1 | # Paso de parámetros 2 | 3 | El paso de parámetros no es un tema exclusivo de la programación 4 | orientada a objetos, ya que la mayoría de los lenguajes de programación 5 | permiten la definición de [funciones que aceptan parámetros](https://es.wikipedia.org/wiki/Argumento_(inform%C3%A1tica)). 6 | Independientemente del lenguaje que estemos utilizando, es importante 7 | conocer como se realiza internamente el paso de parámetros, ya que esto 8 | nos permitirá hacer más eficientes nuestros programas. 9 | 10 | Para entender bien los conceptos de paso de parámetros en C#, 11 | es importante recordar la diferencia entre los tipos de 12 | variables: [de valor](https://docs.microsoft.com/es-mx/dotnet/csharp/language-reference/keywords/value-types) y [de referencia](https://docs.microsoft.com/es-mx/dotnet/csharp/language-reference/keywords/reference-types). 13 | 14 | Cuando ejecutamos un método que requiere parámetros 15 | decimos que le enviamos o pasámos los valores que necesita como argumentos, ya sea de manera 16 | literal o utilizando variables. 17 | 18 | Por ejemplo, analizemos este fragmento de código: 19 | 20 | ```csharp 21 | 22 | Duplicador d = new Duplicador(); 23 | 24 | d.duplica(1); 25 | 26 | int x = 2; 27 | 28 | d.duplica(x); 29 | 30 | ``` 31 | 32 | En el código anterior estamos llamando dos veces al método **duplica(int x)** del 33 | objeto **d**, el método se ha declarado con un parametro **x** de tipo **int**. 34 | Al momento de ejecución le pasamos como argumento un entero literal **1**, después una 35 | variable **int x**, inicializada en **2**. La clase **Duplicador** podría estar implementada de 36 | la siguiente manera: 37 | 38 | ```csharp 39 | class Duplicador{ 40 | 41 | public void duplica(int n) { 42 | n = n*2; 43 | } 44 | 45 | } 46 | ``` 47 | 48 | Por defecto en C# el paso de parámetros se hace **por valor**, 49 | veamos el concepto en el ejemplo y preguntándonos ¿Qué valor 50 | tiene **x** al imprimirse?: 51 | 52 | ```csharp 53 | Duplicador d = new Duplicador(); 54 | int x = 2; 55 | d.duplica(x); 56 | Console.WriteLine(x); 57 | ``` 58 | 59 | En el caso de pase **por valor**, **se hace una copia** del objeto que 60 | se está pasando (en este caso **x**) y 61 | se guarda localmente en **n**. El hacer una copia tiene un costo adicional 62 | y además en el caso de que se modifique **n**, (como sucede aquí) este cambio 63 | solo sucederá en la variable local (**n**) y no en el argumento (**x**). En este caso se debe 64 | imprimir **2**, por lo que ya sabemos. 65 | 66 | Ahora, esto es distinto cuando pasamos variables **tipo referencia**, 67 | veamos otro ejemplo: 68 | 69 | ```csharp 70 | using System; 71 | 72 | class Persona 73 | { 74 | public string nombre; 75 | public string apellido; 76 | 77 | public Persona() { 78 | nombre = 'Fulano'; 79 | apellido = 'De tal'; 80 | } 81 | } 82 | 83 | class Anonymous{ 84 | 85 | static public void anonimiza(Persona p) { 86 | p.nombre = 'xxxxxxxxx'; 87 | p.apellido = 'xxxxxxxxx'; 88 | } 89 | 90 | 91 | static void Main(){ 92 | Persona espía = new Persona(); 93 | 94 | Console.WriteLine(espía.nombre); 95 | anonimiza(espía); 96 | Console.WriteLine(espía.nombre); 97 | 98 | } 99 | } 100 | ``` 101 | 102 | Ahora **anonimiza(Persona p)** recibe una referencia al objeto que se envía como 103 | argumento, en este caso **espía** y se copia a **p**. Esto significa para empezar, que aunque también 104 | se copia el valor, esta copia es una **referencia** al objeto original (argumento). El contar con una referencia 105 | significa que a diferencia de una variable tipo valor, como en el ejemplo anterior, 106 | ahora **si** podríamos modificar al objeto que recibimos, ya que 107 | tenemos su referencia. ¡Esto puede ser muy peligroso!, aunque como la mayoría 108 | de las cosas peligrosas, pueden ser benéficas en ciertos casos. 109 | ¿Qué se imprimiría en en el programa anterior? 110 | 111 | Veamos como podemos controlar el comportamiento del pase de parámetros con estas palabras clave: 112 | 113 | * *ref* con esta palabra especificamos que el paso de parámetros se hará por referencia incluso cuando las 114 | variables sean de tipo valor. Nos permite modificar el valor del parámetro. 115 | 116 | * *in* con esta palabra especificamos que el paso de parámetros se hará por referencia pero evitando que se modifique el parámetro original. 117 | 118 | * *out* El objetivo es inicializar el valor de los parámetros y también se pasan por referencia. 119 | 120 | 121 | ## ref 122 | Vamos a cambiar la implementación del método **incrementa(int n)** del código que vimos anteriormente para ver 123 | que sucede cuando pasamos un parámetro **tipo valor** con el modificador **ref**. Es solo cuestión de agregar **ref** 124 | al especificar el parámetro: 125 | 126 | ```csharp 127 | public void duplica_ref( ref int n) { 128 | n*=2; 129 | } 130 | ``` 131 | 132 | Cuando un parámetro se pasa por referencia, se pasa **directamente** una referencia a la variable externa. Es decir, 133 | No se hace una copia. Esto implica que si se hace un cambio a la variable local, realmente se está haciendo 134 | el cambio en las dos variables, la local y la externa. 135 | 136 | ```csharp 137 | using System; 138 | 139 | class Duplicador{ 140 | 141 | public void duplica(int n) { 142 | n = n*2; 143 | } 144 | 145 | public void duplica_ref(ref int n) { 146 | n = n*2; 147 | } 148 | 149 | 150 | } 151 | 152 | class Program 153 | { 154 | 155 | static void Main() 156 | { 157 | Duplicador d = new Duplicador(); 158 | int x = 2; 159 | d.duplica(x); 160 | Console.WriteLine(x); 161 | d.duplica_ref(x); 162 | Console.WriteLine(x); 163 | } 164 | } 165 | 166 | ``` 167 | En este caso, en el llamado a **d.duplica(x)** no se modifica **x**, pero en **d.duplica_ref(x)** 168 | si se modifica. 169 | 170 | ¿Qué sucede si enviamos una variable tipo referencia con el modificador **ref**? En este 171 | caso funcionaría **casi** igual, como antes, si modificamos al objeto o variable dentro del método al 172 | ser una copia de la referencia original, se afectaría también a l a variable externa. Recordemos que 173 | la copia se destruye al terminar de ejecutar el método, pero el cambio persiste. 174 | 175 | Vamos a ver un caso especial importante. ¿Qué pasaría si reemplazamos el valor de la referencia dentro del método? 176 | Por ejemplo, en lugar de simplemente anonimizar, ¿que tal si reemplazamos a una persona por otra?, vamos a agregar 177 | este método a nuestra clase **Anonymous**, con una versión **por valor** y una **por referencia**: 178 | 179 | ```csharp 180 | class Anonymous{ 181 | 182 | static public void anonimiza(Persona p) { 183 | p.nombre = 'xxxxxxxxx'; 184 | p.apellido = 'xxxxxxxxx'; 185 | } 186 | static public void cambia(Persona p) { 187 | p = new Persona(); 188 | p.nombre = 'John'; 189 | p.apellido = 'Doe'; 190 | } 191 | 192 | static public void cambia_ref( ref Persona p) { 193 | p = new Persona(); 194 | p.nombre = 'John'; 195 | p.apellido = 'Doe'; 196 | } 197 | 198 | static void Main(){ 199 | Persona espía = new Persona(); 200 | 201 | Console.WriteLine(espía.nombre); 202 | anonimiza(espía); 203 | Console.WriteLine(espía.nombre); 204 | cambia(espía); 205 | Console.WriteLine(espía.nombre); 206 | cambia_ref(espía); 207 | Console.WriteLine(espía.nombre); 208 | } 209 | } 210 | 211 | ``` 212 | 213 | Si ejecutamos el código anterior veremos que el método **cambia(espía)** no reemplaza al objeto **espía**. 214 | Lo hace internamenta en la **copia** de la referencia, pero al terminar el método se destruye. En el caso 215 | de **cambia_ref(espía)**, como aquí se envia directamente la referencia, si le asignamos un nuevo valor con 216 | **p = new Persona()** se le está asignando también a la variable externa, en este caso **espía**. Por esto, 217 | el programa debería imprimir: 218 | 219 | ``` 220 | Fulano 221 | xxxxxxxxx 222 | xxxxxxxxx 223 | John 224 | ``` 225 | Cuando enviamos parámetros **por referencia** utilizando **ref** forzosamente deben de estar inicializados, 226 | incluso las variables **tipo valor**. Por ejemplo, esto marcaría error: 227 | 228 | ```csharp 229 | Duplicador d = new Duplicador(); 230 | int x; // Solo estamos declarando x, pero no la inicializamos 231 | d.duplica_ref(ref x); // ERROR 232 | Console.WriteLine(x); 233 | ``` 234 | Debemos de inicializar antes: 235 | 236 | ```csharp 237 | Duplicador d = new Duplicador(); 238 | int x = new int(); // También podríamos hacerlo de una manera más común: int x = 4; 239 | d.duplica_ref(ref x); 240 | Console.WriteLine(x); 241 | ``` 242 | 243 | En este estilo, lo hacemos utilizando un constructor. **TRIVIA:** ¿con que valor se inicializa **x**? 244 | 245 | Otra restricción es que no podemos enviar valores literales: 246 | ```csharp 247 | Duplicador d = new Duplicador(); 248 | d.duplica_ref(ref 12); //ERROR 249 | Console.WriteLine(x); 250 | ``` 251 | 252 | ## out 253 | 254 | Aunque no sea muy natural, en ocasiones queremos recibir parámetros **tipo referencia** 255 | con el proposito de modificar o inicializar los valores de los argumentos. 256 | Veamos un ejemplo, con dos métodos que hacen lo mismo, pero regresan el valor de una manera 257 | distinta: 258 | 259 | ```csharp 260 | using System; 261 | 262 | class Ejemplo { 263 | 264 | static void suma(int a, int b, out resultado){ 265 | resultado = a + b; 266 | } 267 | 268 | static int suma(int a, int b){ 269 | return a + b; 270 | } 271 | 272 | static void Main() 273 | { 274 | int x = 3; 275 | int y = 6; 276 | int r; // Es importante NO inicializar 277 | 278 | suma(x, y, out r); 279 | Console.WriteLine(r); 280 | 281 | Console.WriteLine(suma(x,y)); 282 | 283 | } 284 | } 285 | 286 | ``` 287 | Utilizando el modificador de parámetro **out**, especificamos que vamos a recibir 288 | **por referencia** una variable **no** inicializada la cual inicializaremos dentro 289 | del método. 290 | 291 | La mayoría de los casos es preferible que un método regrese un resultado en lugar de 292 | recibir un argumento en el cual se guarde el resultado. La ventaja que tiene el guardar 293 | en un parámetro tipo **out** es que podríamos regresar varios al mismo tiempo. Antes de 294 | utilizar este estilo, es recomendable que analices si no es mejor regresar varios valores 295 | utilizando una estructura, un arreglo o lista. 296 | 297 | 298 | ## in 299 | 300 | El modificador **in** es equivalente a un **ref** que nos garantiza que no habrá una modificación 301 | al parámetro que se pasa **por referencia**. Por ejemplo, en el caso anterior si en lugar de utilizar **ref** 302 | utilizamnos **in**, no podríamos hacer la modificación. Al igual que con **ref** debemos pasar como argumento 303 | una variable inicializada. 304 | 305 | ```csharp 306 | using System; 307 | 308 | class Duplicador{ 309 | 310 | public void duplica(in int n) { 311 | n = n*2; 312 | } 313 | 314 | 315 | } 316 | 317 | class Program 318 | { 319 | static void Main() 320 | { 321 | Duplicador d = new Duplicador(); 322 | int x = 2; 323 | d.duplica( in x); //Error, se intenta modificar el argumento 324 | Console.WriteLine(x); 325 | } 326 | } 327 | 328 | ``` 329 | [Documentación](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/method-parameters) 330 | 331 | 332 | 333 | 334 | -------------------------------------------------------------------------------- /imgs/agg.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mariosky/oop/ece6b42afc6ccea3d34e0c2ea6425351ccee0204/imgs/agg.png -------------------------------------------------------------------------------- /imgs/card.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mariosky/oop/ece6b42afc6ccea3d34e0c2ea6425351ccee0204/imgs/card.png --------------------------------------------------------------------------------