[{"data":1,"prerenderedAt":943},["ShallowReactive",2],{"navigation_docs":3,"-metodos-this":412,"-metodos-this-surround":938},[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":145,"body":414,"description":932,"extension":933,"links":934,"meta":935,"navigation":499,"path":146,"seo":936,"stem":147,"__hash__":937},"docs\u002F4.metodos\u002F06.this.md",{"type":415,"value":416,"toc":921},"minimark",[417,427,440,446,451,456,609,626,630,635,767,783,787,792,889,905,909,917],[418,419,421,422,426],"h2",{"id":420},"qué-es-el-puntero-this","¿Qué es el puntero ",[423,424,425],"code",{},"this","?",[428,429,430,431,433,434,436,437,439],"p",{},"El puntero ",[423,432,425],{}," es una referencia especial que se utiliza en programación orientada a objetos para referirse al objeto actual dentro de una clase. En otras palabras, ",[423,435,425],{}," se refiere a la instancia de la clase que está ejecutando el código en ese momento. El puntero ",[423,438,425],{}," es útil para acceder a variables y métodos de la clase, especialmente cuando hay conflictos de nombres o cuando se desea mejorar la legibilidad del código.",[418,441,443,444],{"id":442},"uso-del-puntero-this","Uso del puntero ",[423,445,425],{},[447,448,450],"h3",{"id":449},"acceder-a-variables-de-instancia","Acceder a variables de instancia",[428,452,430,453,455],{},[423,454,425],{}," se utiliza para acceder a las variables de instancia de la clase. Esto es especialmente útil cuando los nombres de las variables de instancia son iguales a los nombres de los parámetros del constructor o de otros métodos.",[457,458,463],"pre",{"className":459,"code":460,"language":461,"meta":462,"style":462},"language-java shiki shiki-themes github-dark","public class Persona {\n    private String nombre;\n\n    public Persona(String nombre) {\n        \u002F\u002F El puntero this se utiliza para diferenciar la variable de instancia del parámetro\n        this.nombre = nombre; \n    }\n\n    public void mostrarNombre() {\n        \u002F\u002F El puntero this se utiliza para acceder a la variable de instancia\n        IO.println(\"El nombre de la persona es: \" + this.nombre); \n    }\n}\n","java","",[423,464,465,485,494,501,519,526,542,548,553,567,573,598,603],{"__ignoreMap":462},[466,467,470,474,477,481],"span",{"class":468,"line":469},"line",1,[466,471,473],{"class":472},"snl16","public",[466,475,476],{"class":472}," class",[466,478,480],{"class":479},"svObZ"," Persona",[466,482,484],{"class":483},"s95oV"," {\n",[466,486,488,491],{"class":468,"line":487},2,[466,489,490],{"class":472},"    private",[466,492,493],{"class":483}," String nombre;\n",[466,495,497],{"class":468,"line":496},3,[466,498,500],{"emptyLinePlaceholder":499},true,"\n",[466,502,504,507,509,512,516],{"class":468,"line":503},4,[466,505,506],{"class":472},"    public",[466,508,480],{"class":479},[466,510,511],{"class":483},"(String ",[466,513,515],{"class":514},"s9osk","nombre",[466,517,518],{"class":483},") {\n",[466,520,522],{"class":468,"line":521},5,[466,523,525],{"class":524},"sAwPA","        \u002F\u002F El puntero this se utiliza para diferenciar la variable de instancia del parámetro\n",[466,527,529,533,536,539],{"class":468,"line":528},6,[466,530,532],{"class":531},"sDLfK","        this",[466,534,535],{"class":483},".nombre ",[466,537,538],{"class":472},"=",[466,540,541],{"class":483}," nombre; \n",[466,543,545],{"class":468,"line":544},7,[466,546,547],{"class":483},"    }\n",[466,549,551],{"class":468,"line":550},8,[466,552,500],{"emptyLinePlaceholder":499},[466,554,556,558,561,564],{"class":468,"line":555},9,[466,557,506],{"class":472},[466,559,560],{"class":472}," void",[466,562,563],{"class":479}," mostrarNombre",[466,565,566],{"class":483},"() {\n",[466,568,570],{"class":468,"line":569},10,[466,571,572],{"class":524},"        \u002F\u002F El puntero this se utiliza para acceder a la variable de instancia\n",[466,574,576,579,582,585,589,592,595],{"class":468,"line":575},11,[466,577,578],{"class":483},"        IO.",[466,580,581],{"class":479},"println",[466,583,584],{"class":483},"(",[466,586,588],{"class":587},"sU2Wk","\"El nombre de la persona es: \"",[466,590,591],{"class":472}," +",[466,593,594],{"class":531}," this",[466,596,597],{"class":483},".nombre); \n",[466,599,601],{"class":468,"line":600},12,[466,602,547],{"class":483},[466,604,606],{"class":468,"line":605},13,[466,607,608],{"class":483},"}\n",[610,611,612,613,616,617,619,620,622,623,625],"note",{},"En el caso de la función ",[423,614,615],{},"mostrarNombre",", el puntero ",[423,618,425],{}," se utiliza para acceder a la variable de instancia ",[423,621,515],{}," y mostrar su valor, sin embargo, en este caso, el uso de ",[423,624,425],{}," es opcional, ya que no hay un conflicto de nombres.",[447,627,629],{"id":628},"llamar-a-métodos-de-la-clase","Llamar a métodos de la clase",[428,631,430,632,634],{},[423,633,425],{}," también se puede utilizar para llamar a otros métodos de la clase desde dentro de un método.",[457,636,638],{"className":459,"code":637,"language":461,"meta":462,"style":462},"public class Calculadora {\n    public int sumar(int a, int b) {\n        return a + b;\n    }\n\n    public int sumarTresNumeros(int a, int b, int c) {\n        \u002F\u002F El puntero this se utiliza para llamar al método sumar desde otro método\n        return this.sumar(this.sumar(a, b), c); \n    }\n}\n",[423,639,640,651,679,693,697,701,731,736,759,763],{"__ignoreMap":462},[466,641,642,644,646,649],{"class":468,"line":469},[466,643,473],{"class":472},[466,645,476],{"class":472},[466,647,648],{"class":479}," Calculadora",[466,650,484],{"class":483},[466,652,653,655,658,661,663,666,669,672,674,677],{"class":468,"line":487},[466,654,506],{"class":472},[466,656,657],{"class":472}," int",[466,659,660],{"class":479}," sumar",[466,662,584],{"class":483},[466,664,665],{"class":472},"int",[466,667,668],{"class":514}," a",[466,670,671],{"class":483},", ",[466,673,665],{"class":472},[466,675,676],{"class":514}," b",[466,678,518],{"class":483},[466,680,681,684,687,690],{"class":468,"line":496},[466,682,683],{"class":472},"        return",[466,685,686],{"class":483}," a ",[466,688,689],{"class":472},"+",[466,691,692],{"class":483}," b;\n",[466,694,695],{"class":468,"line":503},[466,696,547],{"class":483},[466,698,699],{"class":468,"line":521},[466,700,500],{"emptyLinePlaceholder":499},[466,702,703,705,707,710,712,714,716,718,720,722,724,726,729],{"class":468,"line":528},[466,704,506],{"class":472},[466,706,657],{"class":472},[466,708,709],{"class":479}," sumarTresNumeros",[466,711,584],{"class":483},[466,713,665],{"class":472},[466,715,668],{"class":514},[466,717,671],{"class":483},[466,719,665],{"class":472},[466,721,676],{"class":514},[466,723,671],{"class":483},[466,725,665],{"class":472},[466,727,728],{"class":514}," c",[466,730,518],{"class":483},[466,732,733],{"class":468,"line":544},[466,734,735],{"class":524},"        \u002F\u002F El puntero this se utiliza para llamar al método sumar desde otro método\n",[466,737,738,740,742,745,748,750,752,754,756],{"class":468,"line":550},[466,739,683],{"class":472},[466,741,594],{"class":531},[466,743,744],{"class":483},".",[466,746,747],{"class":479},"sumar",[466,749,584],{"class":483},[466,751,425],{"class":531},[466,753,744],{"class":483},[466,755,747],{"class":479},[466,757,758],{"class":483},"(a, b), c); \n",[466,760,761],{"class":468,"line":555},[466,762,547],{"class":483},[466,764,765],{"class":468,"line":569},[466,766,608],{"class":483},[610,768,769,770,772,773,775,776,779,780,782],{},"En este ejemplo, el puntero ",[423,771,425],{}," se utiliza para llamar al método ",[423,774,747],{}," desde el método ",[423,777,778],{},"sumarTresNumeros",", lo que permite reutilizar la lógica de suma y mejorar la legibilidad del código, sin embargo, en este caso, el uso de ",[423,781,425],{}," es opcional, ya que no hay un conflicto de nombres, aunque su uso puede mejorar la claridad del código al indicar que se está llamando a un método de la misma clase.",[447,784,786],{"id":785},"resolver-conflictos-de-nombres","Resolver conflictos de nombres",[428,788,430,789,791],{},[423,790,425],{}," es especialmente útil para resolver conflictos de nombres cuando los nombres de las variables de instancia son iguales a los nombres de los parámetros del constructor o de otros métodos.",[457,793,795],{"className":459,"code":794,"language":461,"meta":462,"style":462},"public class Punto {\n    private int x;\n    private int y;\n\n    public Punto(int x, int y) {\n        \u002F\u002F El puntero this se utiliza para diferenciar las variables de instancia de los parámetros\n        this.x = x; \n        this.y = y; \n    }\n}\n",[423,796,797,808,817,826,830,852,857,869,881,885],{"__ignoreMap":462},[466,798,799,801,803,806],{"class":468,"line":469},[466,800,473],{"class":472},[466,802,476],{"class":472},[466,804,805],{"class":479}," Punto",[466,807,484],{"class":483},[466,809,810,812,814],{"class":468,"line":487},[466,811,490],{"class":472},[466,813,657],{"class":472},[466,815,816],{"class":483}," x;\n",[466,818,819,821,823],{"class":468,"line":496},[466,820,490],{"class":472},[466,822,657],{"class":472},[466,824,825],{"class":483}," y;\n",[466,827,828],{"class":468,"line":503},[466,829,500],{"emptyLinePlaceholder":499},[466,831,832,834,836,838,840,843,845,847,850],{"class":468,"line":521},[466,833,506],{"class":472},[466,835,805],{"class":479},[466,837,584],{"class":483},[466,839,665],{"class":472},[466,841,842],{"class":514}," x",[466,844,671],{"class":483},[466,846,665],{"class":472},[466,848,849],{"class":514}," y",[466,851,518],{"class":483},[466,853,854],{"class":468,"line":528},[466,855,856],{"class":524},"        \u002F\u002F El puntero this se utiliza para diferenciar las variables de instancia de los parámetros\n",[466,858,859,861,864,866],{"class":468,"line":544},[466,860,532],{"class":531},[466,862,863],{"class":483},".x ",[466,865,538],{"class":472},[466,867,868],{"class":483}," x; \n",[466,870,871,873,876,878],{"class":468,"line":550},[466,872,532],{"class":531},[466,874,875],{"class":483},".y ",[466,877,538],{"class":472},[466,879,880],{"class":483}," y; \n",[466,882,883],{"class":468,"line":555},[466,884,547],{"class":483},[466,886,887],{"class":468,"line":569},[466,888,608],{"class":483},[610,890,769,891,893,894,897,898,901,902,904],{},[423,892,425],{}," se utiliza para diferenciar las variables de instancia ",[423,895,896],{},"x"," y ",[423,899,900],{},"y"," de los parámetros del constructor que tienen el mismo nombre. Sin el uso de ",[423,903,425],{},", el código sería ambiguo y no se podría determinar a qué variable se está refiriendo.",[418,906,908],{"id":907},"conclusión","Conclusión",[428,910,430,911,913,914,916],{},[423,912,425],{}," es una herramienta fundamental en la programación orientada a objetos que permite referirse al objeto actual dentro de una clase. Su uso es esencial para acceder a variables y métodos de la clase, resolver conflictos de nombres y mejorar la legibilidad del código. Comprender cómo y cuándo utilizar el puntero ",[423,915,425],{}," es crucial para escribir código claro, eficiente y fácil de mantener en cualquier lenguaje de programación orientado a objetos.",[918,919,920],"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 .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html pre.shiki code .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}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);}",{"title":462,"searchDepth":487,"depth":487,"links":922},[923,925,931],{"id":420,"depth":487,"text":924},"¿Qué es el puntero this?",{"id":442,"depth":487,"text":926,"children":927},"Uso del puntero this",[928,929,930],{"id":449,"depth":496,"text":450},{"id":628,"depth":496,"text":629},{"id":785,"depth":496,"text":786},{"id":907,"depth":487,"text":908},"En este artículo, se explica el concepto de puntero `this` en programación orientada a objetos, cómo se utiliza para referirse al objeto actual dentro de una clase, y se presentan ejemplos de cómo utilizar `this` para acceder a variables y métodos de la clase, así como para resolver conflictos de nombres y mejorar la legibilidad del código.","md",null,{"editButton":42},{"title":145,"description":932},"0L3nPsTIwlmM6giiZK0IW5jtluiR9MdhIc5CaH0K-UA",[939,941],{"title":141,"path":142,"stem":143,"description":940,"children":-1},"En este artículo, se explica el concepto de recursividad en programación, cómo funciona, y se presentan ejemplos de cómo utilizar la recursividad para resolver problemas de manera eficiente.",{"title":149,"path":150,"stem":151,"description":942,"children":-1},"En este artículo, se explica el concepto de argumentos variables (varargs) en programación, cómo se utilizan para permitir que un método acepte un número variable de argumentos, y se presentan ejemplos de cómo utilizar varargs para simplificar la llamada a métodos con múltiples argumentos y mejorar la legibilidad del código.",1779479569271]