[{"data":1,"prerenderedAt":1027},["ShallowReactive",2],{"navigation_docs":3,"-clases-objetos-constructores":412,"-clases-objetos-constructores-surround":1022},[4,18,43,118,160,200,231,320,346],{"title":5,"path":6,"stem":7,"children":8,"icon":17},"Evaluación","\u002Fintroduction","1.introduction\u002F1.index",[9,12],{"title":10,"path":6,"stem":7,"icon":11},"Método de Evaluación","i-iconamoon-cheque-bold",{"title":13,"path":14,"stem":15,"icon":16},"Plataforma de Aprendizaje","\u002Fintroduction\u002Fplataforma","1.introduction\u002F2.plataforma","i-lucide-book-marked","i-lucide-house",{"title":19,"icon":20,"path":21,"stem":22,"children":23,"page":42},"Entorno de desarrollo","i-codicon-edit-code","\u002Fide","2.ide",[24,28,33,37],{"title":25,"path":26,"stem":27,"icon":20},"¿Qué es un IDE?","\u002Fide\u002Fentorno","2.ide\u002F1.entorno",{"title":29,"path":30,"stem":31,"icon":32},"Estructura de un Proyecto","\u002Fide\u002Festructura","2.ide\u002F2.estructura","i-clarity-tree-view-line",{"title":34,"path":35,"stem":36,"icon":20},"La compilación en un IDE","\u002Fide\u002Fcompilacion","2.ide\u002F3.compilacion",{"title":38,"path":39,"stem":40,"icon":41},"Depuración de Código","\u002Fide\u002Fdepurar","2.ide\u002F4.depurar","i-lucide-bug",false,{"title":44,"icon":45,"path":46,"stem":47,"children":48,"page":42},"Clases y Objetos","i-catppuccin-java-class","\u002Fclases-objetos","3.clases-objetos",[49,53,57,62,66,70,74,78,83,88,92,96,101,106,110,114],{"title":50,"path":51,"stem":52},"Repaso previo a Clases y Objetos","\u002Fclases-objetos\u002Fpreview","3.clases-objetos\u002F00.preview",{"title":54,"path":55,"stem":56,"icon":45},"¿Qué es la Programación Orientada a Objetos (POO)?","\u002Fclases-objetos\u002Fpoo","3.clases-objetos\u002F01.poo",{"title":58,"path":59,"stem":60,"icon":61},"Diagramas de Clases y Objetos","\u002Fclases-objetos\u002Fdiagramas","3.clases-objetos\u002F02.diagramas","i-devicon-uml",{"title":63,"path":64,"stem":65,"icon":45},"Las Clases","\u002Fclases-objetos\u002Fclases","3.clases-objetos\u002F03.clases",{"title":67,"path":68,"stem":69,"icon":45},"Ámbito y Visibilidad","\u002Fclases-objetos\u002Fambito","3.clases-objetos\u002F04.ambito",{"title":71,"path":72,"stem":73,"icon":45},"Declaración e Instanciación de Objetos","\u002Fclases-objetos\u002Fobjetos","3.clases-objetos\u002F05.objetos",{"title":75,"path":76,"stem":77,"icon":45},"Clases Predefinidas en Java","\u002Fclases-objetos\u002Fpredefinidas","3.clases-objetos\u002F06.predefinidas",{"title":79,"path":80,"stem":81,"icon":82},"Paquetes en Java","\u002Fclases-objetos\u002Fpaquetes","3.clases-objetos\u002F07.paquetes","i-material-icon-theme-folder-java-open",{"title":84,"path":85,"stem":86,"icon":87},"Las Excepciones","\u002Fclases-objetos\u002Fexcepciones","3.clases-objetos\u002F08.excepciones","i-catppuccin-java-exception",{"title":89,"path":90,"stem":91,"icon":45},"La clase JOptionPane","\u002Fclases-objetos\u002Fjoptionpane","3.clases-objetos\u002F09.joptionpane",{"title":93,"path":94,"stem":95,"icon":45},"Constructores y Accesores","\u002Fclases-objetos\u002Fconstructores","3.clases-objetos\u002F10.constructores",{"title":97,"path":98,"stem":99,"icon":100},"Tipos Enumerados (Enums)","\u002Fclases-objetos\u002Fenumerados","3.clases-objetos\u002F11.enumerados","i-catppuccin-java-enum",{"title":102,"path":103,"stem":104,"icon":105},"Modificadores de acceso static y final","\u002Fclases-objetos\u002Fmodificadores","3.clases-objetos\u002F12.modificadores","i-mdi-chart-box",{"title":107,"path":108,"stem":109,"icon":105},"El casting en Java","\u002Fclases-objetos\u002Fcasting","3.clases-objetos\u002F13.casting",{"title":111,"path":112,"stem":113},"Las Expresiones Regulares","\u002Fclases-objetos\u002Fexpresiones-regulares","3.clases-objetos\u002F14.expresiones-regulares",{"title":115,"path":116,"stem":117,"icon":105},"Clases Genéricas en Java","\u002Fclases-objetos\u002Fclases-genericas","3.clases-objetos\u002F15.clases-genericas",{"title":119,"icon":120,"path":121,"stem":122,"children":123,"page":42},"Funciones (Métodos)","i-material-symbols-function","\u002Fmetodos","4.metodos",[124,128,132,136,140,144,148,152,156],{"title":125,"path":126,"stem":127},"Funciones Genéricas","\u002Fmetodos\u002Ffuncion-generica","4.metodos\u002F01.funcion-generica",{"title":129,"path":130,"stem":131},"Métodos de Instancia y de Clase","\u002Fmetodos\u002Finstancia-clase","4.metodos\u002F02.instancia-clase",{"title":133,"path":134,"stem":135},"Sobrecarga de Funciones","\u002Fmetodos\u002Fsobrecarga","4.metodos\u002F03.sobrecarga",{"title":137,"path":138,"stem":139},"Alcance de Variables y Métodos","\u002Fmetodos\u002Falcance","4.metodos\u002F04.alcance",{"title":141,"path":142,"stem":143},"Recursividad","\u002Fmetodos\u002Frecursividad","4.metodos\u002F05.recursividad",{"title":145,"path":146,"stem":147},"Puntero this","\u002Fmetodos\u002Fthis","4.metodos\u002F06.this",{"title":149,"path":150,"stem":151},"Los argumentos variables (varargs)","\u002Fmetodos\u002Fvarargs","4.metodos\u002F07.varargs",{"title":153,"path":154,"stem":155},"La clase Arrays","\u002Fmetodos\u002Farrays","4.metodos\u002F08.arrays",{"title":157,"path":158,"stem":159},"Predicados Simples y Compuestos en Java","\u002Fmetodos\u002Fpredicados","4.metodos\u002F09.predicados",{"title":161,"path":162,"stem":163,"children":164,"icon":199},"Herencia","\u002Fherencia","5.herencia\u002F01.index",[165,167,171,175,179,183,187,191,195],{"title":166,"path":162,"stem":163},"¿Qué es la herencia?",{"title":168,"path":169,"stem":170},"Sobreescritura de métodos y uso de `super`","\u002Fherencia\u002Fsobeescritura","5.herencia\u002F02.sobeescritura",{"title":172,"path":173,"stem":174},"Tipos de herencia","\u002Fherencia\u002Ftipos-herencia","5.herencia\u002F03.tipos-herencia",{"title":176,"path":177,"stem":178},"La clase Object en Java","\u002Fherencia\u002Fobject","5.herencia\u002F04.object",{"title":180,"path":181,"stem":182},"Polimorfismo","\u002Fherencia\u002Fpolimorfismo","5.herencia\u002F05.polimorfismo",{"title":184,"path":185,"stem":186},"Clases y Funciones Abstractas","\u002Fherencia\u002Fabstract","5.herencia\u002F06.abstract",{"title":188,"path":189,"stem":190},"Interfaces","\u002Fherencia\u002Finterfaces","5.herencia\u002F07.interfaces",{"title":192,"path":193,"stem":194},"Funciones e Interfaces","\u002Fherencia\u002Ffunciones-interfaces","5.herencia\u002F08.funciones-interfaces",{"title":196,"path":197,"stem":198},"Interfaces y Funciones Lambda","\u002Fherencia\u002Flambda-interface","5.herencia\u002F09.lambda-interface","i-material-symbols-heritage",{"title":201,"path":202,"stem":203,"children":204,"icon":199},"Arreglos","\u002Farreglos","6.arreglos\u002F01.index",[205,207,211,215,219,223,227],{"title":206,"path":202,"stem":203},"Los arreglos en Java",{"title":208,"path":209,"stem":210},"Los arreglos","\u002Farreglos\u002Farray","6.arreglos\u002F02.array",{"title":212,"path":213,"stem":214},"Matrices","\u002Farreglos\u002Fmatrices","6.arreglos\u002F03.matrices",{"title":216,"path":217,"stem":218},"Comparadores","\u002Farreglos\u002Fcomparator","6.arreglos\u002F04.comparator",{"title":220,"path":221,"stem":222},"Arreglos dinámicos: ArrayList","\u002Farreglos\u002Farraylist","6.arreglos\u002F05.arraylist",{"title":224,"path":225,"stem":226},"Arreglos Relacionales: HashMap","\u002Farreglos\u002Fhashmap","6.arreglos\u002F06.hashmap",{"title":228,"path":229,"stem":230},"La clase Stream en Java","\u002Farreglos\u002Fstream","6.arreglos\u002F07.stream",{"title":232,"icon":199,"path":233,"stem":234,"children":235,"page":42},"Archivos e Interfaz de Usuario","\u002Farchivos-ui","7.archivos-ui",[236,240,244,248,252,256,260,264,268,272,276,280,284,288,292,296,300,304,308,312,316],{"title":237,"path":238,"stem":239},"El paquete Swing","\u002Farchivos-ui\u002Fswing","7.archivos-ui\u002F01.swing",{"title":241,"path":242,"stem":243},"La clase JFrame y el JPanel","\u002Farchivos-ui\u002Fjpanel","7.archivos-ui\u002F02.jpanel",{"title":245,"path":246,"stem":247},"Los Layouts en Swing","\u002Farchivos-ui\u002Flayout","7.archivos-ui\u002F03.layout",{"title":249,"path":250,"stem":251},"Iniciando con Swing","\u002Farchivos-ui\u002Finiciando","7.archivos-ui\u002F04.iniciando",{"title":253,"path":254,"stem":255},"Las clases Color y Font en Swing","\u002Farchivos-ui\u002Fcolor-font","7.archivos-ui\u002F05.color-font",{"title":257,"path":258,"stem":259},"Etiquetas en Swing","\u002Farchivos-ui\u002Fetiquetas","7.archivos-ui\u002F06.etiquetas",{"title":261,"path":262,"stem":263},"Personalizando la apariencia de los componentes en Swing","\u002Farchivos-ui\u002Fpersonalizando","7.archivos-ui\u002F07.personalizando",{"title":265,"path":266,"stem":267},"Sobrescribiendo el método drawComponent() en Swing","\u002Farchivos-ui\u002Fdraw","7.archivos-ui\u002F08.draw",{"title":269,"path":270,"stem":271},"Manejando eventos en Swing","\u002Farchivos-ui\u002Feventos","7.archivos-ui\u002F09.eventos",{"title":273,"path":274,"stem":275},"Personalización de Componentes mediante la Extensión de Clases en Swing","\u002Farchivos-ui\u002Fextends-component","7.archivos-ui\u002F10.extends-component",{"title":277,"path":278,"stem":279},"Gradientes","\u002Farchivos-ui\u002Fgradientes","7.archivos-ui\u002F11.gradientes",{"title":281,"path":282,"stem":283},"Botones en Swing","\u002Farchivos-ui\u002Fbotones","7.archivos-ui\u002F12.botones",{"title":285,"path":286,"stem":287},"Los delegadores en Swing","\u002Farchivos-ui\u002Fdelegadores","7.archivos-ui\u002F13.delegadores",{"title":289,"path":290,"stem":291},"UI para nuestro RPG: Parte 1","\u002Farchivos-ui\u002Frpg-ui-1","7.archivos-ui\u002F14.rpg-ui-1",{"title":293,"path":294,"stem":295},"UI para nuestro RPG: Parte 2","\u002Farchivos-ui\u002Frpg-ui-2","7.archivos-ui\u002F15.rpg-ui-2",{"title":297,"path":298,"stem":299},"Los Streams Entrada y Salida","\u002Farchivos-ui\u002Fstreams","7.archivos-ui\u002F16.streams",{"title":301,"path":302,"stem":303},"Archivo tipo Objeto","\u002Farchivos-ui\u002Farchivo-objeto","7.archivos-ui\u002F17.archivo-objeto",{"title":305,"path":306,"stem":307},"UI para nuestro RPG: Parte 3","\u002Farchivos-ui\u002Frpg-ui-3","7.archivos-ui\u002F18.rpg-ui-3",{"title":309,"path":310,"stem":311},"UI para nuestro RPG: Parte 4","\u002Farchivos-ui\u002Frpg-ui-4","7.archivos-ui\u002F19.rpg-ui-4",{"title":313,"path":314,"stem":315},"UI para nuestro RPG: Parte 5","\u002Farchivos-ui\u002Frpg-ui-5","7.archivos-ui\u002F20.rpg-ui-5",{"title":317,"path":318,"stem":319},"UI para nuestro RPG: Parte 6","\u002Farchivos-ui\u002Frpg-ui-6","7.archivos-ui\u002F21.rpg-ui-6",{"title":321,"icon":322,"path":323,"stem":324,"children":325,"page":42},"Ejemplos","i-check-circle","\u002Fejemplos","8.ejemplos",[326,330,334,338,342],{"title":327,"path":328,"stem":329,"icon":105},"Ejemplo 1: Validando entradas con JOptionPane","\u002Fejemplos\u002Fejemplo-01","8.ejemplos\u002F01.ejemplo-01",{"title":331,"path":332,"stem":333},"Ejemplo 02: Uso de clases genéricas en Java","\u002Fejemplos\u002Fejemplo-02","8.ejemplos\u002F02.ejemplo-02",{"title":335,"path":336,"stem":337},"Ejemplo 03: Uso de Enum, Excepciones en Java","\u002Fejemplos\u002Fejemplo-03","8.ejemplos\u002F03.ejemplo-03",{"title":339,"path":340,"stem":341},"Ejemplo 4: Clase con funciones genéricas de validación","\u002Fejemplos\u002Fejemplo-04","8.ejemplos\u002F04.ejemplo-04",{"title":343,"path":344,"stem":345},"Ejemplo 5: Sistema de Gestión de Empleados","\u002Fejemplos\u002Fejemplo-05","8.ejemplos\u002F05.ejemplo-05",{"title":347,"icon":322,"path":348,"stem":349,"children":350,"page":42},"Actividades","\u002Factividades","9.actividades",[351,355,360,364,368,372,376,380,384,388,392,396,400,404,408],{"title":352,"path":353,"stem":354,"icon":105},"Actividad 1: Infografía sobre el proceso de compilación","\u002Factividades\u002Fact-01","9.actividades\u002F01.act-01",{"title":356,"path":357,"stem":358,"icon":359},"Actividad 2: Modelando Diagramas de Clases UML","\u002Factividades\u002Fact-02","9.actividades\u002F02.act-02","i-material-icon-theme-uml",{"title":361,"path":362,"stem":363,"icon":45},"Actividad 3: Creando Clases y Objetos en Java","\u002Factividades\u002Fact-03","9.actividades\u002F03.act-03",{"title":365,"path":366,"stem":367},"Actividad 4: Validando entradas de datos","\u002Factividades\u002Fact-04","9.actividades\u002F04.act-04",{"title":369,"path":370,"stem":371,"icon":105},"Actividad 5: Implementando una clase genérica","\u002Factividades\u002Fact-05","9.actividades\u002F05.act-05",{"title":373,"path":374,"stem":375,"icon":105},"Actividad 6: Expandiendo InputValidator con Predicados y Function","\u002Factividades\u002Fact-06","9.actividades\u002F06.act-06",{"title":377,"path":378,"stem":379,"icon":105},"Actividad 7: Gestor de Biblioteca con InputValidator","\u002Factividades\u002Fact-07","9.actividades\u002F07.act-07",{"title":381,"path":382,"stem":383,"icon":105},"Actividad 8: Calculadora de Figuras Geométricas","\u002Factividades\u002Fact-08","9.actividades\u002F08.act-08",{"title":385,"path":386,"stem":387,"icon":105},"Actividad 9: gestión de una empresa agroalimentaria","\u002Factividades\u002Fact-09","9.actividades\u002F09.act-09",{"title":389,"path":390,"stem":391,"icon":105},"Actividad 10: Sistema de gestión de clínicas veterinarias","\u002Factividades\u002Fact-10","9.actividades\u002F10.act-10",{"title":393,"path":394,"stem":395},"Definición de Proyecto Evolutivo","\u002Factividades\u002Frpg","9.actividades\u002F11.rpg",{"title":397,"path":398,"stem":399},"Actividad 11: Creación de Personajes","\u002Factividades\u002Fact-11","9.actividades\u002F12.act-11",{"title":401,"path":402,"stem":403},"Actividad 12: El Inventario y los Objetos","\u002Factividades\u002Fact-12","9.actividades\u002F13.act-12",{"title":405,"path":406,"stem":407},"Actividad 13: El combate por turnos","\u002Factividades\u002Fact-13","9.actividades\u002F14.act-13",{"title":409,"path":410,"stem":411},"Actividad 14: Guardando y Cargando","\u002Factividades\u002Fact-14","9.actividades\u002F15.act-14",{"id":413,"title":93,"body":414,"description":1015,"extension":1016,"links":1017,"meta":1018,"navigation":1019,"path":94,"seo":1020,"stem":95,"__hash__":1021},"docs\u002F3.clases-objetos\u002F10.constructores.md",{"type":415,"value":416,"toc":1007},"minimark",[417,430,434,446,453,573,589,599,604,619,623,633,735,739,742,755,771,982,990,993,996,1000,1003],[418,419,420,421,425,426,429],"p",{},"En la Programación Orientada a Objetos (POO), los ",[422,423,424],"strong",{},"constructores"," y ",[422,427,428],{},"accesores"," son conceptos fundamentales que desempeñan un papel crucial en la creación, inicialización y acceso a los objetos en Java. Estos conceptos son esenciales para garantizar la integridad de los datos y facilitar la interacción con los objetos de una clase.",[431,432,433],"h2",{"id":424},"Constructores",[418,435,436,437,440,441,445],{},"Un ",[422,438,439],{},"constructor"," es un método especial que se utiliza para crear e inicializar objetos de una clase. El constructor tiene el mismo nombre que la clase y no tiene un tipo de retorno, ni siquiera ",[442,443,444],"code",{},"void",". Su función principal es asignar valores iniciales a los atributos del objeto cuando se crea una instancia de la clase.",[418,447,448,449,452],{},"Por ejemplo, si tenemos una clase ",[442,450,451],{},"Persona",", podemos definir un constructor para inicializar sus atributos de la siguiente manera:",[454,455,461],"pre",{"className":456,"code":457,"filename":458,"language":459,"meta":460,"style":460},"language-java shiki shiki-themes github-dark","public class Persona {\n    String nombre;\n    int edad;   \n\n    public Persona(String nombre, int edad) {\n        this.nombre = nombre;\n        this.edad = edad;\n    }\n}\n","Persona.java","java","",[442,462,463,483,489,498,505,532,548,561,567],{"__ignoreMap":460},[464,465,468,472,475,479],"span",{"class":466,"line":467},"line",1,[464,469,471],{"class":470},"snl16","public",[464,473,474],{"class":470}," class",[464,476,478],{"class":477},"svObZ"," Persona",[464,480,482],{"class":481},"s95oV"," {\n",[464,484,486],{"class":466,"line":485},2,[464,487,488],{"class":481},"    String nombre;\n",[464,490,492,495],{"class":466,"line":491},3,[464,493,494],{"class":470},"    int",[464,496,497],{"class":481}," edad;   \n",[464,499,501],{"class":466,"line":500},4,[464,502,504],{"emptyLinePlaceholder":503},true,"\n",[464,506,508,511,513,516,520,523,526,529],{"class":466,"line":507},5,[464,509,510],{"class":470},"    public",[464,512,478],{"class":477},[464,514,515],{"class":481},"(String ",[464,517,519],{"class":518},"s9osk","nombre",[464,521,522],{"class":481},", ",[464,524,525],{"class":470},"int",[464,527,528],{"class":518}," edad",[464,530,531],{"class":481},") {\n",[464,533,535,539,542,545],{"class":466,"line":534},6,[464,536,538],{"class":537},"sDLfK","        this",[464,540,541],{"class":481},".nombre ",[464,543,544],{"class":470},"=",[464,546,547],{"class":481}," nombre;\n",[464,549,551,553,556,558],{"class":466,"line":550},7,[464,552,538],{"class":537},[464,554,555],{"class":481},".edad ",[464,557,544],{"class":470},[464,559,560],{"class":481}," edad;\n",[464,562,564],{"class":466,"line":563},8,[464,565,566],{"class":481},"    }\n",[464,568,570],{"class":466,"line":569},9,[464,571,572],{"class":481},"}\n",[418,574,575,576,578,579,425,581,584,585,588],{},"En este ejemplo, el constructor ",[442,577,451],{}," toma dos parámetros (",[442,580,519],{},[442,582,583],{},"edad",") y los asigna a los atributos correspondientes utilizando la palabra clave ",[442,586,587],{},"this"," para referirse al objeto actual.",[590,591,592,593,595,596,598],"note",{},"El uso de ",[442,594,587],{}," es importante para diferenciar entre los parámetros del constructor y los atributos de la clase, especialmente cuando tienen el mismo nombre. Sin ",[442,597,587],{},", el código no sabría a qué variable te estás refiriendo, lo que podría causar confusión o errores.",[600,601,603],"h3",{"id":602},"constructor-por-defecto","Constructor por Defecto",[418,605,606,607,610,611,614,615,618],{},"Si no defines un constructor explícitamente en tu clase, Java proporciona automáticamente un ",[422,608,609],{},"constructor por defecto"," sin parámetros que inicializa los atributos con valores predeterminados (por ejemplo, ",[442,612,613],{},"null"," para objetos, ",[442,616,617],{},"0"," para números, etc.). Sin embargo, si defines cualquier constructor personalizado, el constructor por defecto ya no estará disponible a menos que lo declares explícitamente.",[600,620,622],{"id":621},"sobrecarga-de-constructores-y-constructor-vacío","Sobrecarga de Constructores y Constructor Vacío",[418,624,625,626,629,630,632],{},"Puedes tener múltiples constructores en una clase, cada uno con diferentes parámetros. Esto se conoce como ",[422,627,628],{},"sobrecarga de constructores"," y te permite crear objetos de diferentes maneras según las necesidades de tu programa. Por ejemplo, podrías agregar un constructor vacío (sin parámetros) a la clase ",[442,631,451],{}," para permitir la creación de objetos sin necesidad de proporcionar valores iniciales:",[454,634,636],{"className":456,"code":635,"filename":458,"language":459,"meta":460,"style":460},"public class Persona {\n    String nombre;\n    int edad;\n\n    public Persona() {\n        \u002F\u002F Constructor vacío\n    }\n\n    public Persona(String nombre, int edad) {\n        this.nombre = nombre;\n        this.edad = edad;\n    }\n}\n",[442,637,638,648,652,658,662,671,677,681,685,703,714,725,730],{"__ignoreMap":460},[464,639,640,642,644,646],{"class":466,"line":467},[464,641,471],{"class":470},[464,643,474],{"class":470},[464,645,478],{"class":477},[464,647,482],{"class":481},[464,649,650],{"class":466,"line":485},[464,651,488],{"class":481},[464,653,654,656],{"class":466,"line":491},[464,655,494],{"class":470},[464,657,560],{"class":481},[464,659,660],{"class":466,"line":500},[464,661,504],{"emptyLinePlaceholder":503},[464,663,664,666,668],{"class":466,"line":507},[464,665,510],{"class":470},[464,667,478],{"class":477},[464,669,670],{"class":481},"() {\n",[464,672,673],{"class":466,"line":534},[464,674,676],{"class":675},"sAwPA","        \u002F\u002F Constructor vacío\n",[464,678,679],{"class":466,"line":550},[464,680,566],{"class":481},[464,682,683],{"class":466,"line":563},[464,684,504],{"emptyLinePlaceholder":503},[464,686,687,689,691,693,695,697,699,701],{"class":466,"line":569},[464,688,510],{"class":470},[464,690,478],{"class":477},[464,692,515],{"class":481},[464,694,519],{"class":518},[464,696,522],{"class":481},[464,698,525],{"class":470},[464,700,528],{"class":518},[464,702,531],{"class":481},[464,704,706,708,710,712],{"class":466,"line":705},10,[464,707,538],{"class":537},[464,709,541],{"class":481},[464,711,544],{"class":470},[464,713,547],{"class":481},[464,715,717,719,721,723],{"class":466,"line":716},11,[464,718,538],{"class":537},[464,720,555],{"class":481},[464,722,544],{"class":470},[464,724,560],{"class":481},[464,726,728],{"class":466,"line":727},12,[464,729,566],{"class":481},[464,731,733],{"class":466,"line":732},13,[464,734,572],{"class":481},[736,737,738],"caution",{},"Es importante tener en cuenta que si defines un constructor personalizado (como el constructor con parámetros), el constructor por defecto ya no estará disponible a menos que lo declares explícitamente. Por lo tanto, si deseas tener ambos constructores (el vacío y el personalizado), debes asegurarte de definir ambos en tu clase.",[431,740,741],{"id":428},"Accesores",[418,743,744,745,747,748,425,751,754],{},"Los ",[422,746,428],{}," son métodos que se utilizan para acceder a los atributos de un objeto de manera controlada. En Java, los accesores se dividen en dos categorías principales: ",[422,749,750],{},"getters",[422,752,753],{},"setters",".",[756,757,758,765],"ul",{},[759,760,761,764],"li",{},[422,762,763],{},"Getters",": Son métodos que devuelven el valor de un atributo. Por convención, los getters suelen comenzar con la palabra \"get\" seguida del nombre del atributo con la primera letra en mayúscula. Por ejemplo:",[759,766,767,770],{},[422,768,769],{},"Setters",": Son métodos que permiten modificar el valor de un atributo. Por convención, los setters suelen comenzar con la palabra \"set\" seguida del nombre del atributo con la primera letra en mayúscula. Por ejemplo:",[454,772,774],{"className":456,"code":773,"filename":458,"language":459,"meta":460,"style":460},"public class Persona {\n    String nombre;\n    int edad;\n\n    public Persona(String nombre, int edad) {\n        this.nombre = nombre;\n        this.edad = edad;\n    }\n\n    public String getNombre() {\n        return nombre;\n    }\n\n    public void setNombre(String nombre) {\n        this.nombre = nombre;\n    }\n\n    public int getEdad() {\n        return edad;\n    }\n\n    public void setEdad(int edad) {\n        this.edad = edad;\n    } \n}\n",[442,775,776,786,790,796,800,818,828,838,842,846,858,865,869,873,890,901,906,911,924,931,936,941,960,971,977],{"__ignoreMap":460},[464,777,778,780,782,784],{"class":466,"line":467},[464,779,471],{"class":470},[464,781,474],{"class":470},[464,783,478],{"class":477},[464,785,482],{"class":481},[464,787,788],{"class":466,"line":485},[464,789,488],{"class":481},[464,791,792,794],{"class":466,"line":491},[464,793,494],{"class":470},[464,795,560],{"class":481},[464,797,798],{"class":466,"line":500},[464,799,504],{"emptyLinePlaceholder":503},[464,801,802,804,806,808,810,812,814,816],{"class":466,"line":507},[464,803,510],{"class":470},[464,805,478],{"class":477},[464,807,515],{"class":481},[464,809,519],{"class":518},[464,811,522],{"class":481},[464,813,525],{"class":470},[464,815,528],{"class":518},[464,817,531],{"class":481},[464,819,820,822,824,826],{"class":466,"line":534},[464,821,538],{"class":537},[464,823,541],{"class":481},[464,825,544],{"class":470},[464,827,547],{"class":481},[464,829,830,832,834,836],{"class":466,"line":550},[464,831,538],{"class":537},[464,833,555],{"class":481},[464,835,544],{"class":470},[464,837,560],{"class":481},[464,839,840],{"class":466,"line":563},[464,841,566],{"class":481},[464,843,844],{"class":466,"line":569},[464,845,504],{"emptyLinePlaceholder":503},[464,847,848,850,853,856],{"class":466,"line":705},[464,849,510],{"class":470},[464,851,852],{"class":481}," String ",[464,854,855],{"class":477},"getNombre",[464,857,670],{"class":481},[464,859,860,863],{"class":466,"line":716},[464,861,862],{"class":470},"        return",[464,864,547],{"class":481},[464,866,867],{"class":466,"line":727},[464,868,566],{"class":481},[464,870,871],{"class":466,"line":732},[464,872,504],{"emptyLinePlaceholder":503},[464,874,876,878,881,884,886,888],{"class":466,"line":875},14,[464,877,510],{"class":470},[464,879,880],{"class":470}," void",[464,882,883],{"class":477}," setNombre",[464,885,515],{"class":481},[464,887,519],{"class":518},[464,889,531],{"class":481},[464,891,893,895,897,899],{"class":466,"line":892},15,[464,894,538],{"class":537},[464,896,541],{"class":481},[464,898,544],{"class":470},[464,900,547],{"class":481},[464,902,904],{"class":466,"line":903},16,[464,905,566],{"class":481},[464,907,909],{"class":466,"line":908},17,[464,910,504],{"emptyLinePlaceholder":503},[464,912,914,916,919,922],{"class":466,"line":913},18,[464,915,510],{"class":470},[464,917,918],{"class":470}," int",[464,920,921],{"class":477}," getEdad",[464,923,670],{"class":481},[464,925,927,929],{"class":466,"line":926},19,[464,928,862],{"class":470},[464,930,560],{"class":481},[464,932,934],{"class":466,"line":933},20,[464,935,566],{"class":481},[464,937,939],{"class":466,"line":938},21,[464,940,504],{"emptyLinePlaceholder":503},[464,942,944,946,948,951,954,956,958],{"class":466,"line":943},22,[464,945,510],{"class":470},[464,947,880],{"class":470},[464,949,950],{"class":477}," setEdad",[464,952,953],{"class":481},"(",[464,955,525],{"class":470},[464,957,528],{"class":518},[464,959,531],{"class":481},[464,961,963,965,967,969],{"class":466,"line":962},23,[464,964,538],{"class":537},[464,966,555],{"class":481},[464,968,544],{"class":470},[464,970,560],{"class":481},[464,972,974],{"class":466,"line":973},24,[464,975,976],{"class":481},"    } \n",[464,978,980],{"class":466,"line":979},25,[464,981,572],{"class":481},[418,983,984,985,425,987,989],{},"En este ejemplo, hemos definido getters y setters para los atributos ",[442,986,519],{},[442,988,583],{},". Los getters permiten obtener el valor de estos atributos, mientras que los setters permiten modificarlos de manera controlada.",[736,991,992],{},"El uso de getters y setters es una práctica recomendada para mantener la encapsulación y proteger los datos de una clase. Al utilizar getters y setters, puedes controlar cómo se acceden y modifican los atributos de un objeto, lo que ayuda a garantizar la integridad de los datos y facilita el mantenimiento del código a largo plazo.",[736,994,995],{},"Es importante destacar que el uso de getters y setters no es obligatorio en todas las situaciones. En algunos casos, especialmente cuando los atributos de una clase son simples y no requieren validación o lógica adicional, puede ser aceptable acceder a ellos mediante otras funciones. Sin embargo, en general, es recomendable seguir el principio de encapsulación y utilizar getters y setters para proteger los datos y mantener la integridad de los objetos. A menos de que algún atributo sea más de control interno de la clase, en cuyo caso, no es necesario exponerlo a través de getters y setters.",[431,997,999],{"id":998},"resumen","Resumen",[418,1001,1002],{},"En resumen, los constructores y accesores son conceptos fundamentales en la Programación Orientada a Objetos que permiten la creación, inicialización y acceso controlado a los objetos en Java. Los constructores se utilizan para crear e inicializar objetos, mientras que los accesores (getters y setters) se utilizan para acceder y modificar los atributos de un objeto de manera controlada. Al utilizar estos conceptos de manera adecuada, los desarrolladores pueden garantizar la integridad de los datos y facilitar la interacción con los objetos en sus programas orientados a objetos.",[1004,1005,1006],"style",{},"html pre.shiki code .snl16, html code.shiki .snl16{--shiki-default:#F97583}html pre.shiki code .svObZ, html code.shiki .svObZ{--shiki-default:#B392F0}html pre.shiki code .s95oV, html code.shiki .s95oV{--shiki-default:#E1E4E8}html pre.shiki code .s9osk, html code.shiki .s9osk{--shiki-default:#FFAB70}html pre.shiki code .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}",{"title":460,"searchDepth":485,"depth":485,"links":1008},[1009,1013,1014],{"id":424,"depth":485,"text":433,"children":1010},[1011,1012],{"id":602,"depth":491,"text":603},{"id":621,"depth":491,"text":622},{"id":428,"depth":485,"text":741},{"id":998,"depth":485,"text":999},"Aprendamos sobre los constructores y accesores en Java, dos conceptos fundamentales para la creación e inicialización de objetos, así como para el acceso a sus atributos.","md",null,{"editButton":42},{"icon":45},{"title":93,"description":1015},"XqjDICJGSRdDmn9OfZRsLJX67rXxY2lDHt8JPc3RoDI",[1023,1025],{"title":89,"path":90,"stem":91,"description":1024,"icon":45,"children":-1},"Aprendamos sobre la clase JOptionPane en Java, una herramienta útil para mostrar diálogos gráficos y obtener entradas del usuario de manera sencilla.",{"title":97,"path":98,"stem":99,"description":1026,"icon":100,"children":-1},"Descubre qué son los tipos enumerados (enums) en Java, cómo se definen y utilizan, y su importancia en la programación orientada a objetos.",1779479565411]