[{"data":1,"prerenderedAt":953},["ShallowReactive",2],{"navigation_docs":3,"-metodos-funcion-generica":412,"-metodos-funcion-generica-surround":948},[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":125,"body":414,"description":942,"extension":943,"links":944,"meta":945,"navigation":468,"path":126,"seo":946,"stem":127,"__hash__":947},"docs\u002F4.metodos\u002F01.funcion-generica.md",{"type":415,"value":416,"toc":934},"minimark",[417,422,426,430,433,571,598,602,608,782,788,792,852,856,863,915,923,927,930],[418,419,421],"h2",{"id":420},"qué-son-las-funciones-genéricas","¿Qué son las funciones genéricas?",[423,424,425],"p",{},"Las funciones genéricas son funciones que pueden operar con diferentes tipos de datos sin necesidad de duplicar código. En lugar de escribir una función específica para cada tipo de dato, puedes escribir una función genérica que acepte un tipo de dato como parámetro. Esto permite que la función sea reutilizable y flexible.",[418,427,429],{"id":428},"ejemplo-de-función-genérica-en-java","Ejemplo de función genérica en Java",[423,431,432],{},"Aquí hay un ejemplo de una función genérica en Java que intercambia dos elementos en un array:",[434,435,440],"pre",{"className":436,"code":437,"language":438,"meta":439,"style":439},"language-java shiki shiki-themes github-dark","public class GenericFunctionExample {\n\n    public static \u003CT> void swap(T[] array, int i, int j) {\n        T temp = array[i];\n        array[i] = array[j];\n        array[j] = temp;\n    }\n}\n","java","",[441,442,443,463,470,525,537,548,559,565],"code",{"__ignoreMap":439},[444,445,448,452,455,459],"span",{"class":446,"line":447},"line",1,[444,449,451],{"class":450},"snl16","public",[444,453,454],{"class":450}," class",[444,456,458],{"class":457},"svObZ"," GenericFunctionExample",[444,460,462],{"class":461},"s95oV"," {\n",[444,464,466],{"class":446,"line":465},2,[444,467,469],{"emptyLinePlaceholder":468},true,"\n",[444,471,473,476,479,482,485,488,491,494,497,499,502,506,509,512,515,517,519,522],{"class":446,"line":472},3,[444,474,475],{"class":450},"    public",[444,477,478],{"class":450}," static",[444,480,481],{"class":461}," \u003C",[444,483,484],{"class":450},"T",[444,486,487],{"class":461},"> ",[444,489,490],{"class":450},"void",[444,492,493],{"class":457}," swap",[444,495,496],{"class":461},"(",[444,498,484],{"class":450},[444,500,501],{"class":461},"[] ",[444,503,505],{"class":504},"s9osk","array",[444,507,508],{"class":461},", ",[444,510,511],{"class":450},"int",[444,513,514],{"class":504}," i",[444,516,508],{"class":461},[444,518,511],{"class":450},[444,520,521],{"class":504}," j",[444,523,524],{"class":461},") {\n",[444,526,528,531,534],{"class":446,"line":527},4,[444,529,530],{"class":461},"        T temp ",[444,532,533],{"class":450},"=",[444,535,536],{"class":461}," array[i];\n",[444,538,540,543,545],{"class":446,"line":539},5,[444,541,542],{"class":461},"        array[i] ",[444,544,533],{"class":450},[444,546,547],{"class":461}," array[j];\n",[444,549,551,554,556],{"class":446,"line":550},6,[444,552,553],{"class":461},"        array[j] ",[444,555,533],{"class":450},[444,557,558],{"class":461}," temp;\n",[444,560,562],{"class":446,"line":561},7,[444,563,564],{"class":461},"    }\n",[444,566,568],{"class":446,"line":567},8,[444,569,570],{"class":461},"}\n",[423,572,573,574,577,578,580,581,584,585,588,589,584,591,593,594,597],{},"En este ejemplo, la función ",[441,575,576],{},"swap"," es una función genérica que acepta un array de cualquier tipo ",[441,579,484],{}," y dos índices ",[441,582,583],{},"i"," y ",[441,586,587],{},"j",". La función intercambia los elementos en las posiciones ",[441,590,583],{},[441,592,587],{}," del array. El uso de ",[441,595,596],{},"\u003CT>"," antes del tipo de retorno indica que esta es una función genérica que puede trabajar con cualquier tipo de dato.",[418,599,601],{"id":600},"uso-de-la-función-genérica","Uso de la función genérica",[423,603,604,605,607],{},"Aquí hay un ejemplo de cómo usar la función genérica ",[441,606,576],{}," para intercambiar elementos en un array de enteros y un array de cadenas:",[434,609,611],{"className":436,"code":610,"language":438,"meta":439,"style":439},"void main() {\n    Integer[] intArray = {1, 2, 3, 4, 5};\n    GenericFunctionExample.swap(intArray, 1, 3);\n    IO.println(\"Swapped Integer Array: \" + Arrays.toString(intArray));\n\n    String[] stringArray = {\"Hello\", \"World\", \"Java\"};\n    GenericFunctionExample.swap(stringArray, 0, 2);\n    IO.println(\"Swapped String Array: \" + Arrays.toString(stringArray));\n}\n",[441,612,613,623,663,682,708,712,739,757,777],{"__ignoreMap":439},[444,614,615,617,620],{"class":446,"line":447},[444,616,490],{"class":450},[444,618,619],{"class":457}," main",[444,621,622],{"class":461},"() {\n",[444,624,625,628,631,633,636,640,642,645,647,650,652,655,657,660],{"class":446,"line":465},[444,626,627],{"class":450},"    Integer",[444,629,630],{"class":461},"[] intArray ",[444,632,533],{"class":450},[444,634,635],{"class":461}," {",[444,637,639],{"class":638},"sDLfK","1",[444,641,508],{"class":461},[444,643,644],{"class":638},"2",[444,646,508],{"class":461},[444,648,649],{"class":638},"3",[444,651,508],{"class":461},[444,653,654],{"class":638},"4",[444,656,508],{"class":461},[444,658,659],{"class":638},"5",[444,661,662],{"class":461},"};\n",[444,664,665,668,670,673,675,677,679],{"class":446,"line":472},[444,666,667],{"class":461},"    GenericFunctionExample.",[444,669,576],{"class":457},[444,671,672],{"class":461},"(intArray, ",[444,674,639],{"class":638},[444,676,508],{"class":461},[444,678,649],{"class":638},[444,680,681],{"class":461},");\n",[444,683,684,687,690,692,696,699,702,705],{"class":446,"line":527},[444,685,686],{"class":461},"    IO.",[444,688,689],{"class":457},"println",[444,691,496],{"class":461},[444,693,695],{"class":694},"sU2Wk","\"Swapped Integer Array: \"",[444,697,698],{"class":450}," +",[444,700,701],{"class":461}," Arrays.",[444,703,704],{"class":457},"toString",[444,706,707],{"class":461},"(intArray));\n",[444,709,710],{"class":446,"line":539},[444,711,469],{"emptyLinePlaceholder":468},[444,713,714,717,720,722,724,727,729,732,734,737],{"class":446,"line":550},[444,715,716],{"class":450},"    String",[444,718,719],{"class":461},"[] stringArray ",[444,721,533],{"class":450},[444,723,635],{"class":461},[444,725,726],{"class":694},"\"Hello\"",[444,728,508],{"class":461},[444,730,731],{"class":694},"\"World\"",[444,733,508],{"class":461},[444,735,736],{"class":694},"\"Java\"",[444,738,662],{"class":461},[444,740,741,743,745,748,751,753,755],{"class":446,"line":561},[444,742,667],{"class":461},[444,744,576],{"class":457},[444,746,747],{"class":461},"(stringArray, ",[444,749,750],{"class":638},"0",[444,752,508],{"class":461},[444,754,644],{"class":638},[444,756,681],{"class":461},[444,758,759,761,763,765,768,770,772,774],{"class":446,"line":567},[444,760,686],{"class":461},[444,762,689],{"class":457},[444,764,496],{"class":461},[444,766,767],{"class":694},"\"Swapped String Array: \"",[444,769,698],{"class":450},[444,771,701],{"class":461},[444,773,704],{"class":457},[444,775,776],{"class":461},"(stringArray));\n",[444,778,780],{"class":446,"line":779},9,[444,781,570],{"class":461},[423,783,784,785,787],{},"En este ejemplo, creamos un array de enteros y un array de cadenas. Luego, llamamos a la función ",[441,786,576],{}," para intercambiar elementos en ambos arrays. La función genérica permite que el mismo código se utilice para ambos tipos de datos sin necesidad de escribir funciones separadas para cada tipo.",[418,789,791],{"id":790},"reglas-de-las-funciones-genéricas","Reglas de las funciones genéricas",[793,794,795,805,820,823,826,833,836],"ol",{},[796,797,798,799,801,802,804],"li",{},"Las funciones genéricas deben declarar un tipo de parámetro genérico utilizando la sintaxis ",[441,800,596],{},", donde ",[441,803,484],{}," es un nombre de tipo que se puede usar dentro de la función.",[796,806,807,808],{},"El tipo de parámetro debe ser un argumento de la propia función, ya sea como tipo de retorno o como tipo de uno de los parámetros de la función.\n",[809,810,811,814,817],"ul",{},[796,812,813],{},"Si el tipo de parámetro genérico no se utiliza en la función, entonces no es necesario declararlo como genérico.",[796,815,816],{},"Si el tipo de parámetro genérico se utiliza solo como tipo de retorno, entonces no es necesario que la función tenga parámetros.",[796,818,819],{},"Si el tipo de parámetro genérico se utiliza solo como tipo de uno de los parámetros, entonces no es necesario que la función tenga un tipo de retorno.",[796,821,822],{},"El tipo de parámetro genérico puede ser cualquier tipo de dato, incluyendo tipos primitivos, clases, interfaces y otros tipos genéricos.",[796,824,825],{},"Las funciones genéricas pueden lanzar excepciones, pero no pueden lanzar excepciones que dependan del tipo de parámetro genérico.",[796,827,828,829,832],{},"Las funciones genéricas no pueden crear instancias de tipos genéricos ni usar operadores de tipo como ",[441,830,831],{},"instanceof"," con tipos genéricos debido a la eliminación de tipos en tiempo de compilación.",[796,834,835],{},"Las funciones genéricas pueden ser sobrecargadas, pero no pueden ser sobrecargadas solo por el tipo de parámetro genérico debido a la eliminación de tipos en tiempo de compilación.",[796,837,838,839,842,843,508,845,842,848,851],{},"Las funciones genéricas pueden ser utilizadas con tipos de datos primitivos utilizando sus clases envolventes (por ejemplo, ",[441,840,841],{},"Integer"," para ",[441,844,511],{},[441,846,847],{},"Double",[441,849,850],{},"double",", etc.) debido a la autoboxing en Java.",[418,853,855],{"id":854},"funciones-genéricas-con-restricciones","Funciones genéricas con restricciones",[423,857,858,859,862],{},"En algunos casos, es posible que desees restringir los tipos de datos que una función genérica puede aceptar. Esto se puede lograr utilizando restricciones de tipo. Por ejemplo, si deseas que una función genérica solo acepte tipos que implementen la interfaz ",[441,860,861],{},"Comparable",", puedes usar la siguiente sintaxis:",[434,864,866],{"className":436,"code":865,"language":438,"meta":439,"style":439},"public static \u003CT extends Comparable\u003CT>> void sort(T[] array) {\n    Arrays.sort(array);\n}\n",[441,867,868,900,911],{"__ignoreMap":439},[444,869,870,872,874,876,879,882,884,887,890,893,895,897],{"class":446,"line":447},[444,871,451],{"class":450},[444,873,478],{"class":450},[444,875,481],{"class":450},[444,877,878],{"class":461},"T extends Comparable",[444,880,881],{"class":450},"\u003C",[444,883,484],{"class":461},[444,885,886],{"class":450},">>",[444,888,889],{"class":450}," void",[444,891,892],{"class":457}," sort",[444,894,496],{"class":461},[444,896,484],{"class":450},[444,898,899],{"class":461},"[] array) {\n",[444,901,902,905,908],{"class":446,"line":465},[444,903,904],{"class":461},"    Arrays.",[444,906,907],{"class":457},"sort",[444,909,910],{"class":461},"(array);\n",[444,912,913],{"class":446,"line":472},[444,914,570],{"class":461},[423,916,573,917,919,920,922],{},[441,918,907],{}," es una función genérica que solo acepta tipos que implementen la interfaz ",[441,921,861],{},". Esto garantiza que los elementos del array puedan ser comparados entre sí para realizar la ordenación.",[418,924,926],{"id":925},"conclusión","Conclusión",[423,928,929],{},"Las funciones genéricas son una herramienta poderosa en la programación que permite a los desarrolladores escribir código más flexible y reutilizable. Al utilizar funciones genéricas, puedes evitar la necesidad de escribir código duplicado para cada tipo de dato que deseas manipular, lo que mejora la eficiencia y la mantenibilidad de tu código. Al comprender las reglas y limitaciones de las funciones genéricas, puedes aprovechar al máximo esta característica en tus programas.",[931,932,933],"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 .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 .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}",{"title":439,"searchDepth":465,"depth":465,"links":935},[936,937,938,939,940,941],{"id":420,"depth":465,"text":421},{"id":428,"depth":465,"text":429},{"id":600,"depth":465,"text":601},{"id":790,"depth":465,"text":791},{"id":854,"depth":465,"text":855},{"id":925,"depth":465,"text":926},"En este artículo, se explica qué son las funciones genéricas en programación y cómo se pueden utilizar para crear funciones que pueden operar con diferentes tipos de datos sin necesidad de duplicar código.","md",null,{"editButton":42},{"title":125,"description":942},"eqPfHvjlzcrEM_ejdHfSc3fr51GCQGwG18Z8uDO64_o",[949,951],{"title":115,"path":116,"stem":117,"description":950,"icon":105,"children":-1},"En esta sección, exploraremos el concepto de clases genéricas en Java, que permiten crear clases que pueden trabajar con diferentes tipos de datos de manera flexible y segura.",{"title":129,"path":130,"stem":131,"description":952,"children":-1},"En este artículo, se explican los métodos de instancia y de clase en programación orientada a objetos, sus diferencias y cómo se utilizan para definir el comportamiento de las clases y sus objetos.",1779479566351]