├── .gitignore ├── MyMedicalAppointments └── src │ ├── Main.java │ ├── UI │ ├── UIDoctorMenu.java │ ├── UIMenu.java │ └── UIPatientMenu.java │ └── model │ ├── AppointmentDoctor.java │ ├── AppointmentNurse.java │ ├── Doctor.java │ ├── ISchedulable.java │ ├── Nurse.java │ ├── Patient.java │ └── User.java ├── README.md └── java-se-orientado-a-objetos.pdf /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | # Created by https://www.toptal.com/developers/gitignore/api/java,intellij,intellij+all 3 | # Edit at https://www.toptal.com/developers/gitignore?templates=java,intellij,intellij+all 4 | 5 | ### Intellij ### 6 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider 7 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 8 | 9 | # User-specific stuff 10 | .idea/**/workspace.xml 11 | .idea/**/tasks.xml 12 | .idea/**/usage.statistics.xml 13 | .idea/**/dictionaries 14 | .idea/**/shelf 15 | 16 | # Generated files 17 | .idea/**/contentModel.xml 18 | 19 | # Sensitive or high-churn files 20 | .idea/**/dataSources/ 21 | .idea/**/dataSources.ids 22 | .idea/**/dataSources.local.xml 23 | .idea/**/sqlDataSources.xml 24 | .idea/**/dynamic.xml 25 | .idea/**/uiDesigner.xml 26 | .idea/**/dbnavigator.xml 27 | 28 | # Gradle 29 | .idea/**/gradle.xml 30 | .idea/**/libraries 31 | 32 | # Gradle and Maven with auto-import 33 | # When using Gradle or Maven with auto-import, you should exclude module files, 34 | # since they will be recreated, and may cause churn. Uncomment if using 35 | # auto-import. 36 | # .idea/artifacts 37 | # .idea/compiler.xml 38 | # .idea/jarRepositories.xml 39 | # .idea/modules.xml 40 | # .idea/*.iml 41 | # .idea/modules 42 | # *.iml 43 | # *.ipr 44 | 45 | # CMake 46 | cmake-build-*/ 47 | 48 | # Mongo Explorer plugin 49 | .idea/**/mongoSettings.xml 50 | 51 | # File-based project format 52 | *.iws 53 | 54 | # IntelliJ 55 | out/ 56 | 57 | # mpeltonen/sbt-idea plugin 58 | .idea_modules/ 59 | 60 | # JIRA plugin 61 | atlassian-ide-plugin.xml 62 | 63 | # Cursive Clojure plugin 64 | .idea/replstate.xml 65 | 66 | # Crashlytics plugin (for Android Studio and IntelliJ) 67 | com_crashlytics_export_strings.xml 68 | crashlytics.properties 69 | crashlytics-build.properties 70 | fabric.properties 71 | 72 | # Editor-based Rest Client 73 | .idea/httpRequests 74 | 75 | # Android studio 3.1+ serialized cache file 76 | .idea/caches/build_file_checksums.ser 77 | 78 | ### Intellij Patch ### 79 | # Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721 80 | 81 | # *.iml 82 | # modules.xml 83 | # .idea/misc.xml 84 | # *.ipr 85 | 86 | # Sonarlint plugin 87 | # https://plugins.jetbrains.com/plugin/7973-sonarlint 88 | .idea/**/sonarlint/ 89 | 90 | # SonarQube Plugin 91 | # https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin 92 | .idea/**/sonarIssues.xml 93 | 94 | # Markdown Navigator plugin 95 | # https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced 96 | .idea/**/markdown-navigator.xml 97 | .idea/**/markdown-navigator-enh.xml 98 | .idea/**/markdown-navigator/ 99 | 100 | # Cache file creation bug 101 | # See https://youtrack.jetbrains.com/issue/JBR-2257 102 | .idea/$CACHE_FILE$ 103 | 104 | # CodeStream plugin 105 | # https://plugins.jetbrains.com/plugin/12206-codestream 106 | .idea/codestream.xml 107 | 108 | ### Intellij+all ### 109 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider 110 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 111 | 112 | # User-specific stuff 113 | 114 | # Generated files 115 | 116 | # Sensitive or high-churn files 117 | 118 | # Gradle 119 | 120 | # Gradle and Maven with auto-import 121 | # When using Gradle or Maven with auto-import, you should exclude module files, 122 | # since they will be recreated, and may cause churn. Uncomment if using 123 | # auto-import. 124 | # .idea/artifacts 125 | # .idea/compiler.xml 126 | # .idea/jarRepositories.xml 127 | # .idea/modules.xml 128 | # .idea/*.iml 129 | # .idea/modules 130 | # *.iml 131 | # *.ipr 132 | 133 | # CMake 134 | 135 | # Mongo Explorer plugin 136 | 137 | # File-based project format 138 | 139 | # IntelliJ 140 | 141 | # mpeltonen/sbt-idea plugin 142 | 143 | # JIRA plugin 144 | 145 | # Cursive Clojure plugin 146 | 147 | # Crashlytics plugin (for Android Studio and IntelliJ) 148 | 149 | # Editor-based Rest Client 150 | 151 | # Android studio 3.1+ serialized cache file 152 | 153 | ### Intellij+all Patch ### 154 | # Ignores the whole .idea folder and all .iml files 155 | # See https://github.com/joeblau/gitignore.io/issues/186 and https://github.com/joeblau/gitignore.io/issues/360 156 | 157 | .idea/ 158 | 159 | # Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-249601023 160 | 161 | *.iml 162 | modules.xml 163 | .idea/misc.xml 164 | *.ipr 165 | 166 | # Sonarlint plugin 167 | .idea/sonarlint 168 | 169 | ### Java ### 170 | # Compiled class file 171 | *.class 172 | 173 | # Log file 174 | *.log 175 | 176 | # BlueJ files 177 | *.ctxt 178 | 179 | # Mobile Tools for Java (J2ME) 180 | .mtj.tmp/ 181 | 182 | # Package Files # 183 | *.jar 184 | *.war 185 | *.nar 186 | *.ear 187 | *.zip 188 | *.tar.gz 189 | *.rar 190 | 191 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml 192 | hs_err_pid* 193 | 194 | # End of https://www.toptal.com/developers/gitignore/api/java,intellij,intellij+all 195 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/Main.java: -------------------------------------------------------------------------------- 1 | import static UI.UIMenu.*; 2 | 3 | public class Main { 4 | 5 | public static void main(String[] args) { 6 | 7 | //Mostar menú de la UI 8 | showMenu(); 9 | 10 | } 11 | 12 | } 13 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/UI/UIDoctorMenu.java: -------------------------------------------------------------------------------- 1 | package UI; 2 | 3 | import UI.UIMenu; 4 | import model.Doctor; 5 | 6 | import java.util.ArrayList; 7 | import java.util.Scanner; 8 | 9 | public class UIDoctorMenu { 10 | 11 | public static ArrayList doctorsAvailableAppointments = new ArrayList<>(); 12 | 13 | public static void showDoctorMenu() { 14 | 15 | int response = 0; 16 | do { 17 | 18 | // Mostrar menú 19 | System.out.println("\n\n"); 20 | System.out.println("🩺 Doctor"); 21 | System.out.println("Welcome " + UIMenu.doctorLogged.getName()); 22 | 23 | System.out.println("1. Add Available Appointment"); 24 | System.out.println("2, My Schedule appointments"); 25 | System.out.println("0. Logout"); 26 | 27 | // Obtener la opción elegida por el doctor 28 | Scanner scanner = new Scanner(System.in); 29 | response = Integer.parseInt(scanner.nextLine()); 30 | 31 | // Evaluar la opción elegida por el doctor 32 | switch (response) { 33 | case 1: 34 | showAddAvailableAppointmentMenu(); 35 | break; 36 | case 2: 37 | break; 38 | case 0: 39 | UIMenu.showMenu(); 40 | break; 41 | } 42 | 43 | } while (response != 0); 44 | 45 | } 46 | 47 | private static void showAddAvailableAppointmentMenu() { 48 | 49 | int response = 0; 50 | do { 51 | 52 | System.out.println("\n"); 53 | System.out.println(":: 📝 Add Available Appointment"); 54 | System.out.println(":: Select a Month"); 55 | 56 | for (int i = 0; i < 3; i++) { 57 | 58 | int j = i + 1; 59 | System.out.println(j + ". " + UIMenu.MONTHS[i]); 60 | 61 | } 62 | System.out.println("0. ↩ Return"); 63 | 64 | Scanner scanner = new Scanner(System.in); 65 | response = Integer.parseInt(scanner.nextLine()); 66 | 67 | if (response > 0 && response < 4) { 68 | 69 | int monthSelected = response; 70 | System.out.println(monthSelected + " . " + UIMenu.MONTHS[monthSelected - 1]); 71 | 72 | System.out.println("Insert the date available: [dd/mm/yyyy]"); 73 | String date = scanner.nextLine(); 74 | 75 | System.out.println("You date is: " + date + "\n1. Correct \n2. Change date"); 76 | int responseDate = Integer.parseInt(scanner.nextLine()); 77 | 78 | // Volver a mostrar el menú si se quiere cambiar la fecha de la cita 79 | if (responseDate == 2) continue; 80 | 81 | int responseTime = 0; 82 | String time = ""; 83 | do { 84 | 85 | System.out.println("Insert the time available for date: " + date + " [hh:mm]"); 86 | time = scanner.nextLine(); 87 | System.out.println("You time is: " + time + "\n1. Correct \n2. Change time"); 88 | responseTime = Integer.parseInt(scanner.nextLine()); 89 | 90 | } while (responseTime == 2); 91 | 92 | UIMenu.doctorLogged.addAvailableAppointment(date, time); 93 | checkDoctorAvailableAppointments(UIMenu.doctorLogged); 94 | 95 | } else if (response == 0) { 96 | 97 | showDoctorMenu(); 98 | 99 | } 100 | 101 | } while (response != 0); 102 | 103 | } 104 | 105 | private static void checkDoctorAvailableAppointments(Doctor doctor) { 106 | 107 | // Verificar si un doctor tiene citas y no esta en el arrayList de doctores con citas 108 | if (doctor.getAvailableAppointments().size() > 0 && !doctorsAvailableAppointments.contains(doctor)) { 109 | 110 | // Si sew cumplen ambas condiciones se añade el doctor al arrayList 111 | doctorsAvailableAppointments.add(doctor); 112 | 113 | } 114 | 115 | } 116 | 117 | } 118 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/UI/UIMenu.java: -------------------------------------------------------------------------------- 1 | package UI; 2 | 3 | import model.Doctor; 4 | import model.Patient; 5 | 6 | import java.util.ArrayList; 7 | import java.util.Scanner; 8 | 9 | public class UIMenu { 10 | 11 | public static final String[] MONTHS = {"Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"}; 12 | public static Doctor doctorLogged; 13 | public static Patient patientLogged; 14 | 15 | // Métodos 16 | // Mostrar menú 17 | public static void showMenu() { 18 | System.out.println("Welcome to My Appointments"); 19 | System.out.println("Selecciona la opción deseada"); 20 | 21 | int response = 0; 22 | do { 23 | System.out.println("1. Doctor"); 24 | System.out.println("2. Patient"); 25 | System.out.println("0. Salir"); 26 | 27 | Scanner sc = new Scanner(System.in); 28 | response = Integer.parseInt(sc.nextLine()); 29 | 30 | switch (response){ 31 | case 1: 32 | System.out.println("Doctor"); 33 | authUser(1); 34 | response = 0; 35 | break; 36 | case 2: 37 | authUser(2);; 38 | response = 0; 39 | break; 40 | case 0: 41 | System.out.println("Thank you for you visit"); 42 | break; 43 | default: 44 | System.out.println("Please select a correct answer"); 45 | } 46 | }while (response != 0); 47 | } 48 | 49 | public static void showPatientMenu() { 50 | int response = 0; 51 | do { 52 | System.out.println("\n\n"); 53 | System.out.println("model.Patient"); 54 | System.out.println("1. Book an appointment"); 55 | System.out.println("2. My appointments"); 56 | System.out.println("0. Return"); 57 | 58 | Scanner sc = new Scanner(System.in); 59 | response = Integer.parseInt(sc.nextLine()); 60 | 61 | switch (response) { 62 | case 1: 63 | System.out.println("::Book an appointment"); 64 | for (int i = 0; i < 3; i++) { 65 | System.out.println(i + ". " + MONTHS[i]); 66 | } 67 | break; 68 | case 2: 69 | System.out.println("::My appointments"); 70 | break; 71 | case 0: 72 | showMenu(); 73 | break; 74 | } 75 | } while (response != 0); 76 | } 77 | 78 | private static void authUser(int userType) { 79 | 80 | /* 81 | userType = 1 → Doctor 82 | userType = 2 → Paciente 83 | */ 84 | 85 | ArrayList doctors = new ArrayList<>(); 86 | doctors.add(new Doctor("Julian Duque", "julian@santaclara.health")); 87 | doctors.add(new Doctor("Karen Sosa", "karen@santaclara.health")); 88 | doctors.add(new Doctor("Rocío Gómez", "rocio@santaclara.health")); 89 | 90 | ArrayList patients = new ArrayList<>(); 91 | patients.add(new Patient("Andrés López", "andres@example.com")); 92 | patients.add(new Patient("David Guzmán", "david@example.com")); 93 | patients.add(new Patient("Manuela Ortiz", "manuela@example.com")); 94 | 95 | boolean isEmailCorrect = false; 96 | do { 97 | 98 | System.out.println("Insert your Email: [user@example.com]"); 99 | Scanner scanner = new Scanner(System.in); 100 | String email = scanner.nextLine(); 101 | 102 | if (userType == 1) { 103 | 104 | for (Doctor doctor : doctors) { 105 | 106 | if (doctor.getEmail().equals(email)) { 107 | 108 | isEmailCorrect = true; 109 | 110 | // Obtener el usuario logueado. 111 | doctorLogged = doctor; 112 | 113 | // Mostrar menú del Doctor 114 | UIDoctorMenu.showDoctorMenu(); 115 | 116 | } 117 | 118 | } 119 | 120 | } else if (userType == 2) { 121 | 122 | for (Patient patient : patients) { 123 | 124 | if (patient.getEmail().equals(email)) { 125 | 126 | isEmailCorrect = true; 127 | 128 | // Obtener el usuario logueado. 129 | patientLogged = patient; 130 | 131 | // Mostrar menú del paciente 132 | 133 | } 134 | 135 | } 136 | 137 | } 138 | 139 | } while (!isEmailCorrect); 140 | 141 | } 142 | 143 | } 144 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/UI/UIPatientMenu.java: -------------------------------------------------------------------------------- 1 | package UI; 2 | 3 | import model.Doctor; 4 | 5 | import java.util.ArrayList; 6 | import java.util.Map; 7 | import java.util.Scanner; 8 | import java.util.TreeMap; 9 | 10 | public class UIPatientMenu { 11 | 12 | public static void showPatientMenu() { 13 | 14 | int response = 0; 15 | do { 16 | 17 | // Mostar el menú del usuario 18 | System.out.println("\n\n"); 19 | System.out.println("😷 Patient"); 20 | System.out.println("Welcome " + UIMenu.patientLogged); 21 | 22 | System.out.println("1. Book an appointment"); 23 | System.out.println("2. My appointments"); 24 | System.out.println("0. Logout"); 25 | 26 | // Obtener la opción elegida por el usuario 27 | Scanner scanner = new Scanner(System.in); 28 | response = Integer.parseInt(scanner.nextLine()); 29 | 30 | // Evaluar la opción elegida por el usuario 31 | switch (response) { 32 | 33 | case 1: 34 | break; 35 | case 2: 36 | break; 37 | case 0: 38 | UIMenu.showMenu(); 39 | break; 40 | 41 | } 42 | 43 | } while (response != 0); 44 | 45 | } 46 | 47 | // Métodos 48 | private static void showBookAppointmentMenu() { 49 | 50 | int response = 0; 51 | do { 52 | 53 | System.out.println(":: 📝 Book an appointment"); 54 | System.out.println(":: Select a date:"); 55 | 56 | /* 57 | Map para mostrar los doctores que tienen citas disponibles 58 | Key Map externo → Numeración de la lista de fechas 59 | Key Map anidado → Indice de la fecha que seleccione el usuario 60 | Ejemplo: 61 | [doctors] 62 | Key1 63 | 0. doctor1 64 | Key2 65 | 0. fecha1 66 | 1. fecha2 67 | 2. fecha3 68 | 1. doctor2 69 | 2. doctor3 70 | */ 71 | Map> doctors = new TreeMap<>(); 72 | int auxIndex = 0; 73 | 74 | for (int i = 0; i < UIDoctorMenu.doctorsAvailableAppointments.size(); i++) { 75 | 76 | ArrayList availableAppointments = 77 | UIDoctorMenu.doctorsAvailableAppointments.get(i).getAvailableAppointments(); 78 | 79 | Map doctorAppointments = new TreeMap<>(); 80 | 81 | for (int j = 0; j < availableAppointments.size(); j++) { 82 | 83 | auxIndex++; 84 | System.out.println(auxIndex + ". " + availableAppointments.get(j).getDate()); 85 | doctorAppointments.put(Integer.valueOf(j), UIDoctorMenu.doctorsAvailableAppointments.get(i)); 86 | doctors.put(Integer.valueOf(auxIndex), doctorAppointments); 87 | 88 | } 89 | 90 | } 91 | 92 | Scanner scanner = new Scanner(System.in); 93 | int responseDateSelected = Integer.parseInt(scanner.nextLine()); 94 | 95 | } while (response != 0); 96 | 97 | } 98 | 99 | } 100 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/model/AppointmentDoctor.java: -------------------------------------------------------------------------------- 1 | package model; 2 | 3 | import java.util.Date; 4 | 5 | public 6 | class AppointmentDoctor implements ISchedulable { 7 | 8 | // Atributos 9 | private int id; 10 | private Patient patient; 11 | private Doctor doctor; 12 | private Date date; 13 | private String time; 14 | 15 | 16 | // Getters y Setters 17 | public int getId() { 18 | return id; 19 | } 20 | 21 | public void setId(int id) { 22 | this.id = id; 23 | } 24 | 25 | public Patient getPatient() { 26 | return patient; 27 | } 28 | 29 | public void setPatient(Patient patient) { 30 | this.patient = patient; 31 | } 32 | 33 | public Doctor getDoctor() { 34 | return doctor; 35 | } 36 | 37 | public void setDoctor(Doctor doctor) { 38 | this.doctor = doctor; 39 | } 40 | 41 | public Date getDate() { 42 | return date; 43 | } 44 | 45 | public void setDate(Date date) { 46 | this.date = date; 47 | } 48 | 49 | public String getTime() { 50 | return time; 51 | } 52 | 53 | public void setTime(String time) { 54 | this.time = time; 55 | } 56 | 57 | // Interface 58 | @Override 59 | public void schedule(Date date, String time) { 60 | 61 | } 62 | } 63 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/model/AppointmentNurse.java: -------------------------------------------------------------------------------- 1 | package model; 2 | 3 | import java.util.Date; 4 | 5 | public class AppointmentNurse implements ISchedulable { 6 | 7 | // Atributos 8 | private int id; 9 | private Nurse nurse; 10 | private Patient patient; 11 | private Date date; 12 | private String time; 13 | 14 | // Getters y Setters 15 | public int getId() { 16 | return id; 17 | } 18 | 19 | public void setId(int id) { 20 | this.id = id; 21 | } 22 | 23 | public Nurse getNurse() { 24 | return nurse; 25 | } 26 | 27 | public void setNurse(Nurse nurse) { 28 | this.nurse = nurse; 29 | } 30 | 31 | public Patient getPatient() { 32 | return patient; 33 | } 34 | 35 | public void setPatient(Patient patient) { 36 | this.patient = patient; 37 | } 38 | 39 | public Date getDate() { 40 | return date; 41 | } 42 | 43 | public void setDate(Date date) { 44 | this.date = date; 45 | } 46 | 47 | public String getTime() { 48 | return time; 49 | } 50 | 51 | public void setTime(String time) { 52 | this.time = time; 53 | } 54 | 55 | // Interfaz 56 | @Override 57 | public void schedule(Date date, String time) { 58 | 59 | } 60 | } 61 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/model/Doctor.java: -------------------------------------------------------------------------------- 1 | package model; 2 | 3 | import java.text.ParseException; 4 | import java.text.SimpleDateFormat; 5 | import java.util.ArrayList; 6 | import java.util.Date; 7 | 8 | public class Doctor extends User { 9 | 10 | // Atributos 11 | private String speciality; 12 | private ArrayList availableAppointments = new ArrayList<>(); 13 | 14 | // Método constructor 15 | public Doctor(String name, String email) { 16 | 17 | super(name, email); 18 | 19 | } 20 | 21 | // Métodos 22 | public void addAvailableAppointment(String date, String time) { 23 | 24 | 25 | availableAppointments.add(new AvailableAppointment(date, time)); 26 | 27 | } 28 | public ArrayList getAvailableAppointments() { 29 | 30 | return availableAppointments; 31 | 32 | } 33 | 34 | // Getters y Setters 35 | public String getSpeciality() { 36 | return speciality; 37 | } 38 | 39 | public void setSpeciality(String speciality) { 40 | this.speciality = speciality; 41 | } 42 | 43 | // Sobrescritura de métodos 44 | @Override 45 | public String toString() { 46 | 47 | return super.toString() + 48 | "\nSpeciality: " + speciality + 49 | "\nAvailable: " + availableAppointments.toString(); 50 | 51 | } 52 | 53 | @Override 54 | public void showDataUser() { 55 | 56 | System.out.println("🏥 Empleado del Hospital: Santa Clara"); 57 | System.out.println("🩺 Departamento: Oncología"); 58 | 59 | } 60 | 61 | // Static Nested Class Available Appointment 62 | public static class AvailableAppointment { 63 | 64 | // Atributos 65 | private int id; 66 | private Date date; 67 | String time; 68 | SimpleDateFormat dateFormat = new SimpleDateFormat("ss/MM/yyyy"); 69 | 70 | // Constructor 71 | public AvailableAppointment(String date, String time) { 72 | 73 | try { 74 | 75 | this.date = dateFormat.parse(date); 76 | 77 | } catch (ParseException e) { 78 | 79 | e.printStackTrace(); 80 | 81 | } 82 | this.time = time; 83 | 84 | } 85 | 86 | // Getters y Setters Static Nested Class 87 | public String getDate(String date) { 88 | return date; 89 | } 90 | 91 | public String getDate() { 92 | return dateFormat.format(date); 93 | } 94 | 95 | public void setDate(Date date) { 96 | this.date = date; 97 | } 98 | 99 | public String getTime() { 100 | return time; 101 | } 102 | 103 | public void setTime(String time) { 104 | this.time = time; 105 | } 106 | 107 | // Sobrescritura de métodos 108 | @Override 109 | public String toString() { 110 | 111 | return "AvailableAppointments: \n" + 112 | "\nDate: " + date + 113 | "\nTime: "+ time; 114 | 115 | } 116 | 117 | } 118 | 119 | } 120 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/model/ISchedulable.java: -------------------------------------------------------------------------------- 1 | package model; 2 | 3 | import java.util.Date; 4 | 5 | public interface ISchedulable { 6 | 7 | void schedule(Date date, String time); 8 | 9 | } 10 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/model/Nurse.java: -------------------------------------------------------------------------------- 1 | package model; 2 | 3 | public class Nurse extends User { 4 | 5 | // Atributos 6 | private String speciality; 7 | 8 | // Constructor 9 | public 10 | Nurse(String name, String email) { 11 | 12 | super(name, email); 13 | 14 | } 15 | 16 | // Getters y Setters 17 | public String getSpeciality() { 18 | return speciality; 19 | } 20 | 21 | public void setSpeciality(String speciality) { 22 | this.speciality = speciality; 23 | } 24 | 25 | // Sobrescritura de métodos 26 | @Override 27 | public void showDataUser() { 28 | 29 | System.out.println("🏥 Empleado del Hospital: Santa Clara"); 30 | System.out.println("💉 Departamentos: Pediatría, Oncología"); 31 | System.out.println("📄 Historial completo desde nacimiento"); 32 | 33 | } 34 | 35 | } 36 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/model/Patient.java: -------------------------------------------------------------------------------- 1 | package model; 2 | 3 | public class Patient extends User { 4 | 5 | // Atributos 6 | private String birthday; 7 | private double weight; 8 | private double height; 9 | private String blood; 10 | 11 | // Constructor 12 | public Patient(String name, String email) { 13 | 14 | super(name, email); 15 | 16 | } 17 | 18 | // Getters y Setters 19 | public String getWeight() { return this.weight + " Kg"; } 20 | 21 | public void setWeight(double weight) { 22 | this.weight = weight; 23 | } 24 | 25 | public String getHeight() { 26 | return height + " Mts"; 27 | } 28 | 29 | public void setHeight(double height) { 30 | this.height = height; 31 | } 32 | 33 | public String getBirthday() { 34 | return birthday; 35 | } 36 | 37 | public void setBirthday(String birthday) { 38 | this.birthday = birthday; 39 | } 40 | 41 | public String getBlood() { 42 | return blood; 43 | } 44 | 45 | public void setBlood(String blood) { 46 | this.blood = blood; 47 | } 48 | 49 | // Sobrescritura de métodos 50 | @Override 51 | public String toString() { 52 | 53 | return super.toString() + 54 | "Age='" + birthday + '\'' + 55 | ", weight=" + getWeight() + 56 | ", height=" + getHeight() + 57 | ", blood='" + blood + '\'' + 58 | '}'; 59 | 60 | } 61 | 62 | @Override 63 | public void showDataUser() { 64 | 65 | System.out.println("😷 Paciente: " + getName()); 66 | System.out.println("📄 Historial completo desde nacimiento"); 67 | 68 | } 69 | 70 | } 71 | -------------------------------------------------------------------------------- /MyMedicalAppointments/src/model/User.java: -------------------------------------------------------------------------------- 1 | package model; 2 | 3 | public abstract class User { 4 | 5 | // Atributos 6 | private int id; 7 | private String name; 8 | private String email; 9 | private String address; 10 | private String phoneNumber; 11 | 12 | // Constructor 13 | public User(String name, String email) { 14 | this.name = name; 15 | this.email = email; 16 | } 17 | 18 | // Métodos 19 | public abstract void showDataUser(); 20 | 21 | // Getters y Setters 22 | public int getId() { 23 | return id; 24 | } 25 | 26 | public void setId(int id) { 27 | this.id = id; 28 | } 29 | 30 | public String getName() { 31 | return name; 32 | } 33 | 34 | public void setName(String name) { 35 | this.name = name; 36 | } 37 | 38 | public String getEmail() { 39 | return email; 40 | } 41 | 42 | public void setEmail(String email) { 43 | this.email = email; 44 | } 45 | 46 | public String getAddress() { 47 | return address; 48 | } 49 | 50 | public void setAddress(String address) { 51 | this.address = address; 52 | } 53 | 54 | public String getPhoneNumber() { 55 | return phoneNumber; 56 | } 57 | 58 | public void setPhoneNumber(String phoneNumber) { 59 | 60 | if (phoneNumber.length() > 8) { 61 | 62 | System.err.println("⚠ El número de teléfono debe tener máximo 8 dígitos"); 63 | 64 | } else if (phoneNumber.length() == 8) { 65 | 66 | this.phoneNumber = phoneNumber; 67 | 68 | } 69 | 70 | } 71 | 72 | // Sobrescritura de métodos 73 | @Override 74 | public String toString() { 75 | 76 | return "model.User{" + 77 | "name='" + name + '\'' + 78 | ", email='" + email + '\'' + 79 | ", address='" + address + '\'' + 80 | ", phoneNumber='" + phoneNumber + '\'' + 81 | '}'; 82 | 83 | } 84 | 85 | } 86 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Curso de Java SE Orientado a Objetos 2 | 3 | ## 📚 Módulo 1. Entender la Programación orientada a objetos 4 | 5 | - ### Programación orientada a objetos en Java 6 | 7 | La POO surge a partir de la necesidad de resolver problemas con código, la POO permite resolver dichos problemas de una forma concisa, escalable y fácil de mantener. 8 | 9 | #### Orientación a Objetos 10 | 11 | Es un paradigma de programación. Parte de observar los problemas en forma de objetos. 12 | 13 | **Paradigma: **es una teoría que suministra la base y modelo para resolver problemas. 14 | 15 | El paradigma de Programación Orientada a Objetos se compone de 4 elementos principales: 16 | 17 | - **Clases** 18 | - **Propiedades** 19 | - **Métodos** 20 | - **Objetos** 21 | 22 | Además la POO tiene los siguientes pilares o conceptos fundamentales: 23 | 24 | - **Encapsulamiento** 25 | - **Abstracción** 26 | - **Herencia** 27 | - **Polimorfismo** 28 | 29 | #### UML (Unified Modeling Language) 30 | 31 | En Español *Lenguaje de Modelado Unificado*, permite graficar los atributos, métodos, herencia, etc de las diferentes Clases que componen un proyecto. 32 | 33 | - ### ¿Qué es un Objeto? 34 | 35 | Son todas aquellas cosas que tienen propiedades y comportamientos; los objetos pueden ser físicos o conceptuales. Un objeto *físico* puede ser por ejemplo un usuario, y un ejemplo de objeto *conceptual* puede ser una sesión. 36 | 37 | #### Propiedades o atributos 38 | 39 | Son propiedades que pertenecen a un objeto. Siempre serán sustantivos. **Por ejemplo:** nombre, tamaño, forma, estado. 40 | 41 | #### Comportamientos 42 | 43 | También conocidos como **métodos**. Son las operaciones que realiza el objeto. Pueden ser verbos o sustantivo y verbo. **Por ejemplo:** ``login()``, ``logout()``, ``makeReport()``. 44 | 45 | - ### Abstracción: ¿Qué es una Clase? 46 | 47 | Son el modelo sobre el cuál se construirá un objeto. Se puede decir que de cierta forma una Clase es un especie de molde que se usa para construir Objetos. 48 | 49 | #### Abstracción 50 | 51 | Es un concepto en el que se analiza un Objeto para extraer sus composición y en base a eso crear una Clase. En resumidas cuentas, la abstracción es ese proceso de analizar los objetos para identificar sus atributos y métodos comunes para en base a eso crear un molde llamando Clase. 52 | 53 | > "Cuando se detectan características y comportamientos iguales se debe realizar una abstracción." 54 | 55 | El flujo de trabajo con POO es el siguiente: 56 | 57 | 1. Analizar el problema y extraer los Objetos que lo componen. 58 | 2. Abstraer dichos Objetos en Clases. 59 | 3. Gráficar las Clases en UML 60 | 4. Implementar con código el diagrama UML. 61 | 62 | #### Graficar Clases en UML 63 | 64 | ![Clases en UML](https://i.imgur.com/Li7Ndkf.png) 65 | 66 | - ### Modularidad 67 | 68 | Es un concepto proveniente del diseño industrial y la arquitectura. Consiste en dividir un sistema en varios módulos independientes que unidos conforman todo el sistema completo. 69 | 70 | **Ventajas de la modularidad:** 71 | 72 | - Reutilizar código. 73 | - Se evitan colapsos. 74 | - Código más mantenible. 75 | - Mejor legibilidad en el código 76 | - Rápida resolución de problemas 77 | 78 | Mientras en las programación estructurada se tiene un sólo archivo muy grande en el que esta toda la lógica del sistema y en el que un error puede detener la ejecución de todo el programa, en la programación orientada a objetos las diferentes funciones de un sistema se dividen en módulos independientes, por lo que a la hora de solucionar bugs sólo hay que ubicar el módulo que esta fallando y repararlo sin tener que afectar al resto del código; y si se quieren añadir más funcionalidades al proyecto solo hay que crear nuevos módulos e integrarlos dentro del sistema. 79 | 80 | #### Las Clases dentro de la modularidad 81 | 82 | Las Clases juegan un papel fundamental dentro de la modularidad, pues permiten dividir el software en diferentes partes o módulos/Clases y a su vez separar dichas Clases en archivos diferentes. 83 | 84 | ## 📚 Módulo 2. Definir Clases y sus componentes 85 | 86 | - ### Creando nuestra primera Clase 87 | 88 | #### Crear una Clase en Java 89 | 90 | ````java 91 | public class Doctor { // Doctor → Nombre de la Clase 92 | // Atributos 93 | int id; 94 | String name; 95 | String speciality; 96 | 97 | // Métodos 98 | public void showName() { 99 | System.out.println(name); 100 | } 101 | } 102 | ```` 103 | 104 | #### Instanciar un Objeto en Java 105 | 106 | ``Doctor`` → Tipo de Objeto ``myDoctor`` → Nombre de la instancia del Objeto ``new Doctor();`` → Crea la instancia del Objeto 107 | 108 | ````java 109 | Doctor myDoctor = new Doctor(); 110 | myDoctor.name = "Alejandro López"; // Asignar un valor a un atributo 111 | myDoctor.showname(); // Llamar a un método 112 | ```` 113 | 114 | - ### Método constructor 115 | 116 | ````java 117 | Doctor myDoctor = new Doctor(); // Doctor() → Método constructor 118 | ```` 119 | 120 | El método constructor se llama igual que la Clase a la que pertenece. Cuando no se define explícitamente, el compilador de Java crea internamente uno por default. 121 | 122 | El método constructor es el que se encarga de crear nuevas instancias de una Clase. Se invoca con la palabra reservada ``new``. Puede tener cero o más parámetros y **No retorna un valor**. 123 | 124 | - ### Static: Variables y Métodos Estáticos 125 | 126 | Hay otra forma de llamar a Clases y a sus respectivos métodos/atributos sin tener que crear una instancia con ``new``. Ese es caso de las **Clases estáticas** como ``Math``. 127 | 128 | ````java 129 | Math.random(); 130 | Math.PI; 131 | ```` 132 | 133 | #### Métodos static 134 | 135 | Se definen con la palabra reservada ``static``. Los métodos static pueden ser accedidos usando **el nombre de la Clase**, **la notación de punto** y el nombre del método. 136 | 137 | **Ejemplo:** 138 | 139 | ````java 140 | public class Calculadora() { 141 | public static final double PI = 3.1415926; 142 | public static int valor = 0; 143 | public static int suma(int a, inst b) { 144 | return a + b; 145 | } 146 | } 147 | 148 | // Llamar al método 149 | Calculadora.suma(5, 2); 150 | // Llamar a los atributos 151 | Calculadora.PI; 152 | Calculadora.valor; 153 | ```` 154 | 155 | Los atributos/métodos estáticos tienen un scope global, por lo que pueden ser accedidos y modificados por cualquier Clase dentro del programa. 156 | 157 | #### Miembros static 158 | 159 | Son otra forma de llamar a atributos/métodos estáticos. 160 | 161 | ````java 162 | import static com.blooping.operaciones.Calculadora.*; 163 | import static java.lang.Math.*; 164 | 165 | // Llamar a estos atributos 166 | 167 | public class Principal { 168 | public static void main(String[] args) { 169 | System.out.println(suma(3, 5)); 170 | System.out.println(PI); 171 | } 172 | } 173 | ```` 174 | 175 | 176 | 177 | - ### Creando elementos estáticos 178 | 179 | Los métodos estáticos son muy útiles cuando se quiere llamar a un método pero sin tener que instanciar una Clase, pues hace eso no quedaría bien a nivel de lógica, pues se instanciaría una Clase que sólo muestra elementos en pantalla pero que no tiene atributos ni nada más, lo cuál sería totalmente incensario. 180 | 181 | En esos casos se puede crear un método statico y así mantener el código lo más limpio posible. Para empezar se puede crear un *package* y en su interior crear la Clase que muestra el menú. 182 | 183 | ````java 184 | package UI; // Relaciona la Clase con el package UI 185 | 186 | import java.util.Scanner; // Importa Scanner una Clase que permite ingresar datos desde la terminal 187 | 188 | public class UIMenu { 189 | // Métodos 190 | // Mostrar menú 191 | public static void showMenu() { 192 | // Código qu emuestra el ménú 193 | } 194 | } 195 | ```` 196 | 197 | Luego para usar ese método hay que importar el método estático para poder usarlo. 198 | 199 | ````java 200 | import static UI.UIMenu.*; 201 | 202 | public class Main { 203 | 204 | public static void main(String[] args) { 205 | // Mostar menú de la UI 206 | showMenu(); 207 | } 208 | } 209 | ```` 210 | 211 | **Nota:** sobre el uso de los wildcards(*) al hacer un import lo ideal es importar el método especifico que se requiera. No es una buena buena práctica importar todo el módulo usando * pues esto al trabajar con módulos grandes esto ocupa mucho espacio en la memoria y hace más lento el proceso de indexación en el IDE a la hora de buscar el método. 212 | 213 | - ### Final: Variables Constantes 214 | 215 | #### Declarar una constante en Java 216 | 217 | ````java 218 | public static final double PI = 3.1415926; 219 | ```` 220 | 221 | - ### Variable vs. Objeto: Un vistazo a la memoria 222 | 223 | Las variables de tipo primitivo en Java y los objetos se almacenan de forma diferente en la memoria. 224 | 225 | #### Stack 226 | 227 | Es una memoria con una estructura de "pila". En el caso de las **variables primitivos** en el stack se almacena directamente su valor. 228 | 229 | Por el contrario en el caso de los **objetos** en el stack no se almacena el objeto como tal, sino una referencia al lugar en memoria donde se almacena el objeto (memoria heap). 230 | 231 | #### Heap 232 | 233 | Es una memoria con una estructura de "árbol". Aquí los datos pueden crecer o decrecer. En esta memoria se almacenan los objetos como tal, con sus respectivos atributos. 234 | 235 | ![Stack y Heap](https://i.imgur.com/Whf16AX.png) 236 | 237 | Por esta razón, al hacer una reasignación a una variable, cuando esta es primitiva se reasigna el valor de la variable, pero en el caso de los objetos lo que se reasigna es la dirección en memoria. 238 | 239 | Por ejemplo si se tiene: 240 | 241 | ````java 242 | int a = 1; 243 | int b = 2; 244 | b = a; // b pasará a valer 0 245 | ```` 246 | 247 | Pero cuando se trata de objetos: 248 | 249 | ````java 250 | Doctor doctor1 = new Doctor("Andrés"); 251 | Doctor doctor2 = new Doctor("Felipe"); 252 | 253 | doctor1.showName(); 254 | doctor2.showName(); 255 | 256 | /* 257 | RESULTADO: 258 | El nombre del Doctor asignado es Andrés 259 | El nombre del Doctor asignado es Felipe 260 | */ 261 | 262 | System.out.println("\n"); 263 | 264 | doctor2 = doctor1; 265 | doctor1.showName(); 266 | doctor2.showName(); 267 | 268 | /* 269 | RESULTADO: 270 | El nombre del Doctor asignado es Andrés 271 | El nombre del Doctor asignado es Andrés 272 | */ 273 | 274 | ```` 275 | 276 | Esto se debe a que se reasigna la dirección en memoria del objeto. Ahora ``doctor2`` apunta al lugar en memoria donde esta guardado ``doctor1`` de hecho cualquier cambio que se realice en ``doctor1`` se verá en ``doctor2``. 277 | 278 | 279 | 280 | - ### Sobrecarga de métodos y constructores 281 | 282 | Consiste en hacer que dos o más métodos tengan el mismo nombre pero con argumentos diferentes. 283 | 284 | #### Ejemplo de sobrecarga 285 | 286 | ````java 287 | public class Calculadora { 288 | public int suma (int a, int b) { 289 | return a + b; 290 | } 291 | public float suma (float a, float b) { 292 | return a + b; 293 | } 294 | public float suma (int a, float b) { 295 | return a + b; 296 | } 297 | } 298 | ```` 299 | 300 | No sólo pueden variar el tipo de dato de los argumentos como en el ejemplo anterior, también puede variar la cantidad de argumentos. 301 | 302 | La sobrecarga también se puede aplicar a los *métodos constructores*. 303 | 304 | ````java 305 | Doctor() { 306 | System.out.println("Construyendo el Objeto Doctor"); 307 | } 308 | 309 | Doctor(String name, String speciality) { 310 | id++; 311 | this.name = name; 312 | this.speciality = speciality; 313 | } 314 | ```` 315 | 316 | - ### Encapsulamiento: Modificadores de acceso 317 | 318 | Permite restringir el nivel de acceso a los datos del programa y validar dichos datos. Esto se hace mediante modificadores de acceso. En Java existen los siguientes: 319 | 320 | ![Modificadores de acceso en Java](https://i.imgur.com/4pYTpU7.png) 321 | 322 | - ### Getters y Setters 323 | 324 | Permiten leer y escribir específicamente los valores de las variables miembro. 325 | 326 | **Gettter:** obtiene el valor de la variable. 327 | 328 | **Setter: ** asigna/modifica el valor de la variable. 329 | 330 | En IntelliJ Idea se pueden generar los getters y setters de forma más automatizada usando: *Alt + Insert* → *Getter and Setter* 331 | 332 | - ### Variable vs. Objeto 333 | 334 | Las **variables** son entidades elementales (muy sencillas). Sólo pueden almacenar un valor que puede ser: 335 | 336 | - Un número. 337 | - Un caractér. 338 | - Un valor verdadero o falso. 339 | 340 | Los **objetos** por el contrario, son entidades más complejas que pueden estar formadas por la agrupación de muchas variables y métodos. 341 | 342 | Los **arreglos** son agrupaciones de una cantidad fija de elementos de un mismo tipo de dato. Pueden almacenar tipos de datos primitivos y objetos. Los arreglos además, son objetos, con la diferencia de que sólo almacenan valores de un sólo tipo de datos. 343 | 344 | #### Clases Wrapper / Objeto primitivo 345 | 346 | Son clases que por decirlo de cierta forma, "envuelven" a un primitivo para dotarlo de características de un Objeto, para por ejemplo tener métodos para manipular a ese tipo primitivo. En Java existen las siguientes Clases Wrapper: 347 | 348 | - Byte 349 | - Short 350 | - Integer 351 | - Long 352 | - Float 353 | - Double 354 | - Character 355 | - Boolean 356 | - String 357 | 358 | #### Parseo 359 | 360 | Es cuando se cambia el tipo de dato de un objeto. 361 | 362 | #### Casting 363 | 364 | Cuando se cambia el tipo de dato entre variables. 365 | 366 | 367 | 368 | - ### Clases Anidadas 369 | 370 | Son una Clase que vive dentro de otra. Son Clases Helper que están agrupadas dentro de la lógica, además también pueden tener encapsulación. 371 | 372 | ````java 373 | class ClaseExterior { 374 | class ClaseAnidada { 375 | ... 376 | } 377 | } 378 | ```` 379 | 380 | #### Tipos de Clases anidadas 381 | 382 | - ##### Clases Internas 383 | 384 | - ###### Clases Locales a un método 385 | 386 | Clases declaradas dentro de un método. No es muy común encontrarse con este tipo 387 | 388 | - ###### Clases Internas anónimas 389 | 390 | Están relacionadas con la programación funcional y las funciones lambdas 391 | 392 | - ##### Clases estáticas anidadas 393 | 394 | Son Clases anidadas pero de tipo estático. 395 | 396 | ````java 397 | class ClaseExterior { 398 | static class ClaseEstaticaAnidada { 399 | ... 400 | } 401 | } 402 | 403 | ```` 404 | 405 | En las Clases estáticas anidadas no es necesario crear instancias para poder llamarlas. Se llaman usando con ``ClaseExterior.ClaseEstaticaAnidada``. Para poder llamar a un método de un Clase estática anidada, dicho método también debe ser estático. 406 | **Ejemplo de Clase estática:** 407 | 408 | ````java 409 | public class Enclosing { 410 | private static int x = 1; 411 | 412 | public static class StaticNested { 413 | private void run() { 414 | // Implementación 415 | } 416 | } 417 | } 418 | ```` 419 | 420 | Para llamar a una Clases estática anidada sólo hay que instanciar a la Clase exterior: 421 | 422 | ````java 423 | public class Main { 424 | public static void main(String[] args) { 425 | Enclosing.StaticNested nested = new Enclosing.StaticNested(); 426 | 427 | nested.run(); 428 | } 429 | } 430 | ```` 431 | 432 | #### Colecciones 433 | 434 | Una colección es una especie de array de tamaño dinámico que almacena un conjunto de de Objetos (como las Clases Wrapper). Esta dentro del paquete ``java.util``. 435 | 436 | ````java 437 | ArrayList availableAppointments = new ArrayList<>(); // → Tipo de objeto que va a almacenar el ArrayList. availableAppointments → Nombre del ArrayList. new ArrayList<>(); → Constructor del ArrayList 438 | 439 | availableAppointments.add(new AvailableAppointment(date, time)); // Añadir Objetos al ArrayList 440 | ```` 441 | 442 | **Nota:** si se tiene un atributo cuya estructura de dato es muy compleja, puede ser recomendable crear una Clase anidada. 443 | 444 | #### Métodos de un ArrayList 445 | 446 | Los siguientes son los métodos más comunes. 447 | 448 | ````java 449 | nombreArrayList.add("Elementos"); 450 | nombreArrayList.size(); // Retorna el número de elementos de un ArrayList 451 | nombreArrayList.get(2); // Retorna el elemento que esta en determinada posición de un ArrayList 452 | nombreArrayList.set(index, element) // Sustituye un elemeto por otro. index → Indice del elemento a sustituir. element → Elemento a insertar. 453 | nombreArrayList.remove(5) // Quitar un elemento 454 | ```` 455 | 456 | 457 | 458 | - ### Clases Internas y Locales a un método 459 | 460 | - #### Clases Internas 461 | 462 | También llamadas *Clases anidadas no estáticas*. Al no ser una Clase estática, es necesario instanciarla. **Ejemplo:** 463 | 464 | ````java 465 | // Declaración de la Clase Interna 466 | public class Outer { 467 | public class Inner { 468 | 469 | } 470 | } 471 | ```` 472 | 473 | Llamar a la Clase: 474 | 475 | ````java 476 | public class Main { 477 | public static void main(String[] args) { 478 | Outer outer = new Outer(); 479 | Outer.Inner inner = outer.new Inner(); 480 | } 481 | } 482 | ```` 483 | 484 | Para declarar este tipo de Clases hay que instanciar 2 objetos, lo que consume más espacio en memoria, por lo tanto, hay que tener cuidado al usar este tipo de Clases, de hecho este tipo de Clases no son muy comunes. 485 | 486 | - #### Clases Locales a un Método 487 | 488 | Este tipo de Clases tienen un scope definido para el método al que pertenecen, en el ejemplo de abajo ese método sería el primer ``void run()``. 489 | 490 | Si se quiere tener acceso al método ``run`` de la Clase Local, hay que crear una instancia de dicha Clase. 491 | 492 | Declarar una Clase Local a un método 493 | 494 | ````java 495 | public class Enclosing { 496 | void run() { 497 | class Local { 498 | void run() { 499 | ... 500 | } 501 | } 502 | Local local = new Local(); 503 | local.run(); 504 | } 505 | } 506 | ```` 507 | 508 | Instanciar una Clase Local a un método 509 | 510 | ````java 511 | public class Main { 512 | public static void main(String[] args) { 513 | Enclosing enclosing = new Enclosing(); 514 | enclosing.run(); 515 | } 516 | } 517 | ```` 518 | 519 | Este tipo de Clases también consumen más espacio en memoria. Lo recomendable en estos casos es usar Clases estáticas anidadas para hacer un mejor uso de la memoria. 520 | 521 | - ### Enumerations 522 | 523 | Sirven para declarar una colección de constantes. Son muy útiles para representar un conjunto de cosas que no cambian, como por ejemplo los días de la semana. 524 | 525 | Para crear un Enumeration se usa la palabra reservada ``enum``. 526 | 527 | ````java 528 | public enum Day { 529 | SUNDAY, MONDAY, TUESDAY, WEDNESDAY, 530 | THURSDAY, FRIDAY, SATURDAY 531 | } 532 | ```` 533 | 534 | Se pueden crear referencias de enumerations de la siguiente forma: 535 | 536 | ````java 537 | Day day; 538 | switch (day) { 539 | case MONDAY: 540 | System.out.println(“Mondays are good.”); 541 | break; 542 | case FRIDAY: 543 | System.out.println(“Fridays are nice”); 544 | break; 545 | case SATURDAY: case: SUNDAY: 546 | System.out.println(“Weekends are the best”); 547 | break; 548 | default: 549 | System.out.println(“Midweek are so-so”); 550 | break; 551 | } 552 | ```` 553 | 554 | Se puede llamar un valor del enumeration así: 555 | 556 | ````java 557 | Day.MONDAY; 558 | Day.FRIDAY; 559 | Day.SATURDAY 560 | ```` 561 | 562 | Los enumerations pueden tener atributos, métodos y constructores, como se muestra en el siguiente ejemplo: 563 | 564 | ````java 565 | public enum Day { 566 | MONDAY("Lunes"); 567 | TUESDAY("Jueves"); 568 | FRIDAY("Viernes"); 569 | SATURDAY("Sábado"); 570 | SUNDAY("Domingo"); 571 | 572 | private String spanish; 573 | private Day(String s) { 574 | spanish = s; 575 | } 576 | 577 | private String getSpanish() { 578 | return spanish; 579 | } 580 | } 581 | ```` 582 | 583 | Se pueden usar así: 584 | 585 | ````java 586 | System.out.println(Day.MONDAY); // Imprime MONDAY 587 | ```` 588 | 589 | ````java 590 | System.out.println(Day.MONDAY.getSpanish()); // Imprime Lunes 591 | ```` 592 | 593 | #### Diferencias entre Enumerations y Clases 594 | 595 | Un ``enum`` puede, al igual que una clase, tener atributos y métodos. La única diferencia es que las constantes del ``enum`` son ``public``, ``static`` y ``final`` (inmutables - no pueden ser anuladas). 596 | 597 | Un ``enum`` no puede utilizarse para crear objetos, y no puede extender otras clases (pero puede implementar interfaces). 598 |

¿Por qué y cuándo usar los enum?

599 | 600 | Los enumerations son útiles cuando se tienen valores que se sabe que no van a cambiar, como los días del mes, los días, los colores, una baraja de cartas, etc. 601 | 602 | 603 | ## 📚 Módulo 3. Reutilizar Código 604 | 605 | - ### ¿Qué es la Herencia? Don\'t repeat Yourself 606 | 607 | La **Herencia** permite crear nuevas Clases a partir de otras. 608 | 609 | En la herencia se establece una relación **padre e hijo**. A la clase padre se le conoce como **súper clase** y a sus clases hijas se les llama **subclases**. 610 | 611 | Si una clase es una especie de molde para crear objetos, en la herencia se hace algo así como "crear un molde para hacer moldes". 612 | 613 | ![Herencia](https://i.imgur.com/PKcznhI.png) 614 | 615 | > "Cuando se detectan características y comportamientos iguales se debe realizar una abstracción." 616 | 617 | #### DRY: Don\'t repeat Yourself 618 | 619 | - Promueve la reducción de la duplicación en programación. 620 | - Las piezas de información **nunca deben duplicarse**. 621 | - **Reduce la dificultad** en los cambios y evolución. 622 | 623 | - ### Super y this 624 | 625 | La herencia se define con la siguiente sintaxis: 626 | 627 | ````java 628 | public class Doctor extends User { // User → Súper Clase 629 | 630 | } 631 | ```` 632 | 633 | - #### Super 634 | 635 | Indica que una variable o un método es de la Clase Padre (superclase). 636 | 637 | - #### this 638 | 639 | Permite especificar que la variable que esta señalando (``this.nombreVariable``) es de la misma Clase en que se usa. 640 | 641 | 642 | 643 | - ### Polimorfismo: Sobreescritura de Métodos 644 | 645 | En Java hay una Clase de la que heredan todas las Clases, esa es la Clase Object. Esto permite usar una serie de métodos y atributos que proporciona la Clase Object. 646 | 647 | **Nota: ** en Java no se permite la herencia múltiple de Clases. Las Clases hijas sólo pueden tener una Clase padre. 648 | 649 | #### Sobrescritura 650 | 651 | Cuando una Clase hereda de otra y **en la Clase hija se redefine un método** con una implementación distinta a la de la Clase padre. 652 | 653 | **Nota:** los métodos marcados como ``final`` o ``static`` no se pueden sobrescribir. 654 | 655 | #### Sobrescritura de Constructores 656 | 657 | Un constructor en una subclase usando los miembros heredados de la superclase **con argumentos diferentes.** 658 | 659 | **Ejemplo:** sobrescribir el método ``toString()``. 660 | 661 | ````java 662 | @Override // Indica que el método qu esta a continuación no es propio de la Clase y va a ser sobrescrito. 663 | public String toString() { 664 | return "User{" + 665 | "id=" + id + 666 | ", name='" + name + '\'' + 667 | ", email='" + email + '\'' + 668 | ", address='" + address + '\'' + 669 | ", phoneNumber='" + phoneNumber + '\'' + 670 | '}'; 671 | } 672 | ```` 673 | 674 | Usar el método con la sobrescritura: 675 | 676 | ````java 677 | System.out.println(myDoctor); 678 | /* 679 | Al imprimir cualquier objeto en la consola con System.out.println(object), en realidad, se esta ejecutando el método .toString() de dicho objeto, por lo que si se sobrescribe este método en una Clase, el resultado en la consola también cambiará automáticamente. 680 | */ 681 | ```` 682 | 683 | Se puede sobrescribir un mismo método en diferentes Clases y en cada una darle un comportamiento diferente. Por ejemplo después de sobrescribir el método ``toString()`` en el ejemplo anterior, se podría volver a sobrescribir dicho método para que muestre datos adicionales: 684 | 685 | ````java 686 | @Override 687 | public String toString() { 688 | return super.toString() + // return super.toString() → Retorna el método sobrescrito en la superclase para poder concaternarle los datos adicionales. 689 | "Age='" + birthday + '\'' + 690 | ", weight=" + getWeight() + 691 | ", height=" + getHeight() + 692 | ", blood='" + blood + '\'' + 693 | '}'; 694 | } 695 | ```` 696 | 697 | - ### Polimorfismo: Sobreescribiendo el método toString 698 | 699 | El **polimorfismo** es la posibilidad de sobrescribir un método con **comportamientos diferentes.** 700 | 701 | - ### Interfaces 702 | 703 | Es un tipo de referencia similar a una Clase que podría contener sólo constantes y definiciones de métodos. Una interfaz puede contener por ejemplo métodos que se repiten en varias Clases que no pertenecen a la misma familia. Esa es su principal diferencia con respecto a la herencia entre Clases pues en esta las Clases que tienen un método en el que se aplican polimorfismo pertenecen a la misma familia y tienen a una superclase en común; por el contrario en las *interfaces* se pueden definir diferentes comportamientos para Clases que no tienen ninguna relación entre si y que pertenecen a familias diferentes. 704 | 705 | En las interfaces se establece la forma de una Clase (nombres de métodos, listas de argumentos y tipos de retorno) pero **no bloques de código**, por ejemplo en una interfaz sólo se pondría la redacción de un método pero no su implementación pues esta será radicalmente diferente para cada Clase. 706 | 707 | #### Declarar una interfaz en Java 708 | 709 | ````java 710 | // Crear una interfaz 711 | public IScheduable { 712 | schedule(Date date, String Time); 713 | } 714 | 715 | // Implemtar una interfaz en una Clase 716 | public class AppointmentDoctor implements IScheduable { 717 | ... 718 | } 719 | ```` 720 | 721 | 722 | 723 | **Nota:** es muy común que los nombres de las interfaces terminen en *"able"* (**ejemplos:** ``rundable``, ``printable``, ``readable``), esto se debe a que las interfaces se enfocan en las actividades que son redundantes en el código. También es común encontrar que el nombre de la interfaz comience con una "I". 724 | 725 | - ### Creando una interfaz para definir si una fecha es agendable 726 | 727 | #### Composición de interfaces en Clases 728 | 729 | Es el proceso de añadirle comportamientos a una Clase mediante interfaces. Consiste en abstraer todos los métodos de una Clase y modularizarlos en una interfaz para poder reutilizarlos todas las veces que sean necesarias. Muchos desarrolladores hoy en día aconsejan usar la composición en lugar de la herencia pues en esta última la reutilización de código es lineal mientras que la composición se puede efectuar a cualquier Clase. 730 | 731 | #### POJOS (Plain Old Java Object) 732 | 733 | Es el nombre con el que se conocen las Clases con getters y setters. 734 | 735 | **Nota:** una de las peculiaridades de las interfaces es que se pueden implementar múltiples Interfaces a una Clase. 736 | 737 | ````java 738 | public class AppointmentNurse implements ISchedulable, Runable { 739 | ... 740 | } 741 | ```` 742 | 743 | 744 | 745 | - ### Collections 746 | 747 | Son un tipo de interfaz en Java que permite trabajar con colecciones de datos. Los Colletions sólo trabajan con Objetos, por lo que para trabajar primitivos con Colletions es necesario recurrir a las Clases Wrapper. 748 | 749 | A diferencia de los Arrays que tienen un tamaño fijo, los Collections tienen un tamaño dinámico. 750 | 751 | ![Estructura de un Collection](https://i.imgur.com/Nlpb8SH.png) 752 | 753 | El elemento más alto en la jerarquía es la interfaz **Collection**, la cuál tiene una series de métodos "básicos" donde su comportamiento será definido a medida que se vaya implementando a más elementos. De **Collection** se desprenden 2 interfaces principales **Set** y **List**. 754 | 755 | #### Set 756 | 757 | Caracteristicas: 758 | 759 | - Almacena objetos únicos, no repetidos. 760 | - La mayoría de las veces los objetos se almacenarán en desorden. 761 | - No hay índice. 762 | 763 | De Set a su vez se desprenden la Clase **HashSet**, la Interfaz **SortedSet** y a su vez de esta última se desprende la Clase **TreeSet**. 764 | 765 | - ##### HashSet 766 | 767 | Los elementos se guardan en **desorden** y gracias al mecanismo llamado hashing (obtiene un identificador del objeto) **permite almacenar objetos únicos.** 768 | 769 | - ##### TreeSet 770 | 771 | Almacena **objetos únicos**, y gracias a su estructura de árbol el **acceso es sumamente rápido**. 772 | 773 | 774 | 775 | #### List 776 | 777 | Caracteristicas: 778 | 779 | - Puede almacenar objetos repetidos. 780 | - Los objetos se almacenan en orden secuencial. 781 | - Tenemos acceso al índice. 782 | 783 | De List se desprenden la Clase **ArrayList**, la Clase **Vector** y la Clase **LinkedList**. 784 | 785 | - ##### ArrayList 786 | 787 | Puede tener duplicados, no está sincronizada por lo tanto es más rápida. 788 | 789 | - ##### Vector 790 | 791 | Es sincronizada, los datos están más seguros pero es más lento. 792 | 793 | - ##### LinkedList 794 | 795 | Puede contener elementos duplicados, no está sincronizada (es más rápida) al ser una estructura de datos doblemente ligada podemos añadir datos por encima de la pila o por debajo. 796 | 797 | ![Explicación gráfica de una estructura de datos doblemente ligada](https://i.imgur.com/NAa7Qmn.png) 798 | 799 | *↑ Explicación gráfica de una estructura de datos doblemente ligada* 800 | 801 | 802 | 803 | #### Map 804 | 805 | Tiene las siguientes implementaciones: 806 | 807 | - **HashTable** 808 | - **LinkedHashMap** 809 | - **HashMap** 810 | - **SortedMap** → **TreeMap** 811 | 812 | ![Estructura de un Map](https://i.imgur.com/iduGkKB.png) 813 | 814 | La interfaz **Map** no hereda de la interfaz Collection porque representa una estructura de datos de Mapeo y no de colección simple de objetos. Esta estructura es más compleja, pues cada elemento deberá venir en pareja con otro dato que funcionará como la llave del elemento. 815 | 816 | - ##### Declarar un Map 817 | 818 | ````java 819 | Map map = new HashMap(); 820 | Map treeMap = new TreeMap(); 821 | Map linkedHashMap = new LinkedHashMap(); 822 | ```` 823 | 824 | Sólo se puede crear un Map con las implementaciones **HashMap**, **TreeMap** y **LinkedHashMap** dejando fuera *HashTable* y *SortedMap*. *SortedMap* estará fuera pues es una interfaz y *HashTable* ha quedado deprecada pues tiene métodos redundantes en otras clases. 825 | 826 | - ##### Implenetaciones de Map 827 | 828 | - ###### HashMap 829 | 830 | Los elementos no se ordenan. No aceptan claves duplicadas ni valores nulos. 831 | 832 | - ###### LinkedHashMap 833 | 834 | Ordena los elementos conforme se van insertando; provocando que las búsquedas sean más lentas que las demás clases. 835 | 836 | - ###### TreeMap 837 | 838 | El Mapa lo ordena de forma “natural”. Por ejemplo, si la clave son valores enteros (como luego veremos), los ordena de menos a mayor. 839 | 840 | - ##### Iterar las diferentes implementaciones de Map 841 | 842 | Para iterar las diferentes implementaciones de Map es necesario utilizar la interface **Iterator** y usar un bucle while para recorrer el Map. 843 | 844 | - ###### Para HashMap 845 | 846 | ````java 847 | // Imprimir el Map con un Iterador 848 | Iterator it = map.keySet().iterator(); 849 | while(it.hasNext()){ 850 | Integer key = it.next(); 851 | System.out.println("Clave: " + key + " -> Valor: " + map.get(key)); 852 | } 853 | ```` 854 | 855 | - ###### Para LinkedHashMap 856 | 857 | ````java 858 | // Imprimir el Map con un Iterador 859 | Iterator it = linkedHashMap.keySet().iterator(); 860 | while(it.hasNext()){ 861 | Integer key = it.next(); 862 | System.out.println("Clave: " + key + " -> Valor: " + linkedHashMap.get(key)); 863 | } 864 | ```` 865 | 866 | - ###### Para TreeMap 867 | 868 | ````java 869 | // Imprimir el Map con un Iterador 870 | Iterator it = treeMap.keySet().iterator(); 871 | while(it.hasNext()){ 872 | Integer key = it.next(); 873 | System.out.println("Clave: " + key + " -> Valor: " + treeMap.get(key)); 874 | } 875 | ```` 876 | 877 | - ### ¿Qúe es un Deque? 878 | 879 | Un **deque** (usualmente pronunciado como *deck*) es una interfaz en Java que permite manejar datos en una estructura de datos doblemente ligada (también conocida como *una cola de doble terminación*). Esto último es una colección lineal de elementos en la que se pueden insertar y eliminar elementos al principio y al final de la colección. La interfaz Deque proporciona métodos para acceder a ambos lados de la instancia de Deque y realizar operaciones como insertar, borrar y recuperar elementos. Las clases ``ArrayDeque`` y ``LinkedList`` implementan la interfaz Deque. 880 | 881 | Los métodos de la interfaz Deque se dividen en las siguientes 3 partes: 882 | 883 | - #### Insertar 884 | 885 | Los métodos ``addfirst()`` y ``offerFirst()`` insertan elementos al principio de la instancia Deque. Los métodos ``addLast()`` y ``offerLast()`` insertan elementos al final de la instancia Deque. Cuando la capacidad de la instancia Deque está restringida, los métodos más apropiados son ``offerFirst()`` y ``offerLast()`` porque ``addFirst()`` podría no arrojar una excepción si está llena. 886 | 887 | - #### Eliminar 888 | 889 | Los métodos ``removeFirst()`` y ``pollFirst()`` eliminan elementos del principio de la instancia Deque. Los métodos ``removeLast()`` y ``pollLast()`` eliminan elementos del final. Los métodos ``pollFirst()`` y ``pollLast()`` devuelven nulos si el Deque está vacío mientras que los métodos ``removeFirst()`` y ``removeLast()`` lanzan una excepción si la instancia Deque está vacía. 890 | 891 | - #### Recuperar 892 | 893 | Los métodos ``getFirst()`` y ``peekFirst()`` recuperan el primer elemento de la instancia Deque. Estos métodos no eliminan el valor de la instancia Deque. De manera similar, los métodos ``getLast()`` y ``peekLast()`` recuperan el último elemento. Los métodos ``getFirst`()`` y ``getLast()`` lanzan una excepción si la instancia Deque está vacía mientras que los métodos ``peekFirst()`` y ``peekLast()`` devuelven NULL. 894 | 895 | ![Tabla de Métodos de la interfaz Deque](https://i.imgur.com/JwFOIau.jpg) 896 | 897 | ## 📚 Módulo 4. Aplicar Abstracción 898 | 899 | - ### Clases Abstractas 900 | 901 | El **polimorfismo** se puede aplicar en la *herencia* sobrescribiendo métodos. n el caso de la implementación de Interfaces también se aplica el polimorfismo. 902 | 903 | Cuando se implementa una **Interfaz** sobre una Clase es necesario que dicha Clase implemente todos los métodos de la Interfaz. No obstante hay casos en los que hacer esto es no necesario y sólo no se ocupa implementar todos los métodos de una interfaz. 904 | 905 | En el caso la **Herencia**, cuando se sobrescribe un método, este hereda la implementación que tenía en la superclase, pero en ocasiones no se necesita heredar la implementación de un método. Otra situación que se puede presentar en la herencia es que no se quiere crear una instancia de una Clase padre ya que esta es muy genérica. 906 | 907 | Las **Clases abstractas** permiten solucionar los problemas citados anteriormente. Las Clases abstractas son una especie de combinación entre Interfaces y Herencia. En este tipo de Clases se puede definir que tipo de métodos son obligatorios de implementar y cuáles no y además no se crean instancias. 908 | 909 | ````java 910 | // Declarar una Clase abstracta 911 | public abstract class Figura { 912 | // Implementación 913 | } 914 | 915 | ```` 916 | 917 | // Usar una Clase abstracta 918 | class Triangulo extends Figura { 919 | // Implementación 920 | } 921 | ```` 922 | 923 | 924 | - ### Miembros abstractos 925 | 926 | Definir un método abstracto: 927 | 928 | ````java 929 | public abstract class Figurar { 930 | ... abstract void dibujate(); // Convierte al método en obligatorio 931 | } 932 | ```` 933 | 934 | Los **métodos abstractos** son obligatorios, a diferencia de los demás métodos que tenga una Clase abstracta y que no estén declarados con la palabra reservada ``abstract`` los cuales serán opcionales. 935 | 936 | Se pueden tener Clases abstractas que tengan subclases que a su vez tengan métodos abstractos: 937 | 938 | ````java 939 | // Superclase 940 | public abstract class Figura { 941 | // Implementación 942 | } 943 | 944 | // Subclase 945 | abstract class Triangulo extends Figura { 946 | abstract void dibujate(); 947 | // Para tener un método abstracto la clase también debe ser abstracta 948 | } 949 | 950 | // Clase hija de la subclase anterior 951 | class TrianguloIsosceles extends Triangulo { 952 | void dibujate() { 953 | // Dibujar triángulo isosceles 954 | } 955 | } 956 | ```` 957 | 958 | #### Ejemplo de Polimorfismo en las Clases abstractas 959 | 960 | ````java 961 | // Superclase 962 | public abstract class User { 963 | public abstract void showDataUser(); 964 | } 965 | 966 | // Main.java 967 | User user = new Doctor("Anahí", "anahí@santaclara.health"); 968 | user.showDataUser(); 969 | ```` 970 | 971 | A pesar de que ``User`` es una Clase abstracta por lo que no puede ser instanciada, gracias al polimorfismo *"puede tomar la forma"* de la clase ``Doctor``, pudiendo convertirse en una instancia de dicha Clase. 972 | 973 | - ### Clases Anónimas 974 | 975 | Son una especie de *hack* para instanciar Clases abstractas. Dicha instanciación es temporal, pues sólo esta vigente en el momento en que se hace la instanciación, no puede reutilizar en otra Clase el comportamiento definido en una Clase anónima. 976 | 977 | ````java 978 | User user1 = new User("Felipe Molina", "felipe@example.com") { 979 | @Override 980 | public void showDataUser() { 981 | // Implementación 982 | } 983 | } 984 | 985 | user1.showDataUser(); 986 | ```` 987 | 988 | Las Clases anónimas se usan mucho en desarrollo para Android, para por ejemplo hacer un elemento clickeable. Usando una Clase anónima se puede agregar el método ``onClickListener`` y darle un comportamiento que sólo va a ser vigente para ese momento. 989 | 990 | Las Clases anónimas también se pueden usar con interfaces: 991 | 992 | ````java 993 | ISchedulable iSchedulable = new ISchedulable() { 994 | @Override 995 | public void schedule(Date date, String time) { 996 | 997 | } 998 | }; 999 | 1000 | ISchedulable iSchedulable1 = new AppointmentDoctor(); 1001 | iSchedulable1.schedule(...); 1002 | ```` 1003 | 1004 | - ### Diferencias entre las Interfaces y las Clases Abstractas 1005 | 1006 | Las **interfaces** ahora cuentan con nuevos modificadores de acceso: ``default`` y ``private`` lo que significa que ahora se puede agregar comportamiento a los métodos de una interfaz, por lo que una interfaz tendrá métodos con implementación y otros sin implementación, exactamente igual que en una Clase abstracta. 1007 | 1008 | #### Diferencias 1009 | 1010 | - ##### Clases abstractas 1011 | 1012 | Se usan para definir subclases, por lo que siempre debe ser heredada para poder llamar y sobrescribir los métodos. La herencia de métodos se hace de forma lineal; se pueden heredar métodos abstractos y no abstractos. En resumen una Clase abstracta sirve para redefinir nuevas Clases sin tener que crear nuevos objetos. Las Clases abstractas a diferencia de las interfaces se centran más en los objetos 1013 | 1014 | - ##### Interfaces 1015 | 1016 | Se tienen métodos abstractos y no abstractos, dichos métodos pueden implementarse en familias de Clases distintas por lo que aquí la implementación de los métodos no es lineal. En resumen las interfaces se usan cuando se quiere crear métodos que se puedan implementar en muchas familias, considerando las acciones que pueden tener en común muchos objetos. 1017 | 1018 | ![Clases abstractas vs. Interfaces](https://i.imgur.com/ogOPI6L.png) 1019 | 1020 | **Nota:** una buena práctica es que el diseño de las apps siempre este orientado a interfaces y no a la implementación. Hay que concentrase en crear buenas abstracciones, encontrar comportamientos comunes, tratar de forma independiente los módulos. En otras palabras, hay que enfocarse más en los métodos (interfaz) que re-definir las clases (clase abstracta). 1021 | 1022 | - ### Interfaces en Java 8 y 9 1023 | 1024 | La sintaxis de las interfaces cambio un poco a partir de Java 8 y 9. 1025 | 1026 | - #### Java 8 1027 | 1028 | Ya no todos los métodos tiene que ser abstractos pues se cuenta con un nuevo modificador de acceso para los métodos, ``default``. Esto permite que los métodos dentro de una interfaz puedan tener implementación, y a su vez dicha implementación se puede reutilizar en cualquier Clase sin importar a que familia pertenezca. Este modificador ``default`` en las interfaces tiene las mismas reglas y restricciones que en en caso de los métodos convencionales, es decir puede ser accedido a nivel de la Clase y por Clases/Interfaces que estén dentro de otro paquete. 1029 | 1030 | - #### Java 9 1031 | 1032 | Se puede añadir el modificador de acceso ``private`` a los métodos de una Interfaz. Este modificador tiene las mismas restricciones que en el caso de los métodos convencionales, es decir, sólo puede ser accedido a nivel de la Clase. También permite hacer una implementación en el método de una Interfaz. 1033 | 1034 | ````java 1035 | public interface MyInterface { 1036 | default void defaultMethod() { 1037 | privateMethod("Hello from the default method!") 1038 | } 1039 | 1040 | private void privateMethod(final String string) { 1041 | System.out.println(string); 1042 | } 1043 | 1044 | void normalMethod(); 1045 | } 1046 | ```` 1047 | 1048 | Este tipo de interfaces son muy útiles al trabajar con bases de datos. 1049 | 1050 | - ### Herencia en interfaces 1051 | 1052 | En las interfaces también se puede aplicar la herencia usando la palabra reservada ``extends``. En las interfaces la herencia funciona igual que en las Clases con la diferencia de que en las interfaces si se puede tener herencia múltiple: 1053 | 1054 | ````java 1055 | public interface IReadable { 1056 | public void read(); 1057 | } 1058 | 1059 | 1060 | public interface Visualizable extends IReadable, Serializable { 1061 | public void setViewed(); 1062 | public Boolean isViewed(); 1063 | public String timeViewed(); 1064 | } 1065 | ```` 1066 | 1067 | Además gracias con los modificadores de acceso ``default`` y ``private`` traídos en Java 8 y 9 respectivamente ahora es posible sobrescribir métodos y añadirles comportamiento, si es el caso: 1068 | 1069 | ````java 1070 | public interface Visualizable extends IReadable, Serializable { 1071 | public void setViewed(); 1072 | public Boolean isViewed(); 1073 | public String timeViewed(); 1074 | 1075 | @Override 1076 | default void read() { 1077 | // TODO Auto-generated method stub 1078 | } 1079 | } 1080 | ```` 1081 | 1082 | **Nota: ** es una práctica nombrar los métodos de la forma más descriptiva posible, aún si quedan muy largos. En caso de que el nombre sea excesivamente largo hay que buscar una serie de palabras claves más cortas que describan lo que hace el método. 1083 | 1084 | 1085 | 1086 | 1087 | 1088 | 1089 | 1090 | 1091 | 1092 | 1093 | 1094 | 1095 | 1096 | -------------------------------------------------------------------------------- /java-se-orientado-a-objetos.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/bl00p1ng/Curso_Java_OOP/8b65d9fef18b328791c482aea278c930e07996fc/java-se-orientado-a-objetos.pdf --------------------------------------------------------------------------------