[{"data":1,"prerenderedAt":1141},["ShallowReactive",2],{"navigation_docs":3,"-clases-objetos-preview":412,"-clases-objetos-preview-surround":1136},[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":50,"body":414,"description":1129,"extension":1130,"links":1131,"meta":1132,"navigation":1133,"path":51,"seo":1134,"stem":52,"__hash__":1135},"docs\u002F3.clases-objetos\u002F00.preview.md",{"type":415,"value":416,"toc":1121},"minimark",[417,421,430,436,487,493,516,530,537,545,554,638,644,718,728,802,808,872,878,882,885,1008,1012,1015,1117],[418,419,420],"p",{},"Antes de comenzar con el tema de Clases y Objetos, es útil hacer un repaso rápido de algunos conceptos fundamentales que serán necesarios para entender este paradigma de programación desde el punto de vista del lenguaje Java y desde la versión 25 más reciente.",[422,423,425,426],"h2",{"id":424},"actualización-del-bloque-main","Actualización del Bloque ",[427,428,429],"code",{},"main",[418,431,432,433,435],{},"En versiones anteriores de Java, el método ",[427,434,429],{}," se definía de la siguiente manera:",[437,438,443],"pre",{"className":439,"code":440,"language":441,"meta":442,"style":442},"language-java shiki shiki-themes github-dark","public static void main(String[] args) {\n    \u002F\u002F Código aquí\n}\n","java","",[427,444,445,474,481],{"__ignoreMap":442},[446,447,450,454,457,460,464,468,471],"span",{"class":448,"line":449},"line",1,[446,451,453],{"class":452},"snl16","public",[446,455,456],{"class":452}," static",[446,458,459],{"class":452}," void",[446,461,463],{"class":462},"svObZ"," main",[446,465,467],{"class":466},"s95oV","(",[446,469,470],{"class":452},"String",[446,472,473],{"class":466},"[] args) {\n",[446,475,477],{"class":448,"line":476},2,[446,478,480],{"class":479},"sAwPA","    \u002F\u002F Código aquí\n",[446,482,484],{"class":448,"line":483},3,[446,485,486],{"class":466},"}\n",[418,488,489,490,492],{},"Además de que este método debía de existir dentro de una clase, a partir de Java 25, se ha introducido una sintaxis más simplificada para el método ",[427,491,429],{},", permitiendo escribir programas más concisos. La nueva forma es la siguiente:",[437,494,496],{"className":439,"code":495,"language":441,"meta":442,"style":442},"void main() {\n    \u002F\u002F Código aquí\n}\n",[427,497,498,508,512],{"__ignoreMap":442},[446,499,500,503,505],{"class":448,"line":449},[446,501,502],{"class":452},"void",[446,504,463],{"class":462},[446,506,507],{"class":466},"() {\n",[446,509,510],{"class":448,"line":476},[446,511,480],{"class":479},[446,513,514],{"class":448,"line":483},[446,515,486],{"class":466},[418,517,518,519,522,523,526,527,529],{},"Esta nueva sintaxis elimina la necesidad de declarar el método como ",[427,520,521],{},"public static"," y omite los argumentos ",[427,524,525],{},"String[] args",", lo que facilita la escritura de programas simples y rápidos. Además, ya no es obligatorio que el método ",[427,528,429],{}," esté contenido dentro de una clase, lo que representa un cambio significativo en la estructura del código Java.",[531,532,533,534,536],"note",{},"Es importante destacar que esta nueva sintaxis está diseñada para simplificar la escritura de programas pequeños y ejemplos educativos. Para aplicaciones más complejas y en entornos de producción, es recomendable seguir utilizando la sintaxis tradicional del método ",[427,535,429],{}," dentro de una clase.",[422,538,540,541,544],{"id":539},"el-bloque-switch-mejorado","El bloque ",[427,542,543],{},"switch"," mejorado",[418,546,547,548,550,551,553],{},"Otra mejora significativa en Java 25 es la introducción de una versión más concisa y expresiva del bloque ",[427,549,543],{},". Anteriormente, el ",[427,552,543],{}," se escribía de la siguiente manera:",[437,555,557],{"className":439,"code":556,"language":441,"meta":442,"style":442},"switch (variable) {\n    case valor1:\n        \u002F\u002F Código para valor1\n        break;\n    case valor2:\n        \u002F\u002F Código para valor2\n        break;\n    default:\n        \u002F\u002F Código por defecto\n        break;\n}\n",[427,558,559,566,577,582,591,601,607,614,620,626,633],{"__ignoreMap":442},[446,560,561,563],{"class":448,"line":449},[446,562,543],{"class":452},[446,564,565],{"class":466}," (variable) {\n",[446,567,568,571,574],{"class":448,"line":476},[446,569,570],{"class":452},"    case",[446,572,573],{"class":466}," valor1",[446,575,576],{"class":452},":\n",[446,578,579],{"class":448,"line":483},[446,580,581],{"class":479},"        \u002F\u002F Código para valor1\n",[446,583,585,588],{"class":448,"line":584},4,[446,586,587],{"class":452},"        break",[446,589,590],{"class":466},";\n",[446,592,594,596,599],{"class":448,"line":593},5,[446,595,570],{"class":452},[446,597,598],{"class":466}," valor2",[446,600,576],{"class":452},[446,602,604],{"class":448,"line":603},6,[446,605,606],{"class":479},"        \u002F\u002F Código para valor2\n",[446,608,610,612],{"class":448,"line":609},7,[446,611,587],{"class":452},[446,613,590],{"class":466},[446,615,617],{"class":448,"line":616},8,[446,618,619],{"class":452},"    default:\n",[446,621,623],{"class":448,"line":622},9,[446,624,625],{"class":479},"        \u002F\u002F Código por defecto\n",[446,627,629,631],{"class":448,"line":628},10,[446,630,587],{"class":452},[446,632,590],{"class":466},[446,634,636],{"class":448,"line":635},11,[446,637,486],{"class":466},[418,639,640,641,643],{},"A partir de Java 25, se ha introducido una nueva sintaxis para el ",[427,642,543],{}," que permite utilizar expresiones lambda y simplificar el código. La nueva forma es la siguiente:",[437,645,647],{"className":439,"code":646,"language":441,"meta":442,"style":442},"switch (variable) {\n    case valor1 -> {\n        \u002F\u002F Código para valor1\n    }\n    case valor2 -> {\n        \u002F\u002F Código para valor2\n    }\n    default -> {\n        \u002F\u002F Código por defecto\n    }\n}\n",[427,648,649,655,668,672,677,688,692,696,706,710,714],{"__ignoreMap":442},[446,650,651,653],{"class":448,"line":449},[446,652,543],{"class":452},[446,654,565],{"class":466},[446,656,657,659,662,665],{"class":448,"line":476},[446,658,570],{"class":452},[446,660,661],{"class":466}," valor1 ",[446,663,664],{"class":452},"->",[446,666,667],{"class":466}," {\n",[446,669,670],{"class":448,"line":483},[446,671,581],{"class":479},[446,673,674],{"class":448,"line":584},[446,675,676],{"class":466},"    }\n",[446,678,679,681,684,686],{"class":448,"line":593},[446,680,570],{"class":452},[446,682,683],{"class":466}," valor2 ",[446,685,664],{"class":452},[446,687,667],{"class":466},[446,689,690],{"class":448,"line":603},[446,691,606],{"class":479},[446,693,694],{"class":448,"line":609},[446,695,676],{"class":466},[446,697,698,701,704],{"class":448,"line":616},[446,699,700],{"class":452},"    default",[446,702,703],{"class":452}," ->",[446,705,667],{"class":466},[446,707,708],{"class":448,"line":622},[446,709,625],{"class":479},[446,711,712],{"class":448,"line":628},[446,713,676],{"class":466},[446,715,716],{"class":448,"line":635},[446,717,486],{"class":466},[418,719,720,721,723,724,727],{},"Esta nueva sintaxis utiliza la flecha ",[427,722,664],{}," para asociar cada caso con su bloque de código correspondiente, eliminando la necesidad de utilizar la palabra clave ",[427,725,726],{},"break",". Esto hace que el código sea más limpio y fácil de leer. Además si las acciones a realizar son simples, se pueden escribir en una sola línea:",[437,729,731],{"className":439,"code":730,"language":441,"meta":442,"style":442},"switch (variable) {\n    case valor1 -> System.out.println(\"Valor 1 seleccionado\");\n    case valor2 -> System.out.println(\"Valor 2 seleccionado\");\n    default -> System.out.println(\"Valor por defecto\");\n}\n",[427,732,733,739,762,781,798],{"__ignoreMap":442},[446,734,735,737],{"class":448,"line":449},[446,736,543],{"class":452},[446,738,565],{"class":466},[446,740,741,743,745,747,750,753,755,759],{"class":448,"line":476},[446,742,570],{"class":452},[446,744,661],{"class":466},[446,746,664],{"class":452},[446,748,749],{"class":466}," System.out.",[446,751,752],{"class":462},"println",[446,754,467],{"class":466},[446,756,758],{"class":757},"sU2Wk","\"Valor 1 seleccionado\"",[446,760,761],{"class":466},");\n",[446,763,764,766,768,770,772,774,776,779],{"class":448,"line":483},[446,765,570],{"class":452},[446,767,683],{"class":466},[446,769,664],{"class":452},[446,771,749],{"class":466},[446,773,752],{"class":462},[446,775,467],{"class":466},[446,777,778],{"class":757},"\"Valor 2 seleccionado\"",[446,780,761],{"class":466},[446,782,783,785,787,789,791,793,796],{"class":448,"line":584},[446,784,700],{"class":452},[446,786,703],{"class":452},[446,788,749],{"class":466},[446,790,752],{"class":462},[446,792,467],{"class":466},[446,794,795],{"class":757},"\"Valor por defecto\"",[446,797,761],{"class":466},[446,799,800],{"class":448,"line":593},[446,801,486],{"class":466},[418,803,804,805,807],{},"Incluso, la sentencia ",[427,806,543],{}," puede ser utilizado como una expresión que devuelve un valor:",[437,809,811],{"className":439,"code":810,"language":441,"meta":442,"style":442},"int resultado = switch (variable) {\n    case valor1 -> 10;\n    case valor2 -> 20;\n    default -> 0;\n};\n",[427,812,813,829,843,856,867],{"__ignoreMap":442},[446,814,815,818,821,824,827],{"class":448,"line":449},[446,816,817],{"class":452},"int",[446,819,820],{"class":466}," resultado ",[446,822,823],{"class":452},"=",[446,825,826],{"class":452}," switch",[446,828,565],{"class":466},[446,830,831,833,835,837,841],{"class":448,"line":476},[446,832,570],{"class":452},[446,834,661],{"class":466},[446,836,664],{"class":452},[446,838,840],{"class":839},"sDLfK"," 10",[446,842,590],{"class":466},[446,844,845,847,849,851,854],{"class":448,"line":483},[446,846,570],{"class":452},[446,848,683],{"class":466},[446,850,664],{"class":452},[446,852,853],{"class":839}," 20",[446,855,590],{"class":466},[446,857,858,860,862,865],{"class":448,"line":584},[446,859,700],{"class":452},[446,861,703],{"class":452},[446,863,864],{"class":839}," 0",[446,866,590],{"class":466},[446,868,869],{"class":448,"line":593},[446,870,871],{"class":466},"};\n",[418,873,874,875,877],{},"Estas mejoras en el bloque ",[427,876,543],{}," permiten escribir código más conciso y expresivo, facilitando la lectura y el mantenimiento del mismo.",[422,879,881],{"id":880},"tipos-de-datos","Tipos de Datos",[418,883,884],{},"Java es un lenguaje de programación fuertemente tipado, lo que significa que cada variable debe declararse con un tipo de dato específico. A continuación, se presentan los tipos de datos primitivos más comunes en Java:",[886,887,888,904],"table",{},[889,890,891],"thead",{},[892,893,894,898,901],"tr",{},[895,896,897],"th",{},"Tipo de Dato",[895,899,900],{},"Descripción",[895,902,903],{},"Tamaño",[905,906,907,920,933,945,957,970,983,996],"tbody",{},[892,908,909,914,917],{},[910,911,912],"td",{},[427,913,817],{},[910,915,916],{},"Entero de 32 bits",[910,918,919],{},"4 bytes",[892,921,922,927,930],{},[910,923,924],{},[427,925,926],{},"long",[910,928,929],{},"Entero de 64 bits",[910,931,932],{},"8 bytes",[892,934,935,940,943],{},[910,936,937],{},[427,938,939],{},"float",[910,941,942],{},"Número de punto flotante de 32 bits",[910,944,919],{},[892,946,947,952,955],{},[910,948,949],{},[427,950,951],{},"double",[910,953,954],{},"Número de punto flotante de 64 bits",[910,956,932],{},[892,958,959,964,967],{},[910,960,961],{},[427,962,963],{},"char",[910,965,966],{},"Carácter Unicode de 16 bits",[910,968,969],{},"2 bytes",[892,971,972,977,980],{},[910,973,974],{},[427,975,976],{},"boolean",[910,978,979],{},"Valor verdadero o falso",[910,981,982],{},"1 bit",[892,984,985,990,993],{},[910,986,987],{},[427,988,989],{},"byte",[910,991,992],{},"Entero de 8 bits",[910,994,995],{},"1 byte",[892,997,998,1003,1006],{},[910,999,1000],{},[427,1001,1002],{},"short",[910,1004,1005],{},"Entero de 16 bits",[910,1007,969],{},[422,1009,1011],{"id":1010},"los-wrappers","Los Wrappers",[418,1013,1014],{},"En Java, los tipos de datos primitivos tienen clases envolventes (wrappers) que proporcionan métodos y funcionalidades adicionales. A continuación, se presentan los wrappers correspondientes a los tipos de datos primitivos:",[886,1016,1017,1027],{},[889,1018,1019],{},[892,1020,1021,1024],{},[895,1022,1023],{},"Tipo Primitivo",[895,1025,1026],{},"Wrapper Correspondiente",[905,1028,1029,1040,1051,1062,1073,1084,1095,1106],{},[892,1030,1031,1035],{},[910,1032,1033],{},[427,1034,817],{},[910,1036,1037],{},[427,1038,1039],{},"Integer",[892,1041,1042,1046],{},[910,1043,1044],{},[427,1045,926],{},[910,1047,1048],{},[427,1049,1050],{},"Long",[892,1052,1053,1057],{},[910,1054,1055],{},[427,1056,939],{},[910,1058,1059],{},[427,1060,1061],{},"Float",[892,1063,1064,1068],{},[910,1065,1066],{},[427,1067,951],{},[910,1069,1070],{},[427,1071,1072],{},"Double",[892,1074,1075,1079],{},[910,1076,1077],{},[427,1078,963],{},[910,1080,1081],{},[427,1082,1083],{},"Character",[892,1085,1086,1090],{},[910,1087,1088],{},[427,1089,976],{},[910,1091,1092],{},[427,1093,1094],{},"Boolean",[892,1096,1097,1101],{},[910,1098,1099],{},[427,1100,989],{},[910,1102,1103],{},[427,1104,1105],{},"Byte",[892,1107,1108,1112],{},[910,1109,1110],{},[427,1111,1002],{},[910,1113,1114],{},[427,1115,1116],{},"Short",[1118,1119,1120],"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 .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}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 .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}html pre.shiki code .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}",{"title":442,"searchDepth":476,"depth":476,"links":1122},[1123,1125,1127,1128],{"id":424,"depth":476,"text":1124},"Actualización del Bloque main",{"id":539,"depth":476,"text":1126},"El bloque switch mejorado",{"id":880,"depth":476,"text":881},{"id":1010,"depth":476,"text":1011},"Un repaso rápido de conceptos fundamentales necesarios antes de adentrarnos en Clases y Objetos.","md",null,{"editButton":42,"icon":45},true,{"title":50,"description":1129},"MvGnk7bQK0tEeKocrl5zZZWeCMiZ2nweL4EyGf-RUPA",[1137,1139],{"title":38,"path":39,"stem":40,"description":1138,"icon":41,"children":-1},"Aprende a utilizar las herramientas de depuración en un IDE para identificar y corregir errores en tu código Java.",{"title":54,"path":55,"stem":56,"description":1140,"icon":45,"children":-1},"Introducción a los conceptos fundamentales de la Programación Orientada a Objetos (POO) y su importancia en el desarrollo de software moderno.",1779479563486]