├── README.md ├── documentos ├── plantillas.md └── preSRC │ └── Cinema.md ├── entregas └── README.md ├── evaluaciones └── retos │ ├── README.md │ ├── reto001.md │ ├── reto002.md │ └── reto003.md ├── images ├── EjemploSintaxisH.jpg ├── SintaxisF.jpg ├── SintaxisG.jpg ├── githubReto.png ├── modelosUML │ └── plantUML │ │ ├── alumnoADE.svg │ │ ├── alumnoII.svg │ │ ├── alumnoIOI.svg │ │ ├── cinemaDC.svg │ │ ├── cinemaDO.svg │ │ ├── efectividad.svg │ │ └── jerarquiaAnimales.svg └── referenciaObjeto.png ├── plantUML ├── alumnoADE.puml ├── alumnoII.puml ├── alumnoIOI.puml ├── cinemaDC.puml ├── cinemaDO.puml ├── efectividad.puml └── jerarquiaAnimales.puml ├── src └── 000 │ └── Intervalo.java └── temario ├── README.md ├── aDiaDeHoy.md ├── casosDeUso └── README.md ├── clasesObjetos.md ├── ejercicios ├── 001 │ ├── Intervalo.java │ ├── IntervaloV0.java │ └── README.md └── README.md ├── evolucion.md ├── herencia.md ├── hood.md ├── introVistas.md ├── introduccion.md ├── miembrosClase.md ├── vistaPrivadaClases.md ├── vistaPrivadaObjetos.md ├── vistaPublicaClases.md ├── vistaPublicaClasesEjemplos.md └── vistaPublicaObjetos.md /README.md: -------------------------------------------------------------------------------- 1 | # Programación II 2 | 3 | Repo de materiales y proyectos de la asignatura **Programación II** del [Grado de Ingeniería Informática](https://www.uneatlantico.es/escuela-politecnica-superior/estudios-grado-oficial-en-ingenieria-informatica) la [Universidad Europea del Atlántico](https://www.uneatlantico.es). 4 | 5 | ## Curso [23][24] 6 | 7 | - [Temario](temario/README.md) 8 | - [A día de hoy, deberíamos saber...](temario/aDiaDeHoy.md) 9 | - [Casos de uso](temario/casosDeUso/README.md) 10 | - [Ejercicios](temario/ejercicios/README.md) 11 | - Evaluaciones 12 | - Evaluación continua: [Retos!](evaluaciones/retos/README.md) 13 | - Exámenes 14 | - Parcial: [Enunciado](https://github.com/mmasias/23-24-prg2-ep) | [Repositorio de entrega](https://github.com/mmasias/23-24-prg2-ep). 15 | - Final: [Enunciado](https://github.com/mmasias/23-24-PRG2-examenFinal) | [Repositorio de trabajo y entrega](https://classroom.github.com/a/sE-EGMrx) 16 | - Extraordinario: [Enunciado](https://docs.google.com/presentation/d/1rAec1FEdtUFlQWJBtW8YAG4o4q_w5WOmhwTutOohf7A/edit?usp=sharing) | [Repositorio de trabajo y entrega](https://classroom.github.com/a/BeIjBWlK) 17 | 18 | > ***NOTA:*** Los repositorios de entrega de exámenes estarán disponible días antes del examen. El repositorio con el enunciado del examen se activa al inicio del examen y permitirá entregas hasta la finalización del mismo. 19 | 20 | ## Herramientas et al 21 | 22 | - [Plantillas](/documentos/plantillas.md) 23 | - [PlantText](https://www.planttext.com/), para usar el formato [PlantUML](https://plantuml.com/es/) al realizar diagramas [de actividades](https://plantuml.com/es/activity-diagram-beta), [de estados](https://plantuml.com/es/state-diagram), de [clases](https://plantuml.com/es/class-diagram) y de [objetos](https://plantuml.com/es/object-diagram). 24 | - [Google Docs](https://drive.google.com/drive/u/0/my-drive) 25 | - [Visual Studio Code](https://code.visualstudio.com/) 26 | - [GIT](https://git-scm.com/) & [GitHub](https://github.com/) & Vídeo repaso ([Un repo, dos repos, un fork, varios commit & un PR](https://www.youtube.com/watch?v=p8dV1d97o4s)) 27 | 28 | ## Bibliografía & enlaces interesantes 29 | 30 | NOTA: *Algunos enlaces podrían requerir **credenciales de acceso al campus** o a otros espacios colaborativos.* 31 | 32 | - [Hoja de asistencia et-al](https://docs.google.com/spreadsheets/d/1kzA5eHJtHyxrxYVbTrbaM8zTaQAkO99sw1cy2aXucuw/edit?usp=sharing) 33 | - Libro de la asignatura 34 | - [U.Santa Tecla](https://github.com/USantaTecla-0-general/3-publicaciones), Prof. Dr. Luis Fernández 35 | -------------------------------------------------------------------------------- /documentos/plantillas.md: -------------------------------------------------------------------------------- 1 | # Documento de plantillas 2 | -------------------------------------------------------------------------------- /documentos/preSRC/Cinema.md: -------------------------------------------------------------------------------- 1 | ```java 2 | package documentos.preSRC; 3 | 4 | class Cinema { 5 | 6 | public Cinema() {} 7 | 8 | public void showMovies() {} 9 | public Ticket buyTicket(Moviegoer moviegoer, Movie movie) { 10 | return 11 | } 12 | } 13 | 14 | class Movie { 15 | 16 | public Movie(String title, String director, int length) {} 17 | 18 | public String getTitle() { 19 | return} 20 | public String getDirector() { 21 | return 22 | } 23 | public int getLength() { 24 | return 25 | } 26 | } 27 | 28 | class Ticket { 29 | 30 | public Ticket(Moviegoer moviegoer, Movie movie) {} 31 | 32 | public Movie getMovie() { 33 | return 34 | } 35 | public Moviegoer getgetMoviegoer() { 36 | return 37 | } 38 | } 39 | 40 | class Moviegoer { 41 | 42 | public Moviegoer(String name) {} 43 | public String getName() { 44 | return 45 | } 46 | } 47 | 48 | class Simulation { 49 | public static void main(String[] args) { 50 | 51 | Cinema cinesaSantander = new Cinema(); 52 | 53 | Movie interstellar = new Movie("Interstellar", "Christopher Nolan", 169); 54 | Movie lordOfTheRings = new Movie("El Señor de los Anillos", "Peter Jackson", 178); 55 | 56 | cinesaSantander.showMovies(); 57 | 58 | Moviegoer rogerWilco = new Moviegoer("Juan"); 59 | Moviegoer guybrushThreepwood = new Moviegoer("Pedro") 60 | 61 | 62 | Ticket ticket1 = cinesaSantander.buyTicket(rogerWilco, interstellar); 63 | Ticket ticket2 = cinesaSantander.buyTicket(guybrushThreepwood, lordOfTheRings); 64 | 65 | } 66 | } 67 | ``` 68 | -------------------------------------------------------------------------------- /entregas/README.md: -------------------------------------------------------------------------------- 1 | # Carpeta de entregas 2 | 3 | - Nomenclatura: **/entregas/subcarpetaPersonal/reto-###** 4 | - Nada fuera de esta carpeta. 5 | - Las subcarpetas personales deben seguir el estándar ***apellidoNombre*** 6 | - Dentro de esta subcarpeta personal, **una carpeta por reto**, con el estándar ***reto-00x*** 7 | 8 |
9 | 10 | |/entregas/fernandezIbuprofeno/reto-001/| 11 | |:-:| 12 | |![](/images/githubReto.png)| 13 | *Vista parcial del repositorio de un usuario* 14 | 15 |
16 | 17 | - Las entregas formalmente se hacen mediante un pull request a la rama del reto adecuado. 18 | 19 | ## Acerca de la entrega de los retos 20 | 21 | La entrega correcta de los retos es parte de la evaluación de los mismos. 22 | 23 | - Crear un fork del repositorio de la asignatura en su cuenta personal. 24 | - Dentro de su fork, crear su subcarpeta personal dentro de la carpeta de entrega siguiendo. 25 | - Para cada reto: 26 | - Crear la carpeta del reto ***reto-00x*** 27 | - Trabajar el reto. 28 | - Una vez concluido, enviar un pull request (PR) al repositorio de la asignatura, asegurándose de hacerlo a la rama del reto correspondiente. 29 | 30 | --- 31 | 32 | ```mermaid 33 | gitGraph 34 | commit id: "Contenido 1" 35 | commit id: "Contenido 2" 36 | commit id: "Contenido 3" 37 | commit id: "Contenido 4" 38 | commit id: "Contenido 5" 39 | branch Reto-001 40 | branch FORK_ALUMNO 41 | commit id: "Contenido 5@RepoAlumno" 42 | commit id: "AvanceAlumno" 43 | checkout main 44 | commit id: "Contenido 8" 45 | commit id: "Contenido 9" 46 | commit id: "Contenido 10" 47 | commit 48 | branch Reto-002 49 | checkout FORK_ALUMNO 50 | commit id: "AvanceAlumno+" 51 | commit id: "AvanceAlumno++" 52 | checkout Reto-001 53 | merge FORK_ALUMNO type:HIGHLIGHT tag:"Entrega Reto-001" 54 | checkout FORK_ALUMNO 55 | commit id: "AvanceAlumno+++" 56 | commit id: "AvanceAlumno++++" 57 | checkout Reto-002 58 | merge FORK_ALUMNO type:HIGHLIGHT tag:"Entrega Reto-002" 59 | checkout main 60 | commit id: "Contenido 11" 61 | commit id: "Contenido 12" 62 | ``` -------------------------------------------------------------------------------- /evaluaciones/retos/README.md: -------------------------------------------------------------------------------- 1 | # Retos 2 | 3 | Los retos se irán proponiendo, habitualmente luego de una disertación teórica. Cada uno tendrá sus reglas de resolución y serán de entrega individual, aunque se puede (y se anima) a trabajarlos en grupo. 4 | 5 | 6 | |Reto|Detalle|Entrega|Fecha límite| 7 | |-|-|:-:|-| 8 | |Proceso de creación|[Detalle del reto](/evaluaciones/retos/reto001.md)|Repo, rama entrega-001|13 feb 2024 9 | |Vista pública de una clase|[Detalle del reto](/evaluaciones/retos/reto002.md)|[📝](https://forms.gle/qu2vLRM885LuhnHt7)|27 feb 2024 10 | |Vista pública de una clase|[Detalle del reto](/evaluaciones/retos/reto003.md)|Repo, rama entrega-003| 11 | -------------------------------------------------------------------------------- /evaluaciones/retos/reto001.md: -------------------------------------------------------------------------------- 1 | # Reto 001 > Proceso de creación 2 | 3 | Desarrolle el ejercicio planteado en clase, atendiendo a las indicaciones vistas de modo que quede completamente visible el proceso de creación seguido para resolverlo. 4 | -------------------------------------------------------------------------------- /evaluaciones/retos/reto002.md: -------------------------------------------------------------------------------- 1 | # Reto 002 > Vista pública de las clases 2 | 3 | Elija uno de los siguientes conjuntos de clases y desarrolle la vista pública de las mismas: 4 | 5 | |Escenario 1|Escenario 2|Escenario 3|Escenario 4| 6 | |-|-|-|-| 7 | |Caja|Préstamo|Reserva|Ticket| 8 | -------------------------------------------------------------------------------- /evaluaciones/retos/reto003.md: -------------------------------------------------------------------------------- 1 | # Reto 003 > Vista pública de las clases 2 | 3 | Elija uno de los siguientes conjuntos de clases y desarrolle la vista pública de las mismas: 4 | 5 | |Escenario 1|Escenario 2|Escenario 3|Escenario 4| 6 | |-|-|-|-| 7 | |Centro comercial|Biblioteca|Restaurante|Cine 8 | |Fila|Libro|Reserva|Película 9 | |Cliente|Préstamo|Cliente|Ticket 10 | |Caja|Usuario|Mesa|Visitante 11 | -------------------------------------------------------------------------------- /images/EjemploSintaxisH.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mmasias/23-24-prg2/794f7676a04f28f8498ab0e55b1eedc5e9a703ed/images/EjemploSintaxisH.jpg -------------------------------------------------------------------------------- /images/SintaxisF.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mmasias/23-24-prg2/794f7676a04f28f8498ab0e55b1eedc5e9a703ed/images/SintaxisF.jpg -------------------------------------------------------------------------------- /images/SintaxisG.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mmasias/23-24-prg2/794f7676a04f28f8498ab0e55b1eedc5e9a703ed/images/SintaxisG.jpg -------------------------------------------------------------------------------- /images/githubReto.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mmasias/23-24-prg2/794f7676a04f28f8498ab0e55b1eedc5e9a703ed/images/githubReto.png -------------------------------------------------------------------------------- /images/modelosUML/plantUML/alumnoADE.svg: -------------------------------------------------------------------------------- 1 | AlumnoInversión EducativaPotencial de EmpleabilidadContribución al Mercado LaboralSatisfacción del ClienteInversiónEducativaRetorno de la InversiónCosto de la EducaciónBecas y FinanciamientoPotencialDeEmpleabilidadHabilidades AdquiridasExperiencia PrácticaProyectos y PortafolioContribuciónAlMercadoLaboralEmprendimientoInnovaciónExperiencia LaboralSatisfacciónDelClienteExperiencia EducativaServicios de SoporteActividades ExtracurricularesIncluye11Determina11Contribuye11Mide11 -------------------------------------------------------------------------------- /images/modelosUML/plantUML/alumnoII.svg: -------------------------------------------------------------------------------- 1 | AlumnoInteracción con Sistemas de InformaciónManejo de Datos del AlumnoOptimización de la Experiencia de AprendizajeInteracciónConSistemasDeInformaciónUso de Plataformas EducativasAcceso a Recursos en LíneaComunicación DigitalManejoDeDatosDelAlumnoRegistro AcadémicoPreferencias de AprendizajeRendimiento y EvaluacionesOptimizaciónDeLaExperienciaDeAprendizajePersonalización del AprendizajeAnálisis PredictivoRecomendaciones InteligentesInteractúa11Se Representa11Se Mejora11 -------------------------------------------------------------------------------- /images/modelosUML/plantUML/alumnoIOI.svg: -------------------------------------------------------------------------------- 1 | AlumnoProceso EducativoFlujo de TrabajoErgonomía EducativaProcesoEducativoMaximización de la ProductividadMinimización de RecursosObjetivos EducativosFlujoDeTrabajoProgresión EducativaPlanificación de HorariosOptimización de EspaciosErgonomíaEducativaDiseño de AulasDisposición de Entornos de AprendizajeMinimización de FatigaOptimiza11Navega11Beneficia11 -------------------------------------------------------------------------------- /images/modelosUML/plantUML/cinemaDC.svg: -------------------------------------------------------------------------------- 1 | CinemaCinema()showMovies(): voidbuyTicket(Moviegoer, Movie): TicketMovieMovie(title: String, director: String, length: int)getTitle(): StringgetDirector(): StringgetLength(): intTicketTicket(Moviegoer, Movie)getMovie(): MoviegetMoviegoer(): MoviegoerMoviegoerMoviegoer(name: String)getName(): String -------------------------------------------------------------------------------- /images/modelosUML/plantUML/cinemaDO.svg: -------------------------------------------------------------------------------- 1 | cinesaSantander: Cinemainterstellar: Movietitle: "Interstellar"director: "Christopher Nolan"length: 169lordOfTheRings: Movietitle: "El Señor de los Anillos"director: "Peter Jackson"length: 178rogerWilco: Moviegoername: "Juan"guybrushThreepwood: Moviegoername: "Pedro"ticket1: Ticketticket2: Ticket -------------------------------------------------------------------------------- /images/modelosUML/plantUML/efectividad.svg: -------------------------------------------------------------------------------- 1 | EficaciaEficienciaCompromisoEfectividadSolución -------------------------------------------------------------------------------- /images/modelosUML/plantUML/jerarquiaAnimales.svg: -------------------------------------------------------------------------------- 1 | Animalcelulascomer()Vertebradocelulashuesoscomer()romperHuesos()Invertebradocelulascomer()Mamiferocelulashuesoslabioscomer()romperHuesos()mamar()Avecelulashuesospicocomer()romperHuesos()volar()ponerHuevos()Caninocelulashuesoslabioscolmilloscomer()romperHuesos()mamar()Humanocelulashuesoslabiosraciociniocomer()romperHuesos()mamar()pensar()Ornitorrincocelulashuesospicocomer()romperHuesos()ponerHuevos()mamar() -------------------------------------------------------------------------------- /images/referenciaObjeto.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mmasias/23-24-prg2/794f7676a04f28f8498ab0e55b1eedc5e9a703ed/images/referenciaObjeto.png -------------------------------------------------------------------------------- /plantUML/alumnoADE.puml: -------------------------------------------------------------------------------- 1 | @startuml 2 | class Alumno { 3 | +Inversión Educativa 4 | +Potencial de Empleabilidad 5 | +Contribución al Mercado Laboral 6 | +Satisfacción del Cliente 7 | } 8 | 9 | class InversiónEducativa { 10 | +Retorno de la Inversión 11 | +Costo de la Educación 12 | +Becas y Financiamiento 13 | } 14 | 15 | class PotencialDeEmpleabilidad { 16 | +Habilidades Adquiridas 17 | +Experiencia Práctica 18 | +Proyectos y Portafolio 19 | } 20 | 21 | class ContribuciónAlMercadoLaboral { 22 | +Emprendimiento 23 | +Innovación 24 | +Experiencia Laboral 25 | } 26 | 27 | class SatisfacciónDelCliente { 28 | +Experiencia Educativa 29 | +Servicios de Soporte 30 | +Actividades Extracurriculares 31 | } 32 | 33 | Alumno "1" *-- "1" InversiónEducativa : Incluye > 34 | Alumno "1" *-- "1" PotencialDeEmpleabilidad : Determina > 35 | Alumno "1" *-- "1" ContribuciónAlMercadoLaboral : Contribuye > 36 | Alumno "1" *-- "1" SatisfacciónDelCliente : Mide > 37 | 38 | @enduml 39 | -------------------------------------------------------------------------------- /plantUML/alumnoII.puml: -------------------------------------------------------------------------------- 1 | @startuml 2 | class Alumno { 3 | +Interacción con Sistemas de Información 4 | +Manejo de Datos del Alumno 5 | +Optimización de la Experiencia de Aprendizaje 6 | } 7 | 8 | class InteracciónConSistemasDeInformación { 9 | +Uso de Plataformas Educativas 10 | +Acceso a Recursos en Línea 11 | +Comunicación Digital 12 | } 13 | 14 | class ManejoDeDatosDelAlumno { 15 | +Registro Académico 16 | +Preferencias de Aprendizaje 17 | +Rendimiento y Evaluaciones 18 | } 19 | 20 | class OptimizaciónDeLaExperienciaDeAprendizaje { 21 | +Personalización del Aprendizaje 22 | +Análisis Predictivo 23 | +Recomendaciones Inteligentes 24 | } 25 | 26 | Alumno "1" *-- "1" InteracciónConSistemasDeInformación : Interactúa > 27 | Alumno "1" *-- "1" ManejoDeDatosDelAlumno : Se Representa > 28 | Alumno "1" *-- "1" OptimizaciónDeLaExperienciaDeAprendizaje : Se Mejora > 29 | 30 | @enduml 31 | -------------------------------------------------------------------------------- /plantUML/alumnoIOI.puml: -------------------------------------------------------------------------------- 1 | @startuml 2 | class Alumno { 3 | +Proceso Educativo 4 | +Flujo de Trabajo 5 | +Ergonomía Educativa 6 | } 7 | 8 | class ProcesoEducativo { 9 | +Maximización de la Productividad 10 | +Minimización de Recursos 11 | +Objetivos Educativos 12 | } 13 | 14 | class FlujoDeTrabajo { 15 | +Progresión Educativa 16 | +Planificación de Horarios 17 | +Optimización de Espacios 18 | } 19 | 20 | class ErgonomíaEducativa { 21 | +Diseño de Aulas 22 | +Disposición de Entornos de Aprendizaje 23 | +Minimización de Fatiga 24 | } 25 | 26 | Alumno "1" *-- "1" ProcesoEducativo : Optimiza > 27 | Alumno "1" *-- "1" FlujoDeTrabajo : Navega > 28 | Alumno "1" *-- "1" ErgonomíaEducativa : Beneficia > 29 | 30 | @enduml 31 | -------------------------------------------------------------------------------- /plantUML/cinemaDC.puml: -------------------------------------------------------------------------------- 1 | @startuml 2 | class Cinema { 3 | +Cinema() 4 | +showMovies(): void 5 | +buyTicket(Moviegoer, Movie): Ticket 6 | } 7 | 8 | class Movie { 9 | +Movie(title: String, director: String, length: int) 10 | +getTitle(): String 11 | +getDirector(): String 12 | +getLength(): int 13 | } 14 | 15 | class Ticket { 16 | +Ticket(Moviegoer, Movie) 17 | +getMovie(): Movie 18 | +getMoviegoer(): Moviegoer 19 | } 20 | 21 | class Moviegoer { 22 | +Moviegoer(name: String) 23 | +getName(): String 24 | } 25 | 26 | Cinema -- Ticket 27 | Ticket -- Moviegoer 28 | Ticket -- Movie 29 | 30 | @enduml 31 | -------------------------------------------------------------------------------- /plantUML/cinemaDO.puml: -------------------------------------------------------------------------------- 1 | @startuml 2 | object "cinesaSantander: Cinema" as cinesaSantander { 3 | } 4 | 5 | object "interstellar: Movie" as interstellar { 6 | title: "Interstellar" 7 | director: "Christopher Nolan" 8 | length: 169 9 | } 10 | 11 | object "lordOfTheRings: Movie" as lordOfTheRings { 12 | title: "El Señor de los Anillos" 13 | director: "Peter Jackson" 14 | length: 178 15 | } 16 | 17 | object "rogerWilco: Moviegoer" as rogerWilco { 18 | name: "Juan" 19 | } 20 | 21 | object "guybrushThreepwood: Moviegoer" as guybrushThreepwood { 22 | name: "Pedro" 23 | } 24 | 25 | object "ticket1: Ticket" as ticket1 { 26 | 27 | } 28 | 29 | object "ticket2: Ticket" as ticket2 { 30 | 31 | } 32 | 33 | cinesaSantander -d- ticket1 34 | cinesaSantander -d- ticket2 35 | interstellar -u- ticket1 36 | lordOfTheRings -u- ticket2 37 | rogerWilco -u- ticket1 38 | guybrushThreepwood -u- ticket2 39 | @enduml 40 | -------------------------------------------------------------------------------- /plantUML/efectividad.puml: -------------------------------------------------------------------------------- 1 | 2 | together efectividad { 3 | 4 | class Eficacia 5 | 6 | class Eficiencia 7 | 8 | class Compromiso 9 | 10 | class Efectividad 11 | 12 | class "Solución" as Solucion 13 | 14 | } 15 | 16 | Solucion *-down-> Efectividad 17 | 18 | Compromiso --> Eficacia 19 | Compromiso --> Eficiencia 20 | 21 | Efectividad *-down-> Eficacia 22 | Efectividad *-down-> Eficiencia 23 | Efectividad *-down-> Compromiso -------------------------------------------------------------------------------- /plantUML/jerarquiaAnimales.puml: -------------------------------------------------------------------------------- 1 | @startuml 2 | 3 | hide stereotype 4 | 5 | class Animal{ 6 | - celulas 7 | + comer() 8 | } 9 | class Vertebrado { 10 | - celulas 11 | - huesos 12 | + comer() 13 | + romperHuesos() 14 | } 15 | class Invertebrado { 16 | - celulas 17 | + comer() 18 | } 19 | 20 | class Mamifero { 21 | - celulas 22 | - huesos 23 | - labios 24 | + comer() 25 | + romperHuesos() 26 | + mamar() 27 | } 28 | class Ave { 29 | - celulas 30 | - huesos 31 | - pico 32 | + comer() 33 | + romperHuesos() 34 | + volar() 35 | + ponerHuevos() 36 | } 37 | class Canino { 38 | -celulas 39 | - huesos 40 | - labios 41 | - colmillos 42 | + comer() 43 | + romperHuesos() 44 | + mamar() 45 | } 46 | class Humano { 47 | - celulas 48 | - huesos 49 | - labios 50 | - raciocinio 51 | + comer() 52 | + romperHuesos() 53 | + mamar() 54 | + pensar() 55 | } 56 | class Ornitorrinco { 57 | -celulas 58 | - huesos 59 | -pico 60 | + comer() 61 | + romperHuesos() 62 | + ponerHuevos() 63 | + mamar() 64 | } 65 | 66 | Animal <|-- Vertebrado 67 | Animal <|-- Invertebrado 68 | Vertebrado <|-- Mamifero 69 | Vertebrado <|-- Ave 70 | Mamifero <|-- Canino 71 | Mamifero <|-- Humano 72 | Mamifero <|-- Ornitorrinco 73 | Ave <|-- Ornitorrinco 74 | @enduml -------------------------------------------------------------------------------- /src/000/Intervalo.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | class Intervalo{ 4 | 5 | private double inferior; 6 | private double superior; 7 | 8 | public Intervalo(double inferior, double superior){ 9 | this.inferior = inferior; 10 | this.superior = superior; 11 | } 12 | 13 | public Intervalo(){ 14 | this(0,0); 15 | } 16 | 17 | public Intervalo(double superior) { 18 | inferior = 0; 19 | this.superior = superior; 20 | } 21 | 22 | public Intervalo(Intervalo intervalo){ 23 | this(intervalo.inferior, intervalo.superior); 24 | } 25 | 26 | public double longitud(){ 27 | return (superior - inferior); 28 | } 29 | 30 | public void doblar(){ 31 | double longitudOriginal = longitud(); 32 | inferior = inferior - longitudOriginal/2; 33 | superior = superior + longitudOriginal/2; 34 | } 35 | 36 | public void recoger(){ 37 | Scanner entrada = new Scanner(System.in); 38 | 39 | System.out.println("Nuevo extremo inferior: "); 40 | inferior = entrada.nextDouble(); 41 | 42 | System.out.println("Nuevo extremo superior: "); 43 | superior = entrada.nextDouble(); 44 | 45 | } 46 | 47 | public Intervalo clonar(){ 48 | return new Intervalo(this); 49 | } 50 | 51 | public void desplazar(double distancia){ 52 | inferior = inferior + distancia; 53 | superior = superior + distancia; 54 | } 55 | 56 | public void oponer(){ 57 | double superiorAnterior = superior; 58 | double inferiorAnterior = inferior; 59 | superior = -inferiorAnterior; 60 | inferior = -superiorAnterior; 61 | } 62 | 63 | public Intervalo desplazado(double desplazamiento){ 64 | Intervalo intervalo = this.clonar(); 65 | intervalo.desplazar(desplazamiento); 66 | return intervalo; 67 | } 68 | 69 | public boolean incluye(double valor){ 70 | return inferior<=valor && valor <= superior; 71 | } 72 | 73 | public boolean incluye(Intervalo intervalo){ 74 | return this.incluye(intervalo.inferior) && this.incluye(intervalo.superior); 75 | } 76 | 77 | public boolean equals(Intervalo intervalo){ 78 | return inferior==intervalo.inferior && superior==intervalo.superior; 79 | } 80 | 81 | public boolean intersecta(Intervalo intervalo){ 82 | return this.incluye(intervalo.superior)||this.incluye(intervalo.inferior)||this.incluye(intervalo); 83 | } 84 | 85 | public Intervalo interseccion(Intervalo intervalo){ 86 | assert this.intersecta(intervalo); 87 | if (this.incluye(intervalo)){ 88 | return intervalo.clonar(); 89 | } else if (intervalo.incluye(this)) { 90 | return this.clonar(); 91 | } else if (this.incluye(intervalo.inferior)) { 92 | return new Intervalo(intervalo.inferior, superior); 93 | } else { 94 | return new Intervalo(inferior,intervalo.superior); 95 | } 96 | } 97 | 98 | 99 | public void mostrar(){ 100 | System.out.println("(" + inferior + " , " + superior + ")"); 101 | } 102 | 103 | public static void main(String[] args) { 104 | 105 | Intervalo intervalo = new Intervalo(-2,2); 106 | Intervalo intervalo2 = new Intervalo (0,5); 107 | Intervalo intervalo3 = intervalo.interseccion(intervalo2); 108 | intervalo3.mostrar(); 109 | 110 | 111 | } 112 | } -------------------------------------------------------------------------------- /temario/README.md: -------------------------------------------------------------------------------- 1 | # Temario 2 | 3 | - [x] [Introducción](introduccion.md) 4 | - [x] [Repaso de programación estructurada](https://github.com/mmasias/23-24-prg1/blob/main/temario/README.md) 5 | - [x] [Evolución de los lenguajes de programación](evolucion.md) 6 | - OOP 7 | - Programación basada a objetos 8 | - [x] [Clases y objetos](clasesObjetos.md) 9 | - [x] [Introducción](introVistas.md) 10 | - [x] [Vista pública de las clases](vistaPublicaClases.md) / [Ejemplos](vistaPublicaClasesEjemplos.md) 11 | - [x] [Vista Pública de los objetos](vistaPublicaObjetos.md) 12 | - [x] [Vista privada de las clases](vistaPrivadaClases.md) / Ejemplos 13 | - [x] [Vista privada de los objetos](vistaPrivadaObjetos.md) 14 | - [x] [Miembros de clase](miembrosClase.md) 15 | - [x] [Colaboración entre objetos: HOOD](hood.md) 16 | - [x] Desarrollo de aplicaciones usando HOOD: 17 | - [x] [Tic Tac Toe](https://github.com/mmasias/tictactoe/blob/main/README.md) 18 | - [x] [Klondike](https://github.com/mmasias/23-24-pyKlondike) 19 | - [x] [Blackjack](https://github.com/mmasias/23-24-pyKlondike/tree/XXI) 20 | - Programación orientada a objetos 21 | - [ ] [Relación de Herencia](herencia.md) 22 | - [ ] Herencia por extensión 23 | - [ ] Clases Abstractas 24 | - [ ] Herencia por Implementación 25 | - [ ] Limitaciones de la Herencia 26 | - [ ] Beneficios de la Herencia 27 | - [ ] Polimorfismo 28 | - [ ] Conversión de Tipos 29 | - [ ] Herencia y Enumerados 30 | 31 | ## Temario++ 32 | 33 | - [x] Artículos varios recopilados en la [carpeta de documentos](/documentos/README.md). 34 | 35 | --- 36 | 37 | Con todo esto, [a día de hoy deberíamos saber](aDiaDeHoy.md)... 38 | -------------------------------------------------------------------------------- /temario/aDiaDeHoy.md: -------------------------------------------------------------------------------- 1 | # A día de hoy deberíamos saber 2 | 3 | > *Entiéndase "deberíamos saber" como una combinación de "nos debería sonar", "no nos debería sorprender", "deberíamos conocer", "deberíamos saber manejar", en función del tema abordado. En cualquier caso, lo mínimo es "no nos debería sorprender" y deberíamos poder tener una mínima conversación o lectura sobre estos temas.* 4 | 5 | - A/E/M/J como mecanismos para lidiar con la complejidad 6 | - Clase / Objeto / Mensaje / Método / Atributo / Estado 7 | - Vista **pública** de la clase 8 | - Cabecera de métodos 9 | - El constructor, el destructor, la sobrecarga. 10 | - Un constructor no construye nada. 11 | - Vista **pública** de objetos 12 | - Crear objetos 13 | - Enviar mensajes 14 | - Vista **privada** de las clases 15 | - Implementar la vista privada de una clase 16 | - Instanciarla y ver su funcionamiento de modo individual 17 | - Desarrollar un programa pequeño utilizando HOOD & *flipping@beach* 18 | - Contar clases e instancias. 19 | -------------------------------------------------------------------------------- /temario/casosDeUso/README.md: -------------------------------------------------------------------------------- 1 | # Casos de uso 2 | 3 | |Caso de uso|Código|Breve descripción 4 | |-|:-:|-| 5 | [NombreCasoDeUso](paginaCasoDeUso.md)|[⌨️](/src/casosDeUso/CodigoCasoDeUso.java)|Descripción del caso de uso 6 | [NombreCasoDeUso](paginaCasoDeUso.md)|[⌨️](/src/casosDeUso/CodigoCasoDeUso.java)|Descripción del caso de uso 7 | -------------------------------------------------------------------------------- /temario/clasesObjetos.md: -------------------------------------------------------------------------------- 1 | # Intro II 2 | 3 | ## ¿Por qué? 4 | 5 | Porque hemos de lidiar con la complejidad inherente a los sistemas que vamos a desarrollar / modelar. 6 | 7 | ## ¿Qué? 8 | 9 | La historia del ser humano disfruta de **cuatro mecanismos mentales** que facilitan enormemente nuestra comprensión de los sistemas (complejos): 10 | 11 | ||| 12 | |-|-| 13 | |Abstracción|Proceso mental de extracción de las características esenciales de algo, ignorando los detalles superfluos| 14 | |Encapsulación|Proceso por el que se ocultan los detalles del soporte de las características esenciales de una abstracción| 15 | |Modularización|Proceso de descomposición de un sistema en un conjunto de piezas poco acopladas y cohesivas| 16 | |Jerarquización|Proceso de estructuración por el que se produce una organización de un conjunto de elementos en grados o niveles de responsabilidad, de clasificación o de composición, …​ entre otros| 17 | 18 | ## ¿Para qué? 19 | 20 | - A partir de estos mecanismos, abordar el desarrollo / modelado. 21 | - Dominar la complejidad. 22 | 23 | ## ¿Cómo? 24 | 25 | ### Clase & Objeto 26 | 27 | ||Clase|Objeto| 28 | |-|-|-| 29 | ||Descripción de los **datos** y de las **operaciones** que describen el comportamiento de un cierto conjunto de elementos homogéneos.|Ejemplar concreto (instancia) de una clase, que responde al comportamiento definido por las operaciones de la clase a la que pertenece, adecuándose al estado de sus datos particulares.| 30 | ||Intervalo|horasDeClase / miPresionArterial 31 | |Datos|Extremos inferior y superior|(8,10) / (80,120) 32 | |Operaciones|intersección, longitud, desplazar, etc.| 33 | 34 | ### Mensaje 35 | 36 | Invocación de una operación sobre un objeto. 37 | 38 | Un objeto es el agente activo que lanza el mensaje y otro objeto es el agente pasivo que recibe el mensaje. 39 | 40 | **El objeto receptor del mensaje debe contemplar dicha operación entre las definidas en su clase.** 41 | 42 | Ej. Mensajes a objetos de la clase *Intervalo* 43 | 44 | ```java 45 | (8,10).longitud() --> obtengo 2 46 | (-100,100).desplazar(3) --> cambio el intervalo a (-97,103) 47 | misHorasDeTrabajo.interseccion(tusHorasDeTrabajo) --> (16,18) 48 | ``` 49 | 50 | ### Método 51 | 52 | Definición de una operación de una clase. 53 | 54 | Ej. Métodos de la Clase Intervalo 55 | 56 | - **longitud**: extremo superior menos extremo inferior 57 | - **desplazar**: acumular cantidad a ambos extremos 58 | 59 | ### Atributo 60 | 61 | Cada uno de los datos de una clase, y por tanto, presente en todos los objetos de esa clase. 62 | 63 | Ej. Atributos de la clase Intervalo 64 | 65 | - extremos inferior y superior 66 | 67 | ### Estado 68 | 69 | Conjunto de los **valores de los atributos que tiene un objeto**, por pertenecer a una clase, en un instante dado. 70 | 71 | Ej. Estados de objetos de la clase Intervalo 72 | 73 | - 8 en el extremo inferior y 14 en el extremo superior de presiónArterial; 74 | - 9 en el extremo inferior y 18 en el extremo superior de misHorasDeTrabajo; 75 | 76 | ### Relación de todos estos elementos 77 | 78 | |Clase|Objeto| 79 | |-|-| 80 | |Descripción de los datos y de las operaciones que describen el comportamiento de un cierto conjunto de elementos homogéneos.|Ejemplar concreto (instancia) de una clase, que responde al comportamiento definido por las operaciones de la clase a la que pertenece, adecuándose al estado de sus datos particulares.| 81 | |Una clase es la definición de los atributos y métodos que describen el comportamiento de un cierto conjunto de objetos homogéneos.|Un objeto es un ejemplar concreto de una clase que responde a los mensajes correspondientes a los métodos de ésta, adecuándose al estado de sus atributos. 82 | 83 | Las clases asumen el principio de encapsulación: cuando se describe una clase, se debe describir tanto su vista pública o 84 | interfaz como su vista privada o implantación. 85 | 86 | La **vista pública** o **interfaz** describe qué operaciones responden los objetos de esta clase, o sea, su comportamiento. 87 | 88 | La **vista privada** o **implantación** describe las estructuras de datos de la clase y cómo manipulan las operaciones los datos. De esta forma, se conjugan la abstracción inherente en la clase con la encapsulación de sus datos y de su forma de operar 89 | 90 | Las clases que conjugan de forma equilibrada atributos (datos) y métodos (operaciones) son el único bloque de construcción de programas: módulos. 91 | 92 | Esta modularidad exige que: 93 | 94 | - Los datos y operaciones de una clase son elementos estrechamente relacionados favoreciendo que “una clase se entiende por sí misma” –cohesión-. 95 | - las clases se relacionan -acoplamiento- al colaborar en jerarquías de composición, clasificación, ... para constituir los programas 96 | 97 | **Herencia:** transmisión de atributos y métodos de una clase a otra clase. 98 | 99 | Ej. A partir de la Clase Intervalo 100 | 101 | - IntervaloCerradoCerrado [x,x] 102 | - IntervaloAbiertoCerrado (x,x] 103 | 104 | **Polimorfismo:** enlace dinámico (en tiempo de ejecución) de expresiones a clases y/o de mensajes a métodos. 105 | 106 | Ej. Objetos intercambiables de las clases Intervalo, IntervaloCerradoCerrado, ... 107 | 108 | ### Programación estructurada vs POO 109 | 110 | |PROGRAMACIÓN ESTRUCTURADA|BASES DE LA PROGRAMACIÓN|POO| 111 | |-|:-:|-| 112 | |Registro + Funciones|Abstracción, Encapsulación y Modularidad|Clase| 113 | |Variable de Tipo Registro|Abstracción, Encapsulación|Objeto| 114 | |Función|Modularidad|Método| 115 | Llamada a Función|Abstracción|Mensaje 116 | Campo de un Registro|Encapsulación y Modularidad|Atributo 117 | Estado de una Variable Registro|Encapsulación|Estado 118 | Registros de Campos Variables|Abstracción y Modularidad|Herencia 119 | Punteros a Funciones|Abstracción y Encapsulación|Polimorfismo 120 | -------------------------------------------------------------------------------- /temario/ejercicios/001/Intervalo.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | class Intervalo { 4 | 5 | private double puntoMedio; 6 | 7 | private double longitud; 8 | 9 | private double getInferior() { 10 | return puntoMedio - longitud / 2; 11 | } 12 | 13 | private void setInferior(double inferior) { 14 | longitud = this.getSuperior() - inferior; 15 | puntoMedio = inferior + longitud / 2; 16 | } 17 | 18 | private double getSuperior() { 19 | return puntoMedio + longitud / 2; 20 | } 21 | 22 | private void setSuperior(double superior) { 23 | longitud = superior - this.getInferior(); 24 | puntoMedio = superior - longitud / 2; 25 | } 26 | 27 | public Intervalo(double inferior, double superior) { 28 | this.setInferior(inferior); 29 | this.setSuperior(superior); 30 | } 31 | 32 | public Intervalo(double superior) { 33 | this(0, superior); 34 | } 35 | 36 | public Intervalo(Intervalo intervalo) { 37 | this(intervalo.getInferior(), intervalo.getSuperior()); 38 | } 39 | 40 | public Intervalo() { 41 | this(0, 0); 42 | } 43 | 44 | public Intervalo clone() { 45 | return new Intervalo(this); 46 | } 47 | 48 | public double longitud() { 49 | return getSuperior() - getInferior(); 50 | } 51 | 52 | public void desplazar(double desplazamiento) { 53 | setInferior(getInferior() + desplazamiento); 54 | setSuperior(getSuperior() + desplazamiento); 55 | } 56 | 57 | public Intervalo desplazado(double desplazamiento) { 58 | Intervalo intervalo = this.clone(); 59 | intervalo.desplazar(desplazamiento); 60 | return intervalo; 61 | } 62 | 63 | public boolean incluye(double valor) { 64 | return getInferior() <= valor && valor <= getSuperior(); 65 | } 66 | 67 | public boolean incluye(Intervalo intervalo) { 68 | assert intervalo != null; 69 | return this.incluye(intervalo.getInferior()) && 70 | this.incluye(intervalo.getSuperior()); 71 | } 72 | 73 | public boolean equals(Intervalo intervalo) { 74 | assert intervalo != null; 75 | return getInferior() == intervalo.getInferior() && 76 | getSuperior() == intervalo.getSuperior(); 77 | } 78 | 79 | public Intervalo interseccion(Intervalo intervalo) { 80 | assert this.intersecta(intervalo); 81 | if (this.incluye(intervalo)) { 82 | return intervalo.clone(); 83 | } else if (intervalo.incluye(this)) { 84 | return this.clone(); 85 | } else if (this.incluye(intervalo.getInferior())) { 86 | return new Intervalo(intervalo.getInferior(), getSuperior()); 87 | } else { 88 | return new Intervalo(getInferior(), intervalo.getSuperior()); 89 | } 90 | } 91 | 92 | public boolean intersecta(Intervalo intervalo) { 93 | assert intervalo != null; 94 | return this.incluye(intervalo.getInferior()) || 95 | this.incluye(intervalo.getSuperior()) || 96 | intervalo.incluye(this); 97 | } 98 | 99 | public void oponer() { 100 | double inferiorInicial = getInferior(); 101 | double superiorInicial = getSuperior(); 102 | setInferior(-superiorInicial); 103 | setSuperior(-inferiorInicial); 104 | } 105 | 106 | public void doblar() { 107 | double longitudInicial = this.longitud(); 108 | setInferior(getInferior() - longitudInicial / 2); 109 | setSuperior(getSuperior() + longitudInicial / 2); 110 | } 111 | 112 | public void recoger() { 113 | Scanner scanner = new Scanner(System.in); 114 | System.out.println("Inferior?"); 115 | setInferior(scanner.nextDouble()); 116 | System.out.println("Superior?"); 117 | setSuperior(scanner.nextDouble()); 118 | } 119 | 120 | public void mostrar() { 121 | System.out.println("[" + getInferior() + "," + getSuperior() + "]"); 122 | } 123 | 124 | public Intervalo[] trocear(int trozos) { 125 | return null; 126 | } 127 | 128 | } 129 | -------------------------------------------------------------------------------- /temario/ejercicios/001/IntervaloV0.java: -------------------------------------------------------------------------------- 1 | import java.util.Scanner; 2 | 3 | public class IntervaloV0 { 4 | 5 | private double inferior; 6 | 7 | private double superior; 8 | 9 | public IntervaloV0(double inferior, double superior) { 10 | this.inferior = inferior; 11 | this.superior = superior; 12 | } 13 | 14 | public IntervaloV0(double superior) { 15 | this(0, superior); 16 | } 17 | 18 | public IntervaloV0(IntervaloV0 intervalo) { 19 | this(intervalo.inferior, intervalo.superior); 20 | } 21 | 22 | public IntervaloV0() { 23 | this(0, 0); 24 | } 25 | 26 | public IntervaloV0 clone() { 27 | return new IntervaloV0(this); 28 | } 29 | 30 | public double longitud() { 31 | return superior - inferior; 32 | } 33 | 34 | public void desplazar(double desplazamiento) { 35 | inferior += desplazamiento; 36 | superior += desplazamiento; 37 | } 38 | 39 | public IntervaloV0 desplazado(double desplazamiento) { 40 | IntervaloV0 intervalo = this.clone(); 41 | intervalo.desplazar(desplazamiento); 42 | return intervalo; 43 | } 44 | 45 | public boolean incluye(double valor) { 46 | return inferior <= valor && valor <= superior; 47 | } 48 | 49 | public boolean incluye(IntervaloV0 intervalo) { 50 | assert intervalo!=null; 51 | return this.incluye(intervalo.inferior) && 52 | this.incluye(intervalo.superior); 53 | } 54 | 55 | public boolean equals(IntervaloV0 intervalo) { 56 | assert intervalo!=null; 57 | return inferior == intervalo.inferior && 58 | superior == intervalo.superior; 59 | } 60 | 61 | public IntervaloV0 interseccion(IntervaloV0 intervalo) { 62 | assert this.intersecta(intervalo); 63 | if (this.incluye(intervalo)){ 64 | return intervalo.clone(); 65 | } else if (intervalo.incluye(this)){ 66 | return this.clone(); 67 | } else if (this.incluye(intervalo.inferior)){ 68 | return new IntervaloV0(intervalo.inferior, superior); 69 | } else { 70 | return new IntervaloV0(inferior, intervalo.superior); 71 | } 72 | } 73 | 74 | public boolean intersecta(IntervaloV0 intervalo) { 75 | assert intervalo!=null; 76 | return this.incluye(intervalo.inferior) || 77 | this.incluye(intervalo.superior) || 78 | intervalo.incluye(this); 79 | } 80 | 81 | public void oponer() { 82 | double inferiorInicial = inferior; 83 | double superiorInicial = superior; 84 | inferior = -superiorInicial; 85 | superior = -inferiorInicial; 86 | } 87 | 88 | public void doblar() { 89 | double longitudInicial = this.longitud(); 90 | inferior -= longitudInicial / 2; 91 | superior += longitudInicial / 2; 92 | } 93 | 94 | public void recoger() { 95 | Scanner scanner = new Scanner(System.in); 96 | System.out.println("Inferior?"); 97 | inferior = scanner.nextDouble(); 98 | System.out.println("Superior?"); 99 | superior = scanner.nextDouble(); 100 | } 101 | 102 | public void mostrar() { 103 | System.out.println("[" + inferior + "," + superior + "]"); 104 | } 105 | 106 | public IntervaloV0[] trocear(int trozos) { 107 | return null; 108 | } 109 | 110 | public static void main(String[] args){ 111 | IntervaloV0 intervalo = new IntervaloV0(); 112 | intervalo.recoger(); 113 | intervalo.mostrar(); 114 | System.out.println("Longitud: "+intervalo.longitud()); 115 | } 116 | } 117 | -------------------------------------------------------------------------------- /temario/ejercicios/001/README.md: -------------------------------------------------------------------------------- 1 | 2 |
3 | 4 | |Vista pública clase Intervalo| 5 | |-| 6 | public Intervalo(double inferior, double superior) 7 | public void mostrar() 8 | public Intervalo(double superior) 9 | public Intervalo(Intervalo intervalo) 10 | public Intervalo() 11 | public double longitud() 12 | public void doblar() 13 | public Intervalo clone() 14 | public void recoger() 15 | public void desplazar(double desplazamiento) 16 | public void oponer() 17 | public Intervalo desplazado(double desplazamiento) 18 | public boolean incluye(double valor) 19 | public boolean incluye(Intervalo intervalo) 20 | public boolean equals(Intervalo intervalo) 21 | public boolean intersecta(Intervalo intervalo) 22 | public Intervalo interseccion(Intervalo intervalo) 23 | public Intervalo[] trocear(int trozos) 24 | 25 |
26 | 27 | -------------------------------------------------------------------------------- /temario/ejercicios/README.md: -------------------------------------------------------------------------------- 1 | # Ejercicios diversos, para ir practicando 2 | 3 | |Ejercicio|Concepto|Concepto|Concepto|Concepto|Concepto|Concepto|Concepto 4 | |-|:-:|:-:|:-:|:-:|:-:|:-:|:-:| 5 | |[Nombre del ejercicio](01-PaginaDelEjercicio.md)|☑️|☑️|☑️|🔲|🔲|🔲|😊 6 | -------------------------------------------------------------------------------- /temario/evolucion.md: -------------------------------------------------------------------------------- 1 | # Evolución de los lenguajes de programación 2 | 3 |
4 | 5 | | | **ABSTRACCIÓN** | **ENCAPSULACIÓN** | **MODULARIZACIÓN** | **JERARQUIZACIÓN** | 6 | |--|:-:|:-:|:-:|:-:| 7 | |**CÓDIGO MÁQUINA**|{0,1}|Nula|Nula|Nula| 8 | |**ENSAMBLADOR**|Identificadores|Nula|Macros|Nula| 9 | |**PROGRAMACIÓN DE ALTO NIVEL**|Subprogramas|Reglas de Ámbito|Subprogramas|Expresiones, Registros y Subprogramas| 10 | |**PROGRAMACIÓN ESTRUCTURADA**|Estructuras de control del flujo|control del flujo de ejecución|control del flujo de ejecución|| 11 | |**PROGRAMACIÓN MODULAR**|Espacios de nombre|Privacidad en módulos|Módulos|Jerarquías de dependencia entre módulos| 12 | |**TAD**|Vista pública|Vista privada|TAD's|Jerarquías de composición y dependencia| 13 | |**PROGRAMACIÓN ORIENTADA A OBJETOS**|Herencia y polimorfismo|Herencia y polimorfismo|Clases|Jerarquías de clasificación| 14 | --- 15 | 16 | **OO = TAD + Herencia & Polimorfismo** 17 | 18 |
19 | -------------------------------------------------------------------------------- /temario/herencia.md: -------------------------------------------------------------------------------- 1 | # Herencia 2 | 3 | **Transmisión**: La herencia en todos los ámbitos (derecho, biología, …​) tiene connotaciones de transmisión 4 | 5 | En Programación Orientada a Objetos es la transmisión de todos los miembros (atributos y métodos públicos y privados) de una clase a otra. 6 | 7 | ## Terminología: 8 | 9 |
10 | 11 | ||Clase base|Clase derivada| 12 | |-|-|-| 13 | ||La que transmite|La que recibe la transmisión 14 | |*también llamadas*|padre|hija| 15 | |*también llamadas (aunque en desuso)*|Superclase|Subclase| 16 | 17 |
18 | 19 | ## Implicaciones en la colaboración 20 | 21 | |Composición, asociación y dependencia|Herencia| 22 | |-|-| 23 | |Relaciones binarias que devienen de la colaboración entre objetos: envío de mensajes entre objetos.|Es una relación binaria entre clases, pero **no es necesario** que exista una colaboración entre los objetos de sus clases ***aunque*** tampoco lo impide| 24 | 25 | Por tanto, los objetos de las clases de una relación de herencia son, a priori, independientes. 26 | 27 | ## Tipos 28 | 29 | |Simple|Múltiple| 30 | |-|-| 31 | Cuando una clase derivada hereda de una única clase base.|Cuando una clase derivada hereda de varias clases base. 32 | 33 | ## Jerarquías de clasificación 34 | 35 | ### Definición 36 | 37 | Una jerarquía por grado de clasificación es aquélla donde cada nodo (clases) de la jerarquía establece un dominio de elementos (conjuntos de objetos de la clase) incluido en el dominio de los nodos padre e incluye a los dominios de cada nodo hijo 38 | 39 | > La relación de herencia permite establecer jerarquías por grado de clasificación 40 | 41 | ### Características 42 | 43 | - Eminentemente subjetivas 44 | - Ej. paciente de un hospital: publica/privada, por especialidad,…​ 45 | - Contemplan elementos que son dificilmente categorizables 46 | - Ej. Ornitorrinco, pingüino, mula,…​ 47 | - Dificultad para establecer una clasificación "perfecta" 48 | - Esqueleto fundamental de un programa junto con la jerarquía de composición 49 | 50 | ### Reglas de construcción 51 | 52 | |Generalización/Especialización|¿Es un...? (Is a...?)| 53 | |-|-| 54 | Cuando existen unas características específicas de un subconjunto de elementos de un determinado conjunto más amplio, que pese a que mantienen las características esenciales e identificativas del conjunto al que pertenecen, también son lo suficientemente relevantes como para ser rasgos distintivos de dicho subconjunto de elementos.|Poder responder afirmativamente que un objeto de la clase hija es un objeto de la clase padre. 55 | 56 |
57 | 58 | ![](/images/modelosUML/plantUML/jerarquiaAnimales.svg) 59 | 60 |
61 | 62 | ## Herencia por extensión 63 | 64 | Mediante la palabra reservada `extends` 65 | 66 | ```java 67 | 68 | class extends { 69 | ... 70 | } 71 | 72 | class Abuela { 73 | ... 74 | } 75 | class Padre extends Abuela { 76 | ... 77 | } 78 | class Hija extends Padre { 79 | ... 80 | } 81 | 82 | ``` 83 | 84 | ### Especialización por adición 85 | 86 | ||| 87 | |-|-| 88 | |**Atributos**|Los atributos añadidos en la clase hija tienen las mismas reglas sintácticas y semánticas que en una clase que no sea derivada 89 | |**Métodos**|Los métodos añadidos en la clase hija tienen las mismas reglas sintácticas y semánticas que en una clase que no sea derivada 90 | ||Excepto que **no tienen acceso a los atributos y métodos privados transmitidos desde la clase padre**, si no es a través de los métodos públicos transmitidos desde la clase padre 91 | ||Esto permite la contención del mantenimiento, dado que, si se modifica la implantación de la clase padre, no repercute sobre la implantación de la clase hija y se obtiene un mínimo acoplamiento entre ambas clases. 92 | |**Constructores**|Mediante **super**, donde debe ser la primera sentencia de los constructores de la clase derivada y sus argumentos deben coincidir en número y tipo con la lista de parámetros de algún constructor público o protegido de la clase padre 93 | ||Se puede omitir para el caso del constructor de la clase padre con una lista vacía de parámetros 94 | 95 | #### Implicaciones 96 | 97 | |Los objetos de la clase padre|Los objetos de la clase hija| 98 | |-|-| 99 | |No sufren ninguna alteración por la presencia de clases derivadas.|Tienen todos los atributos transmitidos desde la clase padre junto con los atributos añadidos en la clase hija. 100 | ||Responden a mensajes que corresponden con los métodos públicos transmitidos desde la clase padre junto con los métodos públicos añadidos en la clase derivada. 101 | 102 | ### Miembros protegidos 103 | 104 | Cuando la clase padre no transmite los métodos públicos necesarios para manipular los atributos privados transmitidos desde la clase padre en los métodos añadidos en la clase hija: 105 | 106 | ||| 107 | |-|-| 108 | |**¿Haciéndolos publicos?**|No es solución, puesto que rompe el principio de encapsulación ya que, para la implantación de una clase hija, los objetos de la clase padre dan a conocer más allá de lo que se les solicitaba previamente a la existencia de la clase derivada. 109 | |**Haciéndolos protegidos**|Visibilidad protegida (protected), donde los miembros (atributos y/o métodos) son accesibles en la implantación de la clase y en cualquier clase derivada. 110 | ||**Atributos protegidos**: Dentro del cuerpo de los métodos de la clase derivada se tiene acceso a los atributos protegidos heredados, a los atributos añadidos, a los parámetros del método y a las declaraciones locales, ley flexible de Demeter.
***Pero***: desbordamiento del mantenimiento dado que si se modifica la implantación de la clase padre SI repercute sobre la implantación de la clase hija y se obtiene un máximo acoplamiento entre ambas clases 111 | ||**Métodos get/set protegidos** son métodos para obtener el valor y asignar un valor a los atributos privados transmitidos desde la clase padre, posibilitando cualquier manipulación por parte de la clase hija futura.
***Implicación:*** contención del mantenimiento dado que si se modifica la implantación de la clase padre no repercute sobre la implantación de la clase hija y se obtiene un mínimo acoplamiento entre ambas clases 112 | 113 | ### Especialización por redefinición 114 | 115 | Donde la cabecera del método es exactamente igual a la cabecera del método no privado de la clase padre, excepto su visibilidad, que puede ampliarse. En caso contrario, sería sobrecarga y no redefinición 116 | 117 | Sus implicaciones son: 118 | 119 | - Se anula la transmisión del método de la clase padre. 120 | - Los objetos de la clase padre responden al mensaje con el comportamiento dado en la clase padre. 121 | - Los objetos de la clase hija responden al mensaje con el comportamiento dado en la clase hija. 122 | 123 | #### super 124 | 125 | ||| 126 | |-|-| 127 | En la implantación de cualquier clase derivada, es una referencia constante que guarda la dirección del objeto que recibe el mensaje correspondiente al método que se está redefiniendo, pero con el comportamiento de la clase padre.|Su utilidad será para la reutilización del método de la clase padre, anulado en la transmición, desde la redefinición del método de la clase hija. 128 | 129 | -------------------------------------------------------------------------------- /temario/hood.md: -------------------------------------------------------------------------------- 1 | # HOOD 2 | 3 | |Budd, 94|Ingalls, 81|Booch, 96| 4 | |-|-|-| 5 | |*Cuando los programadores piensan en los problemas, en términos de comportamientos y responsabilidades de los objetos, traen con ellos un caudal de intuición, ideas y conocimientos provenientes de su experiencia diaria*|*En lugar de un saqueador de bits que saquea estructuras de datos, nosotros tenemos un universo de objetos con buen comportamiento que cortésmente se solicitan entre sí cumplir diversos deseos*|*Un objeto en si mismo no es interesante. Los objetos contribuyen al comportamiento de un sistema colaborando con otros objetos*| 6 | 7 | Cada objeto de un programa debe asumir directamente cierta parte de sus responsabilidades y saber delegar otras en otros objetos colaboradores: no se trata de que un objeto asuma y “controle todo” y el resto se dispongan a darle la información y aceptarla cuando el “controlador” la haya procesado; se trata de que cada objeto almacene su propia información y, por ende, que cada objeto la procese. 8 | 9 | Un programa orientado a objetos parte de una clase principal que contiene todos los objetos que le hacen falta. Y estos, a su vez, contendrán los objetos que le hacen falta para ir completando su tarea. 10 | 11 | Una aplicación es un único objeto. Para ejecutarla se envía un único mensaje a la clase principal. 12 | 13 |
14 | 15 | ||Aplicacion|Gestor|Simulador|Juego| 16 | |-|-|-|-|-| 17 | |**Clase prinpal**|App|Manager|Simulator|Game| 18 | |**Método disparador**|execute()|manage()|simulate()|play()| 19 | 20 | 21 | 22 | 23 | 40 | 57 |
24 | 25 | ```java 26 | class App { 27 | 28 | public void execute() { 29 | 30 | } 31 | 32 | public static void main (string arg[]) { 33 | App app = new App(); 34 | app.execute(); 35 | } 36 | } 37 | ``` 38 | 39 | 41 | 42 | ```java 43 | class Game { 44 | 45 | public void play() { 46 | 47 | } 48 | 49 | public static void main (string arg[]) { 50 | Game game = new Game(); 51 | game.play(); 52 | } 53 | } 54 | ``` 55 | 56 |
58 | 59 |
60 | 61 | Una vez que se conoce de dónde partir (la clase del objeto “principal”) y hasta dónde llegar (hasta que nuevas clases no reduzcan los costes), resta saber qué camino seguir para el desarrollo del programa. 62 | 63 | El método propuesto es una simplificación extrema y variación de HOOD (diseño orientado a objetos jerárquico). El resultado es un método muy sencillo y utilizable en pequeñas aplicaciones. Este método contiene 5 fases que se aplican cíclicamente para cada clase del programa: 64 | 65 | 1. Tomar una clase 66 | 1. Definir el comportamiento 67 | 1. Definir los atributos 68 | 1. Codificar los métodos 69 | 1. Recapitular nuevas clases y métodos. 70 | 71 | Usaremos este método para desarrollar el juego del [Tic tac toe](https://github.com/mmasias/tictactoe/blob/main/README.md) 72 | -------------------------------------------------------------------------------- /temario/introVistas.md: -------------------------------------------------------------------------------- 1 | # Vistas 2 | 3 | Determinan el ámbito donde se puede referenciar la declaración de un miembro de la clase: atributo o método. 4 | 5 | - **Pública**: conocido en cualquier punto de la aplicación (antes de la declaración, después y en cualquier otro fichero) 6 | - **Privada**: conocido en cualquier punto de la clase (antes y después de la declaración pero en la implementación de la clase) 7 | 8 | ||Clases|Objetos| 9 | |-|-|-| 10 | Vista pública|***[INTERFAZ](vistaPublicaClases.md)***:
Nombre de la Clase
Cabecera de los Métodos|Creación de Objetos
Paso de Mensajes
Destrucción de Objetos 11 | Vista privada|***IMPLEMENTACIÓN***:
Definición de Atributos
Desencadenamiento de Objetos|Definición de Métodos
Desencadenamiento de Mensajes 12 | 13 | ## Dependencias 14 | 15 | - Al crear objetos y lanzarles mensajes, se debe respetar la interfaz de sus clases => 16 | - 1º **[Vista pública de las Clases](vistaPublicaClases.md)** 17 | - 2º **[Vista pública de los Objetos](vistaPublicaObjetos.md)** 18 | - Al definir atributos de una clase (generalmente, objetos de otras clases) y definir sus métodos (generalmente, lanzando mensajes a los objetos atributos), se debe respetar, transitivamente, la interfaz de otras clases => 19 | - 3º **Vista privada de las Clases** 20 | - Al crear un objeto se produce un desencadenamiento de instanciaciones y al lanzar un mensaje se produce un desencadenamiento de mensajes, acorde a la definición de atributos y de métodos de la clase del objeto => 21 | - 4º **Vista privada de Objetos** 22 | -------------------------------------------------------------------------------- /temario/introduccion.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | 3 | ## ¿Por qué? 4 | 5 | - [Limitaciones](https://docs.google.com/presentation/d/1FBjSPhSYrgBQjVp8HefkiJA_AwJU_bq24b8WMz3xzOA/edit?usp=sharing) 6 | - Equilibrio entre **procesos** y **datos**, aplicando un **enfoque antropomórfico**. 7 | 8 | |*X es bueno; Orientado a objetos es bueno; ergo X es Orientado a objetos*|*Mi conjetura es que la orientación a objetos será en los 80 lo que la programación estructurada en los 70. Todo el mundo estará a favor suyo. Cada productor prometerá que sus productos lo soportan. Cada director pagará con la boca pequeña el servirlo. Cada programador lo practicará. Y nadie sabrá exactamente lo que es*| 9 | |-|-| 10 | |Stoupstrup, 88|Rentsch, 82| 11 | 12 | ## ¿Qué? 13 | 14 | ### Sistema 15 | 16 | Un sistema es un conjunto de componentes interactuando o interdependientes formando un todo integrado. Cada sistema está delimitado por sus límites espacio/temporales e influenciado por su entorno, descrito por su estructura y propósito y expresado en su funcionamiento 17 | 18 | ### Sistema complejo 19 | 20 | Un Sistema complejo es aquel cuya complejidad excede la capacidad intelectual humana — [Grady Booch](https://es.wikipedia.org/wiki/Grady_Booch) 21 | 22 | Sistema|conjunto de componentes interactuando o interdependientes formando un todo integrado|delimitado por sus límites espacio / temporales|e influenciado por su entorno,|descrito por su estructura|y propósito|y expresado en su funcionamiento. 23 | |-|-|-|-|-|-|-| 24 | Sistema respiratorio|Nariz, laringe, faringe, traquea, pulmones, alveolos, …​|fechas y lugares de la vida del ser vivo que contiene el sistema respiratorio|lo que respira: aire limpio vs contaminado, …​|la nariz se conecta con la laringe, la laringe con la traquea, …​|inyectar oxigeno al sistema circulatorio extrayendo monóxido de carbono, …​|inspiración y expiración| 25 | Película de amor|personajes|fechas y lugares de los personajes|la sociedad, las familias, una ex-pareja, …​|argumento que relaciona los personajes de la historia|transmitir emociones|reproducción de la película| 26 | Números romanos|I, V, X, L, C, D y M|fechas y lugar donde estén escritos|en desuso en favor de sistemas de numeración poscionales (indo-arábigo, maya, chino, …​) mucho más efectivos|grupos de máximo 3 elementos consecutivos, grupo con elemento y opcionalmente un elemento inferido prefijo o sufijo, …|registrar información cuantitativa|suma, resta, producto, división, …​ con información cuantitativa registrada| 27 | Semáforo|Rojo, verde y amarillo|fechas y lugar de la instalación del semáforo|fuente de energía, climatología, vándalos, artistas, …​|de rojo a verde, de verda a amarillo y de amarillo a verdo y/o rojo, …​|controlar el tráfico|luces con alimentación eléctrica| 28 | Cadena de suministro|Proveedores, transportistas, almacenes, distribuidores, puntos de venta|Desde la adquisición de materias primas hasta la entrega del producto final al consumidor|Demandas del mercado, regulaciones gubernamentales, relaciones con proveedores, …​|Flujo de información, productos y finanzas a través de los diferentes eslabones|Optimizar la entrega de bienes y servicios desde el proveedor hasta el cliente final|Planificación, implementación y control del flujo de mercancías| 29 | Sistema de manufactura|Maquinaria, operarios, materia prima, procesos de producción|En la planta de producción donde se fabrican los productos|Tecnología disponible, normativas de seguridad y salud, demanda del producto, …​|Secuencia de operaciones y procesos para transformar materias primas en productos finales|Producir bienes de calidad de manera eficiente y segura|Conversión de materias primas en productos finales mediante procesos como mecanizado, ensamblaje, …​| 30 | Lápiz|Cuerpo, mina de grafito, goma de borrar (opcional)|En el momento y lugar de su uso|Preferencias del usuario, desgaste físico|El grafito está encerrado dentro del cuerpo del lápiz. La goma de borrar, si está presente, se encuentra en el extremo opuesto.|Escribir o dibujar sobre papel|La mina de grafito deja una marca sobre el papel cuando es presionada contra este. 31 | 32 |
No obstanteUn lápiz **no se considera un sistema complejo** debido a su simplicidad en términos de interacciones, predictibilidad de su comportamiento y falta de adaptabilidad o emergencia de propiedades nuevas que no son atribuibles a sus componentes individuales
33 | 34 | ## ¿Para qué? 35 | 36 | ### Efectividad 37 | 38 | ||| 39 | |-|-| 40 | |![](/images/modelosUML/plantUML/efectividad.svg)|**Eficacia**, alto cumplimiento de objetivos frente a incumplimientos por errores, desmotivación, cansancio,…​
​
**Eficiencia**, bajo consumo de recursos (tiempo, energía, espacio, …​) frente a consumos disparatados comparado con otras soluciones

**Efectividad** es un equilibrio, un compromiso entre ambas. 41 | 42 | ``` 43 | +-------------+----------------------+----------------------------+ 44 | | | + | + | 45 | | | (A) EFICAZ e | (B) EFICAZ y | 46 | | | INEFICIENTE | EFICIENTE | 47 | | + | | | 48 | | | Haber alcanzado los | Haber alcanzado los retos | 49 | | E | retos sin cumplir | con los recursos dispuestos| 50 | | F | con las pautas | | 51 | | I +----------------------+----------------------------+ 52 | | C | - | - | 53 | | A | (C) INEFICAZ e | (D) INEFICAZ y | 54 | | C | INEFICIENTE | EFICIENTE | 55 | | I | | | 56 | | A | Haber fracasado en | Haber utilizado bien los | 57 | | | el cumplimiento de | recursos disponibles sin | 58 | | - | objetivos pese a | alcanzar retos | 59 | | | extralimitar el uso | | 60 | | | de los medios | | 61 | +-------------+----------------------+----------------------------+ 62 | | EFECTIVIDAD | - EFICIENCIA + | 63 | +-------------+----------------------+----------------------------+ 64 | ``` 65 | 66 | #### Comprar el pan 67 | 68 | ||Eficiente|Ineficiente| 69 | |-|-|-| 70 | **Eficaz**|Trae el pan en cinco minutos y devuelve el cambio|Trae el pan en 20 minutos y no devuelve el cambio 71 | **Ineficaz**|Trae el pan pero no la cantidad, tipos, …​ oportunos en cinco minutos y devuelve la vuelta|Trae el pan pero no la cantidad, tipos, …​ oportunos en 20 minutos y no devuelve la vuelta 72 | 73 | #### Preparar un reporte financiero 74 | 75 | ||Eficiente|Ineficiente| 76 | |-|-|-| 77 | **Eficaz**|Entrega el reporte completo y correcto antes de la fecha límite, utilizando menos horas de trabajo de las presupuestadas.|Entrega el reporte completo y correcto, pero toma más tiempo del esperado y consume recursos adicionales. 78 | **Ineficaz**|Entrega el reporte antes de la fecha límite, pero el reporte contiene errores o le falta información importante.|Entrega el reporte después de la fecha límite y, además, el reporte contiene errores o carece de información relevante. 79 | 80 | #### Sprint con funcionalidad nueva 81 | 82 | ||Eficiente|Ineficiente| 83 | |-|-|-| 84 | **Eficaz**|Se lanza la nueva función con todas las características solicitadas, sin errores, y dentro del tiempo y presupuesto asignados.|Se lanza la nueva función con todas las características solicitadas, pero excediendo el tiempo y presupuesto asignados. 85 | **Ineficaz**|Se lanza la nueva función rápidamente y dentro del presupuesto, pero carece de algunas características clave o tiene errores significativos.|Se lanza la nueva función tarde, excediendo el presupuesto, y además, carece de características importantes o tiene errores significativos. 86 | 87 | #### Optimización de línea de ensamblaje 88 | 89 | ||Eficiente|Ineficiente| 90 | |-|-|-| 91 | **Eficaz**|Reorganización de la línea de ensamblaje que aumenta la producción manteniendo la calidad, utilizando menos recursos de los proyectados.|Reorganización de la línea de ensamblaje que aumenta la producción y mantiene la calidad, pero utilizando más recursos y tiempo del proyectado. 92 | **Ineficaz**|Cambios en la línea de ensamblaje realizados rápidamente y con bajo costo, pero que resultan en una disminución de la calidad o de la producción.|Cambios en la línea de ensamblaje que consumen recursos y tiempo sin lograr aumentar la producción ni mejorar la calidad. 93 | 94 | --- 95 | |Las personas| 96 | |-| 97 | No son efectivas con tamaños elevados de elementos a gestionar por imposibilidad, agotamiento, desmotivación, distracción, …​ 98 | No son eficaces por errores (¿nunca te has equivocado?, …​) 99 | No son eficientes por consumo de tiempo (calcula los primos del primer billón, a relación de un segundo por cálculo de si un número es primo, no hay segundos en la vida de una persona, …​) 100 | No son eficiente por consumo de espacio (calcula con lapiz y papel los posibles caminos entre todas las poblaciones de tu tierra natal, suponiendo que habrá miles, no hay hojas en el planeta, …​) 101 | 102 | ## ¿Cómo? 103 | 104 | ### Características de los sistemas complejos 105 | 106 | |Característica|Descripción| 107 | |-|-| 108 | Estructura jerárquica|Frecuentemente, la complejidad adquiere una forma jerárquica donde el sistema complejo está compuesto de subsistemas interrelacionados que a su vez tienen sus propios subsistemas y así hasta que se alcanza algún elemento del más bajo nivel.|**Organismos vivos**: Los seres humanos tienen sistemas (circulatorio, respiratorio, etc.), que a su vez tienen órganos, tejidos, células, orgánulos, y así sucesivamente. 109 | Patrones comunes|Los sistemas jerárquicos se componen generalmente de sólo unos pocos tipos diferentes de subsistemas en varias combinaciones y órdenes. 110 | Separación de asuntos|Las intra-conexiones de componentes son más fuertes que las inter-conexiones de componentes. Este hecho tiene el efecto de separar los componentes con dinámica de alta frecuencia (involucrando la interacción entre componentes) de los de dinámica de baja frecuencia. En términos sencillos, hay una clara separación de asuntos entre las partes de diferentes niveles de abstracción 111 | Elementos primitivos relativos|La elección de qué componentes en un sistema son primitivos es relativamente arbritraria y mayormente está a discrección del observador del sistema 112 | Formas intermedias estables|Un sistema complejo que funciona invariablemente se encuentra que ha evolucionado a partir de un sistema sencillo que funcionó. Un sistema complejo diseñado desde cero no funciona y no puede ser remendado para hacer que funcione. Usted tiene que comenzar de nuevo, a partir de un sistema sencillo de trabajo 113 | 114 | |Característica|Ejemplo|Ejemplo|Ejemplo 115 | |-|-|-|-| 116 | Estructura jerárquica|**Organización empresarial**: Una empresa grande tiene divisiones (finanzas, operaciones, recursos humanos, etc.), que a su vez pueden tener departamentos, equipos, y roles individuales.|Sistemas operativos: Un sistema operativo se compone de varias capas de abstracción, desde el núcleo (kernel) que interactúa directamente con el hardware, hasta el sistema de archivos, los controladores de dispositivos, y la interfaz de usuario.|Plantas de manufactura y líneas de producción: Una planta de manufactura puede ser vista como un sistema compuesto por diversas líneas de producción (subsistemas), cada una dedicada a la fabricación de partes específicas o al ensamblaje de productos. Dentro de cada línea de producción, encontramos máquinas y estaciones de trabajo 117 | Patrones comunes|Estructuras organizacionales: Muchas empresas adoptan estructuras organizativas comunes, como la matriz o la jerárquica, que se repiten en diferentes sectores y tamaños de empresa.|Software modular: Muchos programas de software están construidos usando patrones de diseño repetitivos que se aplican a diferentes módulos o componentes.|Sistemas de gestión de calidad: como ISO 9001 que se implementan en varios niveles de la organización, utilizando un conjunto común de procesos y procedimientos para asegurar la calidad del producto a través de diferentes departamentos y funciones. 118 | Separación de asuntos|Departamentos especializados en una empresa: Cada departamento se enfoca en tareas específicas (ej., marketing, finanzas) con fuertes conexiones internas, mientras que la interacción entre departamentos se gestiona a través de procesos definidos.|Arquitectura de microservicios: Cada microservicio se enfoca en una funcionalidad específica y se comunica con otros microservicios a través de APIs bien definidas.|Departamentos de ingeniería y producción: La ingeniería se enfoca en el diseño y mejora de productos y procesos, mientras que la producción se centra en la manufactura efectiva de esos productos. Aunque interactúan estrechamente, cada departamento se especializa en tareas específicas con objetivos claros y diferenciados. 119 | Elementos primitivos relativos|Funciones básicas en la gestión empresarial: Lo que se considera una función básica (ej., ventas, logística) puede variar según el enfoque del análisis o la estructura de la empresa.|Lenguajes de programación: Lo que se considera un "elemento primitivo" (por ejemplo, tipos de datos) varía entre lenguajes y puede depender de la perspectiva del desarrollador.|Componentes de maquinaria: Lo que se considera un componente "primitivo" en una máquina (como un sensor, un actuador, o un controlador) puede variar según el enfoque del análisis. Para un ingeniero de mantenimiento, un sensor individual puede ser el elemento de interés, mientras que para el gestor de la planta, la máquina completa puede ser el "elemento básico". 120 | Formas intermedias estables|Desarrollo de nuevos productos o servicios: Las empresas exitosas a menudo comienzan con un producto o servicio simple y efectivo, y luego incrementan su complejidad y alcance gradualmente, basándose en el éxito y la retroalimentación.|Evolución de sistemas operativos: Los sistemas operativos modernos han evolucionado a partir de versiones más simples y estables, agregando complejidad gradualmente.|Desarrollo de líneas de producción: Las líneas de producción eficientes a menudo comienzan como configuraciones simples que funcionan bien. Con el tiempo, se agregan más máquinas y procesos para aumentar la capacidad y la eficiencia. Sin embargo, este crecimiento se basa en la estabilidad y eficacia de la configuración inicial, evolucionando gradualmente para manejar una mayor complejidad sin comprometer la operatividad. 121 | 122 | La historia del ser humano disfruta de **cuatro mecanismos mentales** que facilitan enormemente nuestra comprensión de los sistemas (complejos): 123 | 124 | - Abstracción 125 | - Encapsulación 126 | - Modularización 127 | - Jerarquización 128 | 129 | ### Abstracción 130 | 131 | La abstracción es el proceso mental de extracción de las características esenciales de algo, ignorando los detalles superfluos — Booch 132 | 133 | La abstracción surge de un reconocimiento de similitudes entre ciertos objetos, situaciones o procesos en el mundo real, y la decisión de concentrarse en estas similitudes e ignorar por el momento, las diferencias — Dahl, Dijkstra y Hoare 134 | 135 | La abstracción es una descripción simplificada o especificación de un sistema que hace hincapié en algunos de los detalles o propiedades mientras que suprime otros del sistema. Una buena abstracción es la que hace hincapié en los detalles que son importantes para el lector o usuario y suprime detalles que son, al menos por ahora, de distracción — Shaw 136 | 137 | ||||| 138 | |-|-|-|-| 139 | Una abstracción denota las **características esenciales** de un objeto que lo distinguen de todos los otros tipos de objetos y por lo tanto proporciona límites conceptuales nítidamente definidos, en relación con la perspectiva del espectador.|Una abstracción se centra en la **visión exterior de un objeto** y sirve para separar el comportamiento esencial de un objeto de su implantación|La abstracción es **eminentemente subjetiva**, dependiendo del interés del observador|Nos esforzamos para construir abstracciones de las entidades porque son **directamente paralelos al vocabulario del dominio de un determinado problema**. 140 | 141 | |Perspectiva|Abstracción del Alumno| 142 | |-|-| 143 | |Administrador de empresas|![](/images/modelosUML/plantUML/alumnoADE.svg) 144 | |Ingeniero industrial|![](/images/modelosUML/plantUML/alumnoIOI.svg) 145 | |Ingeniero Informático|![](/images/modelosUML/plantUML/alumnoII.svg)| 146 | 147 | ### Encapsulación 148 | 149 | La encapsulación es proceso por el que se ocultan los detalles del soporte de las características esenciales de una abstracción — Booch 150 | 151 | Principio de Ocultación de la información: todo aquello que no sea necesario dar a conocer, no se debe dar a conocer 152 | 153 | En ninguno de los casos no se trata de ocultar la información en sí misma sino de ocultar los detalles del soporte de dicha información. 154 | 155 | |||| 156 | |-|-|-| 157 | La encapsulación se logra con mayor frecuencia a través de ocultación de información, que es el proceso de **ocultar todos los secretos de un objeto que no contribuyen a sus características esenciales**|La encapsulación proporciona barreras explícitas entre las diferentes abstracciones y por lo tanto conduce a una clara **separación de asuntos**.|El beneficio inmediato será la posibilidad de **cambiar los soportes de las características de una abstracción sin afectar a todos los elementos que dependan de esas características** porque ni los conocen, ni los mencionan 158 | 159 | |Perspectiva|Abstracción|Encapsulación|Con lo cual| 160 | |-|-|-|-| 161 | |Administrador de empresas|![](/images/modelosUML/plantUML/alumnoADE.svg)|Los detalles administrativos, como los procesos internos de calificación, la metodología de enseñanza específica y los sistemas de gestión de información educativa, se mantienen ocultos para el alumno.|Esto permite a la administración ajustar y mejorar estos procesos sin alterar la experiencia general del alumno, manteniendo un enfoque en la calidad y resultados de la educación. 162 | |Ingeniero industrial|![](/images/modelosUML/plantUML/alumnoIOI.svg)|Los algoritmos de personalización de contenido, los sistemas de seguridad para proteger los datos del alumno y las implementaciones técnicas de las plataformas educativas están ocultos al alumno.|El estudiante interactúa con una interfaz sencilla y funcional que le permite acceder a recursos educativos, entregar tareas y recibir retroalimentación, sin necesidad de entender la complejidad tecnológica subyacente. 163 | |Ingeniero Informático|![](/images/modelosUML/plantUML/alumnoII.svg)|Los métodos de análisis de eficiencia, las técnicas de optimización de flujo de trabajo y los detalles de diseño ergonómico de las aulas y materiales educativos están diseñados y mejorados continuamente por el personal docente y administrativo, sin que el alumno necesite conocer estos detalles.|El alumno se beneficia de entornos de aprendizaje optimizados y procesos educativos eficientes, que mejoran su experiencia y rendimiento sin que sea consciente de las complejas decisiones y análisis realizados para lograrlo. 164 | 165 | #### Implicaciones 166 | 167 | Una vez realizada cierta abstracción hay que “trasladarlas” al lenguaje de programación. 168 | 169 | - Esto conlleva decidir entre diversas estructuras de datos (estáticas o dinámicas, en memoria principal o secundaria, etc.) y/o diversos algoritmos (¿con variables auxiliares o no? ¿recursivo o iterativo?, etc.), siendo diversas las alternativas que recogen dichas características esenciales. 170 | - Una vez que se selecciona una implantación, debe ser tratado como un secreto de la abstracción y oculta a la mayoría de los clientes. 171 | 172 | En la práctica, esto significa que cada clase debe tener dos partes: 173 | 174 | |La interfaz|La implementación| 175 | |-|-| 176 | Capta sólo su vista exterior, que abarca nuestra abstracción del comportamiento común a todas las instancias de la clase.|La implementación de una clase comprende la representación de la abstracción, así como los mecanismos para conseguir el comportamiento deseado. 177 | Es el único lugar donde establecemos todas los suposiciones que un cliente puede hacer sobre cualquier instancia de la clase|La implementación encapsula detalles sobre los qué ningún cliente puede hacer suposiciones. 178 | 179 | - La abstracción de un objeto debe preceder a las decisiones acerca de su implantación. 180 | - Ninguna parte de un sistema complejo debe depender de los detalles internos de cualquier otra parte. 181 | 182 | Mientras que la abstracción ayuda a las personas a pensar en lo que están haciendo, la encapsulación permite hacer cambios fiables en el programa con un esfuerzo limitado. 183 | 184 | ### Modularización 185 | 186 | ***La modularidad es el proceso de descomposición de un sistema en un conjunto de piezas poco acoplados y cohesivos*** — Booch 96 187 | 188 | |Acoplamiento|Cohesión| 189 | |-|-| 190 | El acoplamiento “[…​] es la medida de fuerza de la asociación establecida por una conexión ente un módulo -elemento- y otro. El acoplamiento fuerte complica un sistema porque los módulos son más difíciles de comprender, cambiar o corregir por sí mismos si están muy interrelacionados con otros módulos|La cohesión mide el grado de conectividad entre los elementos de un solo módulo 191 | 192 | Al diseñar un sistema de software complejo, ***es esencial descomponerlo en partes más pequeñas y más pequeñas***, cada una de las cuales podemos entonces refinar independientemente. De esta manera, satisfacemos la restricción muy real que existe sobre la capacidad del canal de la cognición humana: para entender cualquier nivel dado de un sistema, sólo necesitamos comprender algunas partes (en lugar de todas las partes) a la vez. 193 | 194 | |||| 195 | |-|-|-| 196 | Para modularizar hay que minimizar las dependencias entre módulos (acoplamiento) que deben tener significado propio por sí mismo agrupando abstracciones lógicamente relacionadas (cohesión).|El bajo acoplamiento de un modulo se basa en la abstracción que limita su interfaz a lo esencial y en la encapsulación que oculta todos los detalles necesarios para su implantación pero innecesarios para otros módulos que se relacionen con éste.|Dividir un programa en una serie de límites documentados bien definidos dentro del programa es de gran valor en la comprensión del programa 197 | 198 | |Perspectiva|Abstracción y Encapsulación|Modularidad 199 | |-|-|-| 200 | |Administrador de empresas|![](/images/modelosUML/plantUML/alumnoADE.svg)|La gestión educativa se puede descomponer en módulos específicos como admisiones, programas académicos, servicios al estudiante y colocación laboral. Cada módulo tiene cohesión alta, enfocándose en aspectos específicos de la experiencia educativa y el desarrollo del alumno. El acoplamiento entre estos módulos es bajo, permitiendo cambios o mejoras en un área sin perturbar significativamente las otras. 201 | |Ingeniero Industrial|![](/images/modelosUML/plantUML/alumnoIOI.svg)|La optimización de la línea de ensamblaje educativa puede verse como la creación de módulos dedicados a diferentes aspectos del proceso educativo: desarrollo curricular, entrega de contenido, evaluación del aprendizaje y mejora del entorno físico y virtual de aprendizaje. Cada módulo es altamente cohesivo, tratando aspectos específicos de la educación, mientras que el acoplamiento entre módulos es bajo, permitiendo la innovación y mejora continua en un área sin desestabilizar otras. 202 | |Ingeniero Informático|![](/images/modelosUML/plantUML/alumnoII.svg)|Los sistemas de información educativa pueden estructurarse en módulos como gestión de cursos, seguimiento del rendimiento del alumno, y plataformas de comunicación. Esto asegura que cada aspecto del sistema (por ejemplo, la entrega de contenido, las evaluaciones y los foros de discusión) sea cohesivo y funcione de manera independiente, mientras que el acoplamiento entre estos módulos se mantiene mínimo. 203 | 204 | ### Jerarquización 205 | 206 | Jerarquía es una clasificación u ordenamiento de las abstracciones — Booch 207 | 208 | La jerarquización es el proceso de estructuración por el que se produce una organización de un conjunto de elementos en grados o niveles de responsabilidad, de clasificación o de composición, …​ entre otros 209 | 210 | **Grafo dirigido acíclico** 211 | 212 | |||| 213 | |-|-|-| 214 | **La abstracción** es una buena cosa pero en todos los casos, excepto las aplicaciones más triviales, podemos encontrar muchas más abstracciones diferentes de lo que podemos comprender a la vez.|**La encapsulación** ayuda a gestionar esta complejidad al ocultar el interior de la vista de nuestras abstracciones.|**La modularidad** ayuda también, por que nos da una manera de agrupar abstracciones relacionados lógicamente. 215 | 216 | Aún así, esto no es suficiente. Un conjunto de abstracciones a menudo forma una jerarquía, y mediante la identificación de estas jerarquías en nuestro diseño se simplifica enormemente nuestra comprensión del problema. 217 | 218 | 219 | ||| 220 | |-|-| 221 | La identificación de las jerarquías dentro de un sistema de software complejo a menudo no es fácil.|Si no revelamos la estructura de clases de un sistema, tendríamos que multiplicar nuestro conocimiento sobre las propiedades de cada parte individual. 222 | Una vez que se exponen esas jerarquías, la estructura de un sistema complejo se vuelve muy simple y obtenemos la comprensión de la misma.|Con la inclusión de la estructura de clases, captamos estas propiedades comunes en un solo lugar. 223 | 224 | |Perspectiva|Abstracción, Encapsulación, Modularidad|Jerarquía 225 | |-|-|-| 226 | |Administrador de empresas|![](/images/modelosUML/plantUML/alumnoADE.svg)|La estructura organizativa de la institución educativa puede ser vista como una jerarquía que clasifica los niveles de responsabilidad y servicios ofrecidos al alumno. En la cima, podríamos tener la administración general, seguida por departamentos especializados (finanzas, servicios estudiantiles, académicos), y dentro de estos, subdepartamentos o equipos dedicados a necesidades específicas del alumno, como asesoramiento, soporte académico y desarrollo profesional. 227 | |Ingeniero Industrial|![](/images/modelosUML/plantUML/alumnoIOI.svg)|En el contexto de los sistemas de información, la jerarquía podría representarse en la arquitectura del software utilizado para la gestión educativa y aprendizaje en línea. Por ejemplo, en la cima estaría el sistema de gestión de aprendizaje (LMS), seguido por módulos específicos como gestión de contenido, foros de discusión, y seguimiento del progreso del alumno. Dentro de cada módulo, podríamos encontrar componentes más detallados, como herramientas de evaluación, bibliotecas de recursos y sistemas de comunicación alumno-profesor. 228 | |Ingeniero Informático|![](/images/modelosUML/plantUML/alumnoII.svg)|En el diseño y optimización de sistemas educativos, la jerarquía podría aplicarse al ordenamiento de los procesos y flujos de trabajo. En el nivel más alto, tendríamos el diseño curricular general y la planificación académica. A un nivel intermedio, se situarían los programas y cursos específicos, y en el nivel más detallado, las lecciones individuales, actividades y evaluaciones. Además, esta jerarquía se extiende al diseño físico y virtual de los espacios de aprendizaje, desde la disposición general de las instalaciones educativas hasta el diseño específico de aulas y entornos virtuales. 229 | 230 | -------------------------------------------------------------------------------- /temario/miembrosClase.md: -------------------------------------------------------------------------------- 1 | # Miembros de Clase 2 | 3 | |Instancia|Clase| 4 | |-|-| 5 | |Los miembros de instancia asumen los aspectos, datos y operaciones, particulares/locales de/a cada objeto de la clase|Los miembros de clase o estáticos asumen los aspectos, datos y operaciones, compartidos/globales por/a la comunidad de objetos de la clase| 6 | |**Atributos de instancia** presentes en cada uno de los objetos de la clase|**Atributos de clase** compartidos por la globalidad de objetos de la clase| 7 | |*Ej.: día, mes y año de una fecha concreta.*|*Ej.: los nombres y duración de los meses de cualquier fecha, excepto en Febrero de años bisiestos...*| 8 | |Si no hay objetos, no hay atributos de instancia|Si no hay objetos, **sí** hay atributos de clase| 9 | |**Métodos de instancia** cuyos mensajes se lanzan sobre un objeto particular de la clase|**Métodos de clase** cuyos mensajes NO se lanzan sobre objetos particulares| 10 | |*Ej.: si una fecha concreta está dentro de la primavera, si una fecha concreta se encuentra en un año bisiesto​*|*Ej.: si un año (de cualquier fecha, no de una fecha particular) es bisiesto*| 11 | 12 | ## Atributos y métodos estaticos 13 | 14 | Caracterizados por la palabra reservada `static` tras su visibilidad 15 | 16 |
17 | 18 | ||| 19 | |-|-| 20 | |**Atributo**|` static = `| 21 | |**Método**|` static ([ { , }])`| 22 | 23 |
24 | 25 | ### Atributos estáticos 26 | 27 | - Su reserva de memoria e inicialización obligatoria se realiza al principio de la ejecución del programa, 28 | - En orden dentro de las declaraciones de la clase pero en desorden entre las distintas clases 29 | - Accesibles desde cualquier método, de instancia o estático, de la clase. 30 | 31 | Notación sintáctica para el acceso desde las expresiones: 32 | 33 | `.` 34 | 35 | ### Métodos estáticos 36 | 37 | - Se permite el acceso a los atributos estáticos 38 | - No se permite el acceso a `this` ni a los atributos de instancia 39 | 40 | Notación sintáctica para la invocación/llamada/ejecución del método estático como sentencia de los métodos: 41 | 42 | `.([ { , }])` 43 | 44 | ## Ejemplo 45 | 46 | ```java 47 | public class Alumno { 48 | private static String nombreUniversidad = "UNEATLANTICO"; 49 | private String nombre; 50 | private int edad; 51 | 52 | public Alumno(String nombre, int edad) { 53 | this.nombre = nombre; 54 | this.edad = edad; 55 | } 56 | 57 | public void presentarse() { 58 | System.out.println("Hola, me llamo " + nombre + " y tengo " + edad + " años."); 59 | } 60 | 61 | public static void cambiarUniversidad(String nombreUniversidad) { 62 | this.nombreUniversidad = nombreUniversidad; 63 | } 64 | 65 | public static String getNombreUniversidad() { 66 | return nombreUniversidad; 67 | } 68 | 69 | public void mostrarUniversidad() { 70 | System.out.println(nombre + " estudia en: " + nombreUniversidad); 71 | } 72 | 73 | public static void main(String[] args) { 74 | 75 | Alumno alumno1 = new Alumno("Juan", 15); 76 | Alumno alumno2 = new Alumno("María", 16); 77 | 78 | alumno1.presentarse(); 79 | alumno2.presentarse(); 80 | 81 | Alumno.cambiarUniversidad("UNINI"); 82 | 83 | System.out.println(Alumno.getNombreUniversidad()); 84 | 85 | alumno1.mostrarUniversidad(); 86 | alumno2.mostrarUniversidad(); 87 | } 88 | } 89 | 90 | ``` 91 | 92 | ## Bloques inicializadores 93 | 94 | Bloques de código que se ejecutan cuando se crea una instancia (***bloque inicializador de instancia***) o cuando se carga la clase (***bloque inicializador estático***). 95 | 96 | ```java 97 | public class Persona { 98 | private String nombre; 99 | private int edad; 100 | 101 | { 102 | nombre = "Sin nombre"; 103 | edad = 0; 104 | } 105 | 106 | static { 107 | System.out.println("Clase Persona cargada"); 108 | } 109 | } 110 | ``` 111 | 112 | ||Constructores|Bloques inicializadores| 113 | |-|-|-| 114 | |**Nombre**|Tienen el mismo nombre que la clase en la que se encuentran.|No tienen nombre propio.| 115 | |**Tipo de retorno**|No tienen un tipo de retorno (ni siquiera void).|Tampoco tienen tipo de retorno.| 116 | |**Llamada**|Se invocan explícitamente cuando se crea un objeto utilizando new.|Se ejecutan automáticamente cuando se crea un objeto (bloque inicializador de instancia) o cuando se carga la clase (bloque inicializador estático).| 117 | |||*Bloques de instancia*: Se ejecutan siempre antes de cualquier constructor en la creación de objetos. 118 | |||*Bloques estáticos*: Se ejecutan solo una vez, cuando se carga la clase por primera vez. 119 | |**Sobrecarga**|Pueden sobrecargarse para ofrecer diferentes formas de inicializar un objeto con distintos parámetros.|No permiten sobrecarga. 120 | |**Función principal**|Inicializan las propiedades de una instancia y permiten recibir parámetros para ajustar los valores.|Se utilizan para inicializar propiedades comunes a todos los constructores, para reducir duplicación de código o para realizar tareas iniciales específicas que no dependen de los parámetros de entrada. 121 | 122 | ```java 123 | public class Persona { 124 | private String nombre; 125 | private int edad; 126 | 127 | { 128 | nombre = "Sin nombre"; 129 | edad = 0; 130 | } 131 | 132 | static { 133 | System.out.println("Clase Persona cargada"); 134 | } 135 | 136 | public Persona(String nombre, int edad) { 137 | this.nombre = nombre; 138 | this.edad = edad; 139 | } 140 | } 141 | ``` 142 | -------------------------------------------------------------------------------- /temario/vistaPrivadaClases.md: -------------------------------------------------------------------------------- 1 | # Vista Privada de las Clases 2 | 3 | > [Punto de partida](ejercicios/001/README.md) 4 | 5 | ## Definición de Atributos 6 | 7 | - **Datos constantes** 8 | - **Variables de tipos primitivos** 9 | - **Referencias a objetos y/o vectores de objetos** 10 | 11 | Se declaran variables y/o constantes de tipos primitivos, referencias a objetos o vectores de éstos, anteponiendo la palabra **private** 12 | 13 | En cualquer punto de la implementación de la clase pero lo lógico es **al principio de la declaración de la clase**. 14 | 15 | ```java 16 | class { 17 | 18 | private 19 | private 20 | ... 21 | } 22 | ``` 23 | 24 | ```java 25 | class Interval { 26 | 27 | private double min; 28 | private double max; 29 | } 30 | ``` 31 | 32 | ## Definición de Constructores 33 | 34 | **Inicialización de los atributos de la clase** 35 | 36 | Reservado para las tareas de inicialización de los atributos del objeto, evitando la creación de objetos incosistentes 37 | 38 | A falta de inicialización explícita, **no recomendado**, se inicializan a valores por defecto, dependiendo de su tipo (0 para tipos numéricos, *false* para el tipo *boolean*, *caracter nulo* para tipo *char* y *null* para referencias); 39 | 40 | ```java 41 | class Interval { 42 | 43 | private double min; 44 | private double max; 45 | 46 | public Interval(){ 47 | min = 0; 48 | max = 0; 49 | } 50 | 51 | public Interval(double maximum){ 52 | min = 0; 53 | max = maximum; 54 | } 55 | 56 | public Interval(double minimum, double maximum){ 57 | min = minimum; 58 | max = maximum; 59 | } 60 | ... 61 | } 62 | 63 | ``` 64 | 65 | ## Definición de Métodos 66 | 67 | **Operaciones con sentencias secuenciales, alternativos, iterativas, expresiones (asignación) y/o de retorno** 68 | 69 | En cualquier punto de la implementación de la clase, se define el cuerpo de las cabeceras de los métodos acompañándolos de una sentencia secuencial que contiene las declaraciones locales y sentencias que se consideren oportunas 70 | 71 | Dentro del cuerpo del método se tiene acceso a los atributos, los parámetros del método y a las declaraciones locales desde las expresiones de la anidación jerárquica de sentencias 72 | 73 | La notación punto para el paso de mensajes sirve también para acceder a los atributos de un objeto de la misma clase 74 | 75 | ```java 76 | clase { 77 | 78 | public 79 | public 80 | ... 81 | } 82 | ``` 83 | 84 | ```java 85 | class Interval { 86 | 87 | private double min; 88 | private double max; 89 | 90 | public void shift (double amount) { 91 | min += amount; 92 | max += amount; 93 | } 94 | 95 | public Interval(Interval interval){ 96 | min = interval.min; 97 | max = interval.max; 98 | } 99 | 100 | public boolean equals(Intervalo interval) { 101 | return min == interval.min && max == interval.max; 102 | } 103 | ... 104 | } 105 | ``` 106 | 107 | Si el tipo devuelto no es_ void, se determinará el valor devuelto por el método con la siguiente sentencia: 108 | 109 | ```java 110 | 111 | return ; 112 | 113 | ``` 114 | 115 | ```java 116 | 117 | public double length() { 118 | return max - min; 119 | } 120 | 121 | public boolean includes(double point) { 122 | return min <= point && point <= max; 123 | } 124 | 125 | public boolean valid() { 126 | return min <= max; 127 | } 128 | 129 | ``` 130 | 131 | ## Referencia this 132 | 133 | **Para la resolución de colisión de identificadores y reutilización de métodos dentro de la clase** 134 | 135 | ***this*** es una referencia constante que guarda la dirección del objeto que recibe el mensaje correspondiente al método que se está definiendo, implícitamente existe en todas las clases: 136 | 137 | ```java 138 | 139 | private final this; 140 | 141 | ``` 142 | 143 | ### Para evitar la multiplicidad de identificadores innecesarios 144 | 145 | Sirve para resolución de ambigüedades en la colisión de parámetros o declaraciones locales con el mismo nombre que los atributos; 146 | 147 | ```java 148 | 149 | public Interval(double min, double max) { 150 | this.min = min; 151 | this.max = max; 152 | } 153 | 154 | ``` 155 | 156 | ### Para la reutilización de constructures 157 | 158 | Sirve para la reutilización de contructores en la definición de otros constructores, siendo la primera sentencia del constructor, mediante la sintaxis: 159 | 160 | ```java 161 | 162 | this([ {, }]); 163 | 164 | ``` 165 | 166 | ```java 167 | 168 | public Interval() { 169 | this(0, 0); 170 | } 171 | 172 | public Interval(double max) { 173 | this(0, max); 174 | } 175 | 176 | public Interval(Interval interval) { 177 | this(interval.min, interval.max); 178 | } 179 | 180 | ``` 181 | 182 | ### Para la reutilización de métodos 183 | 184 | Sirve para la reutilización de métodos en la codificación de otros métodos 185 | 186 | ```java 187 | 188 | public boolean includes(Interval interval) { 189 | return this.includes(interval.min) && this.includes(interval.max); 190 | } 191 | 192 | public void escale(double escale) { 193 | final double newHalfLength = this.length()/2 * escale; 194 | final double middlePoint = this.middlePoint(); 195 | this.min = middlePoint - newHalfLength; 196 | this.max = middlePoint + newHalfLength; 197 | } 198 | 199 | ``` 200 | 201 | ## Métodos privados 202 | 203 | **Para la reutilización de métodos dentro de la clase** 204 | 205 | Sirve para la reutilización de métodos en la codificación de otros métodos 206 | 207 | Dado que puede ser conveniente disponer de métodos, que no han sido solicitados, para implementar otros métodos, cabe la posibilidad de definir métodos de ámbito privado que sólo se pueden usar en la implementación de la clase 208 | 209 | ```java 210 | 211 | class { 212 | private 213 | private 214 | ... 215 | } 216 | 217 | ``` 218 | 219 | ```java 220 | 221 | public Interval shifted(double amount) { 222 | Interval interval = this.clone(); 223 | interval.shift(amount); 224 | return interval; 225 | } 226 | 227 | private Interval clone() { 228 | return new Interval(this); 229 | } 230 | 231 | ``` 232 | -------------------------------------------------------------------------------- /temario/vistaPrivadaObjetos.md: -------------------------------------------------------------------------------- 1 | # Vista privada de objetos 2 | 3 | ## Desencadenamiento de instanciaciones 4 | 5 | Se crea un objeto (instancia), por lo que: 6 | 7 | - Se crean los atributos definidos en la clase; 8 | - Se ejecuta la inicialización de los atributos con posibles creaciones de nuevos objetos; 9 | - Se ejecuta el constructor en la creación del objeto con posibles creaciones de nuevos objetos; 10 | 11 | Y, recursivamente, se pueden crear nuevos objetos de otras clases hasta llegar, de esta manera, a la creación de objetos que se basan directamente en tipos primitivos. 12 | 13 | ## Desencadenamiento de mensajes 14 | 15 | Se lanza un mensaje a un objeto, por lo que: 16 | 17 | - Se crean las declaraciones locales con su inicialización y se ejecuta el cuerpo del método correspondiente 18 | 19 | - Se pueden lanzar nuevos mensajes a objetos que sean atributos de su clase, a objetos que sean argumentos del mensaje o a objetos que se crean en su ejecución 20 | 21 | Y, recursivamente, pueden lanzar nuevos mensajes en la definición de sus respectivos métodos hasta llegar, de esta manera, a la definición de métodos que se basan directamente en tipos primitivos. 22 | 23 | |El desencadenamiento de instanciaciones|El desencadenamiento de mensajes| 24 | |-|-| 25 | |Puede provocar un desencadenamiento de mensajes a través de la ejecución de los constructores que pueden lanzar mensajes|Puede provocar un desencadenamiento de instanciaciones a través de la creación de objetos en la definición de los métodos. 26 | 27 | -------------------------------------------------------------------------------- /temario/vistaPublicaClases.md: -------------------------------------------------------------------------------- 1 | # Vista pública de las Clases 2 | 3 | ## Sintaxis 4 | 5 | ```java 6 | class { 7 | 8 | } 9 | ``` 10 | 11 | ## Cabecera de métodos de la clase 12 | 13 | ```java 14 | public ({ , ...}*) 15 | 16 | ``` 17 | 18 | - Tipo1 indica el tipo del valor devuelto, que puede ser:_ 19 | - void, nada, dado que el efecto será un cambio de estado en el objeto y/o sistema 20 | - , un valor de tipo primitivo o una referencia a un objeto de una clase 21 | - [], una referencia a un vector de valores de tipos primitivos o de referencias a objetos 22 | - [][], una referencia a una matriz de valores de tipos primitivos o de referencias a objetos 23 | - etc... 24 | - el nombre del método debe comenzar con minúscula 25 | - el tipo2 puede ser igual que tipo1 excepto void 26 | - Todos los parámetros son pasados **por valor** 27 | 28 | > *En Java, cuando se pasa un parámetro a un método, lo que se pasa realmente es una **copia del valor** de ese parámetro. Esto implica que cualquier cambio en ese valor dentro del método no afectará al valor original fuera del método.

29 | Sin embargo, la confusión suele surgir cuando se trata de objetos. En Java, las variables de tipo objeto en realidad contienen **referencias a objetos** en lugar de los objetos mismos. Cuando se pasa una variable de objeto a un método, Java pasa la copia de la referencia al objeto. Aunque técnicamente esto sigue siendo "pasar por valor" (porque la referencia se copia por valor), en la práctica significa que el método llamado puede modificar el objeto al que apunta la referencia. Esto es porque tanto la referencia original como la copia apuntan al mismo objeto en la memoria.

Es crucial entender que, aunque se pueda modificar el objeto al que apunta la referencia dentro del método (porque la referencia copiada apunta al mismo objeto), no se puede cambiar la referencia original para que apunte a un nuevo objeto. En otras palabras, dentro del método, si se intenta hacer que la referencia copiada apunte a un nuevo objeto, esto no afectará a la referencia original fuera del método.* 30 | 31 | ## Sobrecarga de métodos 32 | 33 | Varios métodos pueden tener el mismo nombre con las siguientes restricciones: 34 | 35 | - Si están en la misma clase, deben diferenciarse en el número o tipo de parámetros comparados dos a dos. 36 | - Si están en distintas clases, no existe restricción. 37 | 38 | ## Constructores 39 | 40 | Son métodos que reúnen las tareas de inicialización (no construyen) y se lanzan automáticamente en la construcción de objetos. 41 | 42 | - `public NombreDeLaClase()` 43 | - Deben coincidir su nombre con el de la clase; 44 | - No devuelven nada (ni void); 45 | - No se pueden lanzar mensajes que se correspondan con los constructores de la clase. 46 | 47 | ## Destructores 48 | 49 | Son métodos que reúnen las tareas de liberación de recursos (no destruyen) y se lanzan automáticamente en la destrucción de objetos. 50 | 51 | - Su cabecera debe ser: `public void finalize()` 52 | - No se pueden lanzar mensajes que se correspondan con los destructores de la clase. 53 | - muy poco frecuentes porque: 54 | - Java tiene incorporado un recolector de basura que libera automáticamente la memoria dinámica no apuntada por ninguna referencia 55 | - normalmente un objeto no “vive” con una línea de comunicación, un fichero abierto, ... que deba cerrar y, en tal caso, es preferible gestionar dichos recursos sin intervención de automatismos 56 | -------------------------------------------------------------------------------- /temario/vistaPublicaClasesEjemplos.md: -------------------------------------------------------------------------------- 1 | # Vista pública de las Clases - Ejemplos 2 | 3 | ```java 4 | class Intervalo { 5 | 6 | public Intervalo(double puntoInicial, double puntoFinal) 7 | public Intervalo() 8 | public Intervalo(double punto) 9 | public Intervalo(Intervalo intervalo) 10 | 11 | public void mostrar() 12 | public void recoger() 13 | public double longitud() 14 | public double puntoMedio() 15 | public void escalar(double factor) 16 | public void desplazar(double desplazamiento) 17 | public boolean incluye(double punto) 18 | public boolean incluye(Intervalo intervalo) 19 | public boolean igual(Intervalo intervalo) 20 | public boolean distinto(Intervalo intervalo) 21 | public boolean intersecta(Intervalo intervalo) 22 | public Intervalo simetrico() 23 | public Intervalo desplazado(double desplazamiento) 24 | public Intervalo interseccion(Intervalo intervalo) 25 | public Intervalo union(Intervalo intervalo) 26 | public Intervalo entre(Intervalo intervalo) 27 | public Intervalo[] trozos(int trozos) 28 | } 29 | ``` 30 | 31 | --- 32 | 33 | ```java 34 | class Rectangulo { 35 | public void mostrar() 36 | public void recoger() 37 | public double area() 38 | public double perimetro() 39 | public void escalar(double factor) 40 | public void desplazar(double distanciaX, double distanciaY) 41 | public boolean contienePunto(double x, double y) 42 | public boolean intersecta(Rectangulo rectangulo) 43 | public Rectangulo interseccion(Rectangulo rectangulo) 44 | public Rectangulo union(Rectangulo rectangulo) 45 | public void rotar(int grados) 46 | public Rectangulo[] dividir(double x, double y, char orientacion) 47 | public void establecerColor(String color) 48 | public String obtenerColor() 49 | public void establecerTransparencia(double porcentaje) 50 | public double obtenerTransparencia() 51 | } 52 | ``` 53 | 54 | --- 55 | 56 | ```java 57 | class Poligono { 58 | public void mostrar() 59 | public void recoger() 60 | public double area() 61 | public double perimetro() 62 | public void escalar(double factor) 63 | public void desplazar(double distanciaX, double distanciaY) 64 | public boolean contienePunto(double x, double y) 65 | public void rotar(double angulo, double anguloX, double anguloY) 66 | public boolean intersecta(Poligono poligono) 67 | public Poligono interseccion(Poligono poligono) 68 | public Poligono union(Poligono poligono) 69 | public void añadirVertice(double x, double y) 70 | public void eliminarVertice(int indice) 71 | public Poligono envolventeConvexa() 72 | public int numeroDeVertices() 73 | public void normalizar() 74 | } 75 | ``` 76 | 77 | --- 78 | 79 | ```java 80 | class Libro { 81 | public void establecerTitulo(String titulo) 82 | public String obtenerTitulo() 83 | public void establecerAutor(String autor) 84 | public String obtenerAutor() 85 | public void establecerEditorial(String editorial) 86 | public String obtenerEditorial() 87 | public void establecerAñoPublicacion(int año) 88 | public int obtenerAñoPublicacion() 89 | public void establecerISBN(String ISBN) 90 | public String obtenerISBN() 91 | public void establecerCantidadPaginas(int paginas) 92 | public int obtenerCantidadPaginas() 93 | public void añadirEtiqueta(String etiqueta) 94 | public boolean eliminarEtiqueta(String etiqueta) 95 | public String[] obtenerEtiquetas() 96 | public void establecerDisponibilidad(boolean disponible) 97 | public boolean estaDisponible() 98 | public String generarResumen() 99 | public void registrarPrestamo() 100 | public void registrarDevolucion() 101 | public int contarPrestamos() 102 | } 103 | ``` 104 | 105 | --- 106 | 107 | ```java 108 | class CuentaBancaria { 109 | public void depositar(double cantidad) 110 | public boolean retirar(double cantidad) 111 | public double consultarSaldo() 112 | public boolean transferir(double cantidad, CuentaBancaria destino) 113 | public String obtenerNumeroDeCuenta() 114 | public String obtenerTitular() 115 | public void cambiarPin(String nuevoPin) 116 | public boolean validarPin(String pin) 117 | public void bloquearCuenta() 118 | public void desbloquearCuenta() 119 | public String generarEstadoDeCuenta() 120 | public void establecerLimiteRetiroDiario(double limite) 121 | public double obtenerLimiteRetiroDiario() 122 | public boolean establecerNotificaciones(boolean activar, String tipo) 123 | public void añadirTitularSecundario(Persona titular) 124 | public void eliminarTitularSecundario(Persona titular) 125 | public Persona[] obtenerTitulares() 126 | } 127 | ``` 128 | -------------------------------------------------------------------------------- /temario/vistaPublicaObjetos.md: -------------------------------------------------------------------------------- 1 | # Vista pública de los objetos 2 | 3 |
4 | 5 | |Creación|Referencia|Interacción| 6 | |-|-|-| 7 | Crear objetos|Referenciar objetos|Enviar mensajes 8 | Creación de vectores de objetos|Referencia a un vector de referencias a objetos 9 | 10 |
11 | 12 | --- 13 | 14 | ## Creación de objetos 15 | 16 | ***new*** es un operador unario prefijo cuyo operando es una clase de objetos y **devuelve la dirección de memoria donde se ha reservado el espacio para dicho objeto**. 17 | 18 | ### Sintaxis f 19 | 20 | ```java 21 | new ([, ...]) 22 | ``` 23 | 24 | - La lista de expresiones debe coincidir con la lista de parámetros de alguno de los constructores de la clase 25 | - En caso de no existir constructor, la lista debe estar vacía. 26 | 27 |
28 | 29 |
30 | 31 | ```java 32 | new Intervalo() 33 | new Intervalo(100) 34 | new Intervalo(11.5, 55.1) 35 | new Intervalo(new Intervalo(-1, 1)) 36 | ``` 37 | 38 | ## Referencia a un objeto 39 | 40 | Variable puntero que alberga la dirección de un objeto de una clase. 41 | 42 | ```java 43 | [final] [=]; 44 | ``` 45 | 46 | - A falta de inicialización, su dirección es **null** 47 | - **final** obliga a la inicialización y fija su valor para la referencia. 48 | 49 | ```java 50 | Intervalo intervalo; 51 | ``` 52 | 53 |
54 | 55 |
56 | 57 | ### Operadores 58 | 59 | ||| 60 | |-|-| 61 | |` = `|Asigna la dirección a la referencia siendo del mismo tipo 62 | |` == `|Determina si dos direcciones a objetos de la misma clase son iguales 63 | |` != `|Determina si dos direcciones a objetos de la misma clase son distintas 64 | 65 | ```java 66 | final Intervalo HORARIO = new Intervalo(7, 15); 67 | Intervalo edades = new Intervalo(100); 68 | Intervalo años; 69 | años = edades; 70 | boolean mismo = edades == años; 71 | ``` 72 | 73 | ## Paso de mensajes 74 | 75 | ```java 76 | .([{, })] 77 | ``` 78 | 79 | Donde el método (sin contemplar constructores ni destructores) debe estar presente en la interfaz de la clase del objeto y la lista de expresiones debe coincidir en número y tipos a la lista de parámetros del método. 80 | 81 | ```java 82 | intervalo.longitud() 83 | new Intervalo(-100, 100).longitud() 84 | edades.partido(5) 85 | años.incluye(88) 86 | edades.interseccion(años) 87 | ``` 88 | 89 | ## Creación de vectores de objetos 90 | 91 | **new** es operador unario prefijo cuyo operando es un vector de referencias a objetos de una clase y devuelve la dirección de memoria donde se ha reservado el espacio para dicho vector. 92 | 93 | ### Sintaxis g 94 | 95 | ```java 96 | new [] 97 | ``` 98 | 99 | - La expresión debe ser de tipo entero y determina la longitud de referencias del vector inicializadas a **null** 100 | 101 |
102 | 103 |
104 | 105 | ```java 106 | new Intervalo[100] 107 | ``` 108 | 109 | 110 | ### Sintaxis h 111 | 112 | ```java 113 | new [] { , ..., } 114 | ``` 115 | 116 | - Cada expresión debe ser una dirección a un objeto de la clase que inicializan las referencias del vector creado de longitud igual al número de expresiones; 117 | 118 | ```java 119 | Intervalo intervalo = new Intervalo(); 120 | new Intervalo[] {new Intervalo(), null, intervalo) 121 | ``` 122 | 123 |
124 | 125 | ![](/images/EjemploSintaxisH.jpg) 126 | 127 |
128 | 129 | 130 | ## Referencia a un vector de referencias a objetos 131 | 132 | Es una variable puntero que alberga la dirección de un vector de referencias a objetos de una clase. 133 | 134 | ```java 135 | [final] [] [= ]; 136 | ``` 137 | 138 | - Si no se inicializa, su dirección es **null** 139 | - **final** obliga a la inicialización y fija el valor de la referencia 140 | 141 | ```java 142 | Intervalo[] intervalos; 143 | Intervalo[] intervalos = new Intervalo[10]; 144 | intervalos[0] = new Intervalo (); 145 | intervalos[1] = intervalos[0].desplazados(1); 146 | intervalos[intervalos.length-1] = new Intervalo(2,2); 147 | Intervalo intervalo = intervalos[1]; 148 | intervalos = null; 149 | ``` 150 | --------------------------------------------------------------------------------