[{"data":1,"prerenderedAt":878},["ShallowReactive",2],{"navigation_docs":3,"-herencia-sobeescritura":412,"-herencia-sobeescritura-surround":873},[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":168,"body":414,"description":867,"extension":868,"links":869,"meta":870,"navigation":769,"path":169,"seo":871,"stem":170,"__hash__":872},"docs\u002F5.herencia\u002F02.sobeescritura.md",{"type":415,"value":416,"toc":854},"minimark",[417,422,431,436,511,572,599,607,613,620,694,720,726,732,738,819,837,841,850],[418,419,421],"h2",{"id":420},"qué-es-la-sobreescritura-de-métodos","¿Qué es la sobreescritura de métodos?",[423,424,425,426,430],"p",{},"La sobreescritura de métodos es un concepto fundamental en la programación orientada a objetos que permite a una clase derivada proporcionar una implementación específica de un método que ya está definido en su clase base. Esto se logra utilizando la palabra clave ",[427,428,429],"code",{},"@Override"," en Java, lo que indica que el método en la clase derivada está destinado a sobrescribir el método de la clase base. La sobreescritura de métodos es útil para modificar o extender el comportamiento de un método heredado sin cambiar la firma del método.",[432,433,435],"h3",{"id":434},"ejemplo-de-sobreescritura-de-métodos-en-java","Ejemplo de sobreescritura de métodos en Java",[437,438,443],"pre",{"className":439,"code":440,"language":441,"meta":442,"style":442},"language-java shiki shiki-themes github-dark","public class Animal {\n    public void eat() {\n        System.out.println(\"This animal eats food.\");\n    }\n}\n","java","",[427,444,445,465,480,499,505],{"__ignoreMap":442},[446,447,450,454,457,461],"span",{"class":448,"line":449},"line",1,[446,451,453],{"class":452},"snl16","public",[446,455,456],{"class":452}," class",[446,458,460],{"class":459},"svObZ"," Animal",[446,462,464],{"class":463},"s95oV"," {\n",[446,466,468,471,474,477],{"class":448,"line":467},2,[446,469,470],{"class":452},"    public",[446,472,473],{"class":452}," void",[446,475,476],{"class":459}," eat",[446,478,479],{"class":463},"() {\n",[446,481,483,486,489,492,496],{"class":448,"line":482},3,[446,484,485],{"class":463},"        System.out.",[446,487,488],{"class":459},"println",[446,490,491],{"class":463},"(",[446,493,495],{"class":494},"sU2Wk","\"This animal eats food.\"",[446,497,498],{"class":463},");\n",[446,500,502],{"class":448,"line":501},4,[446,503,504],{"class":463},"    }\n",[446,506,508],{"class":448,"line":507},5,[446,509,510],{"class":463},"}\n",[437,512,514],{"className":439,"code":513,"language":441,"meta":442,"style":442},"public class Dog extends Animal {\n    @Override\n    public void eat() {\n        System.out.println(\"The dog eats dog food.\");\n    }\n}\n",[427,515,516,532,540,550,563,567],{"__ignoreMap":442},[446,517,518,520,522,525,528,530],{"class":448,"line":449},[446,519,453],{"class":452},[446,521,456],{"class":452},[446,523,524],{"class":459}," Dog",[446,526,527],{"class":452}," extends",[446,529,460],{"class":459},[446,531,464],{"class":463},[446,533,534,537],{"class":448,"line":467},[446,535,536],{"class":463},"    @",[446,538,539],{"class":452},"Override\n",[446,541,542,544,546,548],{"class":448,"line":482},[446,543,470],{"class":452},[446,545,473],{"class":452},[446,547,476],{"class":459},[446,549,479],{"class":463},[446,551,552,554,556,558,561],{"class":448,"line":501},[446,553,485],{"class":463},[446,555,488],{"class":459},[446,557,491],{"class":463},[446,559,560],{"class":494},"\"The dog eats dog food.\"",[446,562,498],{"class":463},[446,564,565],{"class":448,"line":507},[446,566,504],{"class":463},[446,568,570],{"class":448,"line":569},6,[446,571,510],{"class":463},[423,573,574,575,578,579,582,583,586,587,589,590,592,593,595,596,598],{},"En este ejemplo, la clase ",[427,576,577],{},"Dog"," sobrescribe el método ",[427,580,581],{},"eat()"," de la clase ",[427,584,585],{},"Animal",". Cuando se llama al método ",[427,588,581],{}," en una instancia de ",[427,591,577],{},", se ejecutará la implementación específica de ",[427,594,577],{},", que imprime \"The dog eats dog food.\" en lugar de la implementación de ",[427,597,585],{},".",[418,600,602,603,606],{"id":601},"uso-de-super-para-acceder-a-los-métodos-de-la-clase-base","Uso de ",[427,604,605],{},"super"," para acceder a los métodos de la clase base",[423,608,609,610,612],{},"La palabra clave ",[427,611,605],{}," se utiliza en Java para acceder a los métodos y atributos de la clase base desde una clase derivada. Esto es especialmente útil cuando deseas llamar a la implementación del método de la clase base dentro de la implementación sobrescrita en la clase derivada.",[432,614,616,617,619],{"id":615},"ejemplo-de-uso-de-super-en-java","Ejemplo de uso de ",[427,618,605],{}," en Java",[437,621,623],{"className":439,"code":622,"language":441,"meta":442,"style":442},"public class Dog extends Animal {\n    @Override\n    public void eat() {\n        super.eat(); \u002F\u002F Llama al método eat() de la clase base Animal\n        System.out.println(\"The dog eats dog food.\");\n    }\n}\n",[427,624,625,639,645,655,673,685,689],{"__ignoreMap":442},[446,626,627,629,631,633,635,637],{"class":448,"line":449},[446,628,453],{"class":452},[446,630,456],{"class":452},[446,632,524],{"class":459},[446,634,527],{"class":452},[446,636,460],{"class":459},[446,638,464],{"class":463},[446,640,641,643],{"class":448,"line":467},[446,642,536],{"class":463},[446,644,539],{"class":452},[446,646,647,649,651,653],{"class":448,"line":482},[446,648,470],{"class":452},[446,650,473],{"class":452},[446,652,476],{"class":459},[446,654,479],{"class":463},[446,656,657,661,663,666,669],{"class":448,"line":501},[446,658,660],{"class":659},"sDLfK","        super",[446,662,598],{"class":463},[446,664,665],{"class":459},"eat",[446,667,668],{"class":463},"(); ",[446,670,672],{"class":671},"sAwPA","\u002F\u002F Llama al método eat() de la clase base Animal\n",[446,674,675,677,679,681,683],{"class":448,"line":507},[446,676,485],{"class":463},[446,678,488],{"class":459},[446,680,491],{"class":463},[446,682,560],{"class":494},[446,684,498],{"class":463},[446,686,687],{"class":448,"line":569},[446,688,504],{"class":463},[446,690,692],{"class":448,"line":691},7,[446,693,510],{"class":463},[423,695,696,697,582,699,701,702,705,706,582,708,710,711,713,714,716,717,719],{},"En este ejemplo, dentro del método ",[427,698,581],{},[427,700,577],{},", se llama a ",[427,703,704],{},"super.eat()",", lo que ejecuta la implementación del método ",[427,707,581],{},[427,709,585],{}," antes de ejecutar el código específico de ",[427,712,577],{},". Esto permite que el método sobrescrito en ",[427,715,577],{}," mantenga el comportamiento original de ",[427,718,585],{}," mientras agrega su propia funcionalidad.",[418,721,723,724],{"id":722},"los-constructores-y-el-uso-de-super","Los constructores y el uso de ",[427,725,605],{},[423,727,728,729,731],{},"Además de acceder a los métodos de la clase base, la palabra clave ",[427,730,605],{}," también se utiliza para llamar al constructor de la clase base desde el constructor de la clase derivada. Esto es importante para asegurarse de que los atributos heredados de la clase base se inicialicen correctamente.",[423,733,734,735,737],{},"Aunque Java proporciona un constructor por defecto que llama al constructor sin argumentos de la clase base, si la clase base no tiene un constructor sin argumentos o si deseas llamar a un constructor específico de la clase base, debes usar ",[427,736,605],{}," explícitamente.",[437,739,741],{"className":439,"code":740,"language":441,"meta":442,"style":442},"public class Dog extends Animal {\n    private String breed;\n\n    public Dog(String breed) {\n        super(); \u002F\u002F Llama al constructor sin argumentos de la clase base Animal\n        this.breed = breed;\n    }\n}\n",[427,742,743,757,765,771,787,796,810,814],{"__ignoreMap":442},[446,744,745,747,749,751,753,755],{"class":448,"line":449},[446,746,453],{"class":452},[446,748,456],{"class":452},[446,750,524],{"class":459},[446,752,527],{"class":452},[446,754,460],{"class":459},[446,756,464],{"class":463},[446,758,759,762],{"class":448,"line":467},[446,760,761],{"class":452},"    private",[446,763,764],{"class":463}," String breed;\n",[446,766,767],{"class":448,"line":482},[446,768,770],{"emptyLinePlaceholder":769},true,"\n",[446,772,773,775,777,780,784],{"class":448,"line":501},[446,774,470],{"class":452},[446,776,524],{"class":459},[446,778,779],{"class":463},"(String ",[446,781,783],{"class":782},"s9osk","breed",[446,785,786],{"class":463},") {\n",[446,788,789,791,793],{"class":448,"line":507},[446,790,660],{"class":659},[446,792,668],{"class":463},[446,794,795],{"class":671},"\u002F\u002F Llama al constructor sin argumentos de la clase base Animal\n",[446,797,798,801,804,807],{"class":448,"line":569},[446,799,800],{"class":659},"        this",[446,802,803],{"class":463},".breed ",[446,805,806],{"class":452},"=",[446,808,809],{"class":463}," breed;\n",[446,811,812],{"class":448,"line":691},[446,813,504],{"class":463},[446,815,817],{"class":448,"line":816},8,[446,818,510],{"class":463},[423,820,821,822,824,825,827,828,831,832,834,835,598],{},"En este ejemplo, el constructor de la clase ",[427,823,577],{}," llama al constructor sin argumentos de la clase ",[427,826,585],{}," utilizando ",[427,829,830],{},"super()",". Esto asegura que cualquier inicialización necesaria en la clase ",[427,833,585],{}," se realice antes de que se ejecute el código específico de ",[427,836,577],{},[418,838,840],{"id":839},"conclusión","Conclusión",[423,842,843,844,846,847,849],{},"La sobreescritura de métodos y el uso de ",[427,845,605],{}," son conceptos esenciales en la programación orientada a objetos que permiten a las clases derivadas modificar o extender el comportamiento de los métodos heredados de la clase base. La sobreescritura de métodos permite proporcionar implementaciones específicas para métodos heredados, mientras que ",[427,848,605],{}," facilita el acceso a los métodos y constructores de la clase base, asegurando una correcta inicialización y reutilización del código. Comprender estos conceptos es crucial para escribir código limpio, eficiente y mantenible en cualquier lenguaje de programación orientado a objetos.",[851,852,853],"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 .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}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 .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html pre.shiki code .s9osk, html code.shiki .s9osk{--shiki-default:#FFAB70}",{"title":442,"searchDepth":467,"depth":467,"links":855},[856,859,864,866],{"id":420,"depth":467,"text":421,"children":857},[858],{"id":434,"depth":482,"text":435},{"id":601,"depth":467,"text":860,"children":861},"Uso de super para acceder a los métodos de la clase base",[862],{"id":615,"depth":482,"text":863},"Ejemplo de uso de super en Java",{"id":722,"depth":467,"text":865},"Los constructores y el uso de super",{"id":839,"depth":467,"text":840},"En este artículo, se explica qué es la sobreescritura de métodos en programación orientada a objetos, cómo se utiliza la palabra clave `super` para acceder a los métodos de la clase base, y se proporcionan ejemplos prácticos para ilustrar estos conceptos.","md",null,{"editButton":42},{"title":168,"description":867},"PZrd8xWG6r499d9ZI2khaPdhB-cin7X1WJZP-xCK48g",[874,876],{"title":166,"path":162,"stem":163,"description":875,"children":-1},"La herencia es un concepto fundamental en la programación orientada a objetos que permite crear nuevas clases basadas en clases existentes, facilitando la reutilización de código y la creación de jerarquías de clases.",{"title":172,"path":173,"stem":174,"description":877,"children":-1},"En este artículo, se explican los diferentes tipos de herencia en programación orientada a objetos, incluyendo la herencia simple, la herencia múltiple, la herencia jerárquica, la herencia híbrida y la herencia multinivel, junto con ejemplos prácticos para ilustrar cada tipo.",1779479569933]