[{"data":1,"prerenderedAt":828},["ShallowReactive",2],{"navigation_docs":3,"-clases-objetos-clases-genericas":412,"-clases-objetos-clases-genericas-surround":823},[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":115,"body":414,"description":816,"extension":817,"links":818,"meta":819,"navigation":820,"path":116,"seo":821,"stem":117,"__hash__":822},"docs\u002F3.clases-objetos\u002F15.clases-genericas.md",{"type":415,"value":416,"toc":809},"minimark",[417,422,426,430,433,601,623,627,630,752,765,769,798,802,805],[418,419,421],"h2",{"id":420},"qué-son-las-clases-genéricas","¿Qué son las clases genéricas?",[423,424,425],"p",{},"Las clases genéricas en Java son una característica que permite definir clases con parámetros de tipo. Esto significa que puedes crear una clase que pueda trabajar con diferentes tipos de datos sin necesidad de duplicar el código para cada tipo específico. Las clases genéricas proporcionan una forma de escribir código más flexible y reutilizable.",[418,427,429],{"id":428},"sintaxis-de-las-clases-genéricas","Sintaxis de las clases genéricas",[423,431,432],{},"La sintaxis básica para definir una clase genérica es la siguiente:",[434,435,440],"pre",{"className":436,"code":437,"language":438,"meta":439,"style":439},"language-java shiki shiki-themes github-dark","public class NombreClase\u003CT> {\n    private T variable;\n\n    public NombreClase(T variable) {\n        this.variable = variable;\n    }\n\n    public T getVariable() {\n        return variable;\n    }\n\n    public void setVariable(T variable) {\n        this.variable = variable;\n    }\n}\n","java","",[441,442,443,469,478,485,503,519,525,530,544,552,557,562,579,590,595],"code",{"__ignoreMap":439},[444,445,448,452,455,459,463,466],"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"," NombreClase",[444,460,462],{"class":461},"s95oV","\u003C",[444,464,465],{"class":450},"T",[444,467,468],{"class":461},"> {\n",[444,470,472,475],{"class":446,"line":471},2,[444,473,474],{"class":450},"    private",[444,476,477],{"class":461}," T variable;\n",[444,479,481],{"class":446,"line":480},3,[444,482,484],{"emptyLinePlaceholder":483},true,"\n",[444,486,488,491,493,496,500],{"class":446,"line":487},4,[444,489,490],{"class":450},"    public",[444,492,458],{"class":457},[444,494,495],{"class":461},"(T ",[444,497,499],{"class":498},"s9osk","variable",[444,501,502],{"class":461},") {\n",[444,504,506,510,513,516],{"class":446,"line":505},5,[444,507,509],{"class":508},"sDLfK","        this",[444,511,512],{"class":461},".variable ",[444,514,515],{"class":450},"=",[444,517,518],{"class":461}," variable;\n",[444,520,522],{"class":446,"line":521},6,[444,523,524],{"class":461},"    }\n",[444,526,528],{"class":446,"line":527},7,[444,529,484],{"emptyLinePlaceholder":483},[444,531,533,535,538,541],{"class":446,"line":532},8,[444,534,490],{"class":450},[444,536,537],{"class":461}," T ",[444,539,540],{"class":457},"getVariable",[444,542,543],{"class":461},"() {\n",[444,545,547,550],{"class":446,"line":546},9,[444,548,549],{"class":450},"        return",[444,551,518],{"class":461},[444,553,555],{"class":446,"line":554},10,[444,556,524],{"class":461},[444,558,560],{"class":446,"line":559},11,[444,561,484],{"emptyLinePlaceholder":483},[444,563,565,567,570,573,575,577],{"class":446,"line":564},12,[444,566,490],{"class":450},[444,568,569],{"class":450}," void",[444,571,572],{"class":457}," setVariable",[444,574,495],{"class":461},[444,576,499],{"class":498},[444,578,502],{"class":461},[444,580,582,584,586,588],{"class":446,"line":581},13,[444,583,509],{"class":508},[444,585,512],{"class":461},[444,587,515],{"class":450},[444,589,518],{"class":461},[444,591,593],{"class":446,"line":592},14,[444,594,524],{"class":461},[444,596,598],{"class":446,"line":597},15,[444,599,600],{"class":461},"}\n",[423,602,603,604,606,607,609,610,612,613,612,616,612,619,622],{},"En este ejemplo, ",[441,605,465],{}," es un parámetro de tipo que se utiliza para definir el tipo de la variable ",[441,608,499],{},". Puedes usar cualquier letra o nombre para el parámetro de tipo, pero comúnmente se utilizan letras como ",[441,611,465],{},", ",[441,614,615],{},"E",[441,617,618],{},"K",[441,620,621],{},"V",", etc.",[418,624,626],{"id":625},"uso-de-clases-genéricas","Uso de clases genéricas",[423,628,629],{},"Para utilizar una clase genérica, debes especificar el tipo de dato que deseas usar al crear una instancia de la clase. Por ejemplo:",[434,631,633],{"className":436,"code":632,"language":438,"meta":439,"style":439},"void main() {\n    \u002F\u002F Crear una instancia de la clase genérica con Integer\n    NombreClase\u003CInteger> intInstance = new NombreClase\u003C>(42);\n    System.out.println(\"Valor entero: \" + intInstance.getVariable());\n    \u002F\u002F Crear una instancia de la clase genérica con String\n    NombreClase\u003CString> stringInstance = new NombreClase\u003C>(\"Hola, Mundo!\");\n    System.out.println(\"Valor de cadena: \" + stringInstance.getVariable());\n}\n",[441,634,635,645,651,676,702,707,728,748],{"__ignoreMap":439},[444,636,637,640,643],{"class":446,"line":447},[444,638,639],{"class":450},"void",[444,641,642],{"class":457}," main",[444,644,543],{"class":461},[444,646,647],{"class":446,"line":471},[444,648,650],{"class":649},"sAwPA","    \u002F\u002F Crear una instancia de la clase genérica con Integer\n",[444,652,653,656,659,662,664,667,670,673],{"class":446,"line":480},[444,654,655],{"class":461},"    NombreClase\u003C",[444,657,658],{"class":450},"Integer",[444,660,661],{"class":461},"> intInstance ",[444,663,515],{"class":450},[444,665,666],{"class":450}," new",[444,668,669],{"class":461}," NombreClase\u003C>(",[444,671,672],{"class":508},"42",[444,674,675],{"class":461},");\n",[444,677,678,681,684,687,691,694,697,699],{"class":446,"line":487},[444,679,680],{"class":461},"    System.out.",[444,682,683],{"class":457},"println",[444,685,686],{"class":461},"(",[444,688,690],{"class":689},"sU2Wk","\"Valor entero: \"",[444,692,693],{"class":450}," +",[444,695,696],{"class":461}," intInstance.",[444,698,540],{"class":457},[444,700,701],{"class":461},"());\n",[444,703,704],{"class":446,"line":505},[444,705,706],{"class":649},"    \u002F\u002F Crear una instancia de la clase genérica con String\n",[444,708,709,711,714,717,719,721,723,726],{"class":446,"line":521},[444,710,655],{"class":461},[444,712,713],{"class":450},"String",[444,715,716],{"class":461},"> stringInstance ",[444,718,515],{"class":450},[444,720,666],{"class":450},[444,722,669],{"class":461},[444,724,725],{"class":689},"\"Hola, Mundo!\"",[444,727,675],{"class":461},[444,729,730,732,734,736,739,741,744,746],{"class":446,"line":527},[444,731,680],{"class":461},[444,733,683],{"class":457},[444,735,686],{"class":461},[444,737,738],{"class":689},"\"Valor de cadena: \"",[444,740,693],{"class":450},[444,742,743],{"class":461}," stringInstance.",[444,745,540],{"class":457},[444,747,701],{"class":461},[444,749,750],{"class":446,"line":532},[444,751,600],{"class":461},[423,753,754,755,758,759,761,762,764],{},"En este ejemplo, hemos creado dos instancias de la clase genérica ",[441,756,757],{},"NombreClase",": una con el tipo ",[441,760,658],{}," y otra con el tipo ",[441,763,713],{},". Esto demuestra cómo las clases genéricas permiten trabajar con diferentes tipos de datos sin necesidad de duplicar el código.",[418,766,768],{"id":767},"ventajas-de-las-clases-genéricas","Ventajas de las clases genéricas",[770,771,772,780,786,792],"ol",{},[773,774,775,779],"li",{},[776,777,778],"strong",{},"Reutilización de código",": Las clases genéricas permiten escribir código que puede ser reutilizado para diferentes tipos de datos, lo que reduce la duplicación y mejora la mantenibilidad.",[773,781,782,785],{},[776,783,784],{},"Seguridad de tipos",": Al usar clases genéricas, el compilador puede verificar los tipos en tiempo de compilación, lo que ayuda a prevenir errores de tipo en tiempo de ejecución.",[773,787,788,791],{},[776,789,790],{},"Flexibilidad",": Las clases genéricas pueden trabajar con cualquier tipo de dato, lo que las hace muy flexibles y adecuadas para una amplia variedad de aplicaciones.",[773,793,794,797],{},[776,795,796],{},"Compatibilidad con colecciones",": Las clases genéricas son especialmente útiles cuando se trabaja con colecciones, como listas, conjuntos y mapas, ya que permiten especificar el tipo de elementos que contienen.",[418,799,801],{"id":800},"conclusión","Conclusión",[423,803,804],{},"Las clases genéricas son una poderosa característica de Java que permite escribir código más flexible, reutilizable y seguro. Al utilizar clases genéricas, puedes crear estructuras de datos y algoritmos que pueden trabajar con diferentes tipos de datos sin necesidad de duplicar el código, lo que mejora la eficiencia y la mantenibilidad de tus programas.",[806,807,808],"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}html pre.shiki code .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}",{"title":439,"searchDepth":471,"depth":471,"links":810},[811,812,813,814,815],{"id":420,"depth":471,"text":421},{"id":428,"depth":471,"text":429},{"id":625,"depth":471,"text":626},{"id":767,"depth":471,"text":768},{"id":800,"depth":471,"text":801},"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.","md",null,{"editButton":42},{"icon":105},{"title":115,"description":816},"T-d-MdkBXyKb9KJMHkFa_ivZWa6Kb84y1YXRpz45RuY",[824,826],{"title":111,"path":112,"stem":113,"description":825,"children":-1},"Las expresiones regulares son una herramienta poderosa para buscar y manipular cadenas de texto. En esta sección, aprenderás qué son las expresiones regulares, cómo se utilizan en Java y cómo pueden ayudarte a validar y procesar datos de manera eficiente.",{"title":125,"path":126,"stem":127,"description":827,"children":-1},"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.",1779479566244]