{"author":"Melchor Estrada José Luis","modules":[{"children":[{"children":[],"contentMd":"### Definición de Programación\nLa **programación** es el proceso de crear un conjunto de instrucciones (código) que una computadora puede entender y ejecutar para realizar tareas específicas. \n\n### Elementos Esenciales de la Programación\n\n#### 1. Instrucciones\nCada orden individual que recibe la computadora:\n- **Operaciones aritméticas**: sumas, restas, multiplicaciones\n- **Operaciones lógicas**: comparaciones, condiciones\n- **Operaciones de entrada/salida**: leer datos, mostrar resultados\n\n#### 2. Algoritmos\nSecuencia lógica y ordenada de pasos para resolver un problema:\n- **Características de un buen algoritmo**:\n  - Preciso (sin ambigüedades)\n  - Definido (siempre produce el mismo resultado con las mismas entradas)\n  - Finito (debe terminar en algún momento)\n  - Eficiente (usa recursos de forma óptima)\n\n#### 3. Lenguajes de Programación\nSistemas de comunicación con la computadora:\n- **Lenguajes de bajo nivel**: Más cercanos al hardware (ensamblador)\n- **Lenguajes de alto nivel**: Más cercanos al lenguaje humano (C#, Java, Python)\n- **Compilados vs Interpretados**: Formas diferentes de ejecutar el código\n\n### Importancia de la Programación\n- **Automatización** de tareas repetitivas\n- **Resolución** de problemas complejos\n- **Innovación** tecnológica\n- **Eficiencia** en procesos empresariales","title":"Qué es la Programación"},{"children":[],"contentMd":"### Concepto de Programación Estructurada\nLa **programación estructurada** es un paradigma que organiza el código de manera lógica y secuencial usando tres estructuras de control fundamentales.\n\n### Las Tres Estructuras Básicas\n\n#### 1. Secuencia\n**Definición**: Ejecución de instrucciones una después de otra, en el orden en que aparecen.\n\n**Características**:\n- Orden lineal de ejecución\n- Cada instrucción se ejecuta exactamente una vez\n- Flujo predecible y sencillo\n\n**Ejemplo conceptual**:\n```\nINICIO\n    Instrucción 1\n    Instrucción 2\n    Instrucción 3\nFIN\n```\n\n#### 2. Decisión (Estructuras Condicionales)\n**Definición**: Permiten que el programa tome diferentes caminos según se cumplan o no ciertas condiciones.\n\n**Tipos**:\n- **If simple**: Ejecuta un bloque si se cumple una condición\n- **If-else**: Ejecuta un bloque u otro según la condición\n- **Switch-case**: Múltiples caminos según el valor de una variable\n\n**Ejemplo conceptual**:\n```\nSI (condición es VERDADERA) ENTONCES\n    ejecutar bloque A\nSINO\n    ejecutar bloque B\nFIN SI\n```\n\n#### 3. Iteración (Bucles)\n**Definición**: Repiten un bloque de código múltiples veces mientras se cumpla una condición.\n\n**Tipos**:\n- **For**: Número determinado de repeticiones\n- **While**: Repite mientras la condición sea verdadera\n- **Do-while**: Ejecuta al menos una vez y luego repite mientras la condición sea verdadera\n\n**Ejemplo conceptual**:\n```\nMIENTRAS (condición sea VERDADERA) HACER\n    ejecutar bloque de código\n    actualizar condición\nFIN MIENTRAS\n```\n\n### Ventajas de la Programación Estructurada\n- **Código más legible** y fácil de entender\n- **Menos propenso a errores** lógicos\n- **Facilita el mantenimiento** y modificación\n- **Mejor organización** del código\n- **Promueve la reutilización** mediante funciones\n\n### Limitaciones\n- **Dificultad** para modelar problemas del mundo real\n- **Código menos reutilizable** en proyectos grandes\n- **Complejidad** en aplicaciones de gran escala","title":"Programación Estructurada"},{"children":[],"contentMd":"### Definición de POO\nLa **Programación Orientada a Objetos (POO)** es un paradigma de programación que se basa en el concepto de \"objetos\", los cuales contienen tanto **datos** (atributos) como **comportamientos** (métodos).\n\n### Conceptos Fundamentales de POO\n\n#### 1. Objetos\n**Definición**: Entidades que combinan estado y comportamiento.\n\n**Características de los objetos**:\n- **Identidad**: Cada objeto es único\n- **Estado**: Conjunto de valores de sus atributos en un momento dado\n- **Comportamiento**: Acciones que puede realizar\n\n**Ejemplos del mundo real**:\n- Un **coche** específico (objeto) vs el concepto de coche (clase)\n- Una **persona** con nombre y edad específicos\n- Una **cuenta bancaria** con saldo y titular\n\n#### 2. Clases\n**Definición**: Plantillas o moldes que definen las características y comportamientos que tendrán los objetos.\n\n**Relación clase-objeto**:\n- La **clase** es el plano o diseño\n- El **objeto** es la instancia concreta creada a partir de ese plano\n\n**Analogía**:\n- **Clase** = Molde para hacer galletas\n- **Objeto** = Galleta específica hecha con ese molde\n\n### Diferencias entre POO y Programación Estructurada\n\n| Aspecto | Programación Estructurada | Programación Orientada a Objetos |\n|---------|--------------------------|----------------------------------|\n| **Enfoque** | Funciones y procedimientos | Objetos y sus interacciones |\n| **Datos y código** | Separados | Unidos en objetos |\n| **Reutilización** | Mediante funciones | Mediante herencia y composición |\n| **Modelado** | Procesos y algoritmos | Entidades del mundo real |\n| **Mantenimiento** | Más difícil en proyectos grandes | Más organizado y escalable |\n\n### Ventajas de la POO\n- **Modelado natural**: Representa mejor el mundo real\n- **Reutilización**: Código más reusable mediante herencia\n- **Mantenibilidad**: Más fácil modificar y extender\n- **Encapsulamiento**: Protección de datos internos\n- **Abstracción**: Oculta complejidad innecesaria\n\n### Aplicaciones de la POO\n- **Sistemas empresariales** complejos\n- **Interfaces gráficas** de usuario\n- **Videojuegos** y simulaciones\n- **Aplicaciones web** y móviles\n- **Sistemas operativos** y drivers","title":"Programación Orientada a Objetos (POO)"},{"children":[],"contentMd":"### ¿Qué es la Programación?\nLa **programación** es el proceso de crear un conjunto de instrucciones que le dicen a una computadora cómo realizar una tarea específica. Estas instrucciones se escriben en un **lenguaje de programación**.\n\n### Lenguajes de Programación que Aprenderemos\n- **Visual Basic .NET**: Para aplicaciones Windows con Windows Forms\n- **Java**: Para aplicaciones multiplataforma\n- **PHP**: Para desarrollo web del lado del servidor\n- **C# .NET MAUI**: Para aplicaciones móviles y desktop\n\n### Variables y Tipos de Datos\nConcepto común en todos los lenguajes:\n```vb\n' Visual Basic\nDim nombre As String = \"Juan\"\nDim edad As Integer = 25\nDim precio As Double = 19.99\nDim esMayor As Boolean = True\n```\n\n```java\n// Java\nString nombre = \"Juan\";\nint edad = 25;\ndouble precio = 19.99;\nboolean esMayor = true;\n```\n\n```php\n// PHP\n$nombre = \"Juan\";\n$edad = 25;\n$precio = 19.99;\n$esMayor = true;\n```\n\n### Estructuras de Control\nLas mismas estructuras lógicas en todos los lenguajes:\n- **Condicionales**: if, else, switch\n- **Bucles**: for, while, do-while\n- **Secuencias**: ejecución lineal de código","title":"Introducción a la Programación Multiplataforma"},{"children":[],"contentMd":"### Programación Estructurada\nOrganiza el código en funciones/procedimientos:\n```vb\n' Visual Basic - Enfoque estructurado\nModule Calculadora\n    Sub Main()\n        Dim resultado As Double = Sumar(5, 3)\n        Console.WriteLine(resultado)\n    End Sub\n    \n    Function Sumar(a As Double, b As Double) As Double\n        Return a + b\n    End Function\nEnd Module\n```\n\n### Programación Orientada a Objetos\nOrganiza el código en clases y objetos:\n```vb\n' Visual Basic - Enfoque POO\nPublic Class Calculadora\n    Public Function Sumar(a As Double, b As Double) As Double\n        Return a + b\n    End Function\nEnd Class\n```\n\n### Ventajas de la POO\n- **Reutilización** mediante herencia\n- **Organización** mejor del código\n- **Mantenibilidad** más fácil\n- **Abstracción** de la complejidad\n\n### Transición entre Paradigmas\nLa POO no reemplaza la programación estructurada, la complementa. Dentro de los métodos de una clase, seguimos usando programación estructurada.","title":"Programación Estructurada vs POO - Enfoque Práctico"}],"shortDescription":"Conceptos básicos de programación, introducción a la POO y comparativa entre paradigmas estructurado y orientado a objetos.","title":"Fundamentos de Programación y POO"},{"children":[{"children":[],"contentMd":"### Definición de Clase\nUna **clase** es una plantilla, molde o blueprint que define las características (atributos) y comportamientos (métodos) que tendrán los objetos creados a partir de ella.\n\n### Componentes de una Clase\n\n#### 1. Atributos (Variables Miembro)\n**Definición**: Variables internas que almacenan el estado del objeto.\n\n**Características**:\n- Representan las **propiedades** o **características** del objeto\n- Definen el **estado** actual del objeto\n- Pueden ser de diferentes tipos de datos\n\n**Ejemplos**:\n- En una clase `Coche`: color, marca, velocidad, número de puertas\n- En una clase `Persona`: nombre, edad, dirección, teléfono\n- En una clase `CuentaBancaria`: número de cuenta, saldo, titular\n\n#### 2. Métodos\n**Definición**: Funciones o procedimientos que definen el comportamiento del objeto.\n\n**Características**:\n- Representan las **acciones** que puede realizar el objeto\n- Pueden modificar el estado del objeto (atributos)\n- Pueden devolver información sobre el estado del objeto\n\n**Ejemplos**:\n- En una clase `Coche`: acelerar(), frenar(), cambiarMarcha()\n- En una clase `Persona`: caminar(), hablar(), trabajar()\n- En una clase `CuentaBancaria`: depositar(), retirar(), consultarSaldo()\n\n#### 3. Constructores\n**Definición**: Métodos especiales que se ejecutan al crear un nuevo objeto.\n\n**Función principal**:\n- **Inicializar** los atributos del objeto\n- Establecer el **estado inicial** del objeto\n- Realizar **configuraciones** necesarias\n\n### Estructura General de una Clase\n```\nNOMBRE_DE_LA_CLASE\n├── ATRIBUTOS\n│   ├── atributo1\n│   ├── atributo2\n│   └── ...\n├── CONSTRUCTORES\n│   ├── Constructor por defecto\n│   ├── Constructor con parámetros\n│   └── ...\n└── MÉTODOS\n    ├── método1()\n    ├── método2()\n    └── ...\n```\n\n### Ejemplo Conceptual de Clase\n**Clase: Libro**\n\n**Atributos**:\n- título (texto)\n- autor (texto)\n- número de páginas (número)\n- ISBN (texto)\n- prestado (sí/no)\n\n**Métodos**:\n- prestar()\n- devolver()\n- obtenerInformación()\n- estaPrestado()\n\n**Importancia de las Clases**:\n- **Organización**: Agrupan datos y comportamientos relacionados\n- **Reutilización**: Pueden usarse para crear múltiples objetos\n- **Abstracción**: Definen interfaces claras para interactuar con los objetos\n- **Mantenibilidad**: Cambios en la clase afectan a todos sus objetos","title":"Clases en POO - Teoría"},{"children":[],"contentMd":"### Definición de Objeto\nUn **objeto** es una instancia concreta creada a partir de una clase. Es la \"cosa real\" con la que trabajamos en el programa.\n\n### Características de los Objetos\n\n#### 1. Identidad\n**Definición**: Cada objeto es único e identificable, incluso si tiene los mismos valores de atributos que otro objeto.\n\n**Ejemplo**:\n- Dos coches del mismo modelo, color y año siguen siendo objetos diferentes\n- Cada objeto ocupa una posición diferente en memoria\n\n#### 2. Estado\n**Definición**: Conjunto de valores actuales de todos los atributos del objeto.\n\n**Características**:\n- El estado puede **cambiar** durante la ejecución del programa\n- Representa la \"situación actual\" del objeto\n- Se modifica mediante los métodos del objeto\n\n**Ejemplo**:\n- Un objeto `Coche` puede tener estado: {color: \"rojo\", velocidad: 50, combustible: 30}\n\n#### 3. Comportamiento\n**Definición**: Conjunto de operaciones que el objeto puede realizar, definidas por sus métodos.\n\n**Características**:\n- Define **qué puede hacer** el objeto\n- Puede modificar el estado del objeto\n- Puede interactuar con otros objetos\n\n### Creación de Objetos (Instanciación)\n\n#### Proceso de Instanciación\n1. **Reserva de memoria**: El sistema asigna espacio para el objeto\n2. **Ejecución del constructor**: Se inicializan los atributos\n3. **Referencia**: Se obtiene una referencia para manipular el objeto\n\n#### Sintaxis General\n```\nTipoDeClase nombreDelObjeto = new ConstructorDeLaClase(parámetros);\n```\n\n**Ejemplo conceptual**:\n```\nCoche miCoche = new Coche(\"Toyota\", \"Rojo\", 2023);\n```\n\n### Manipulación de Objetos\n\n#### Acceso a Miembros\n**Operador punto (.)**: Se usa para acceder a atributos y métodos del objeto.\n\n**Ejemplos**:\n- **Leer un atributo**: `valor = miCoche.color`\n- **Modificar un atributo**: `miCoche.color = \"Azul\"`\n- **Llamar un método**: `miCoche.acelerar(20)`\n\n#### Comunicación entre Objetos\nLos objetos pueden interactuar entre sí mediante:\n- **Paso de mensajes**: Un objeto llama a métodos de otro objeto\n- **Asociaciones**: Relaciones estables entre objetos\n- **Composición**: Un objeto contiene otros objetos\n\n### Ejemplos de Objetos en Diferentes Contextos\n\n#### Sistema Bancario\n- Objeto `CuentaCorriente`: {número: \"123-456\", saldo: 1500.00, titular: \"Juan Pérez\"}\n- Objeto `Cliente`: {nombre: \"María García\", dirección: \"Calle 123\", teléfono: \"555-0123\"}\n\n#### Sistema Educativo\n- Objeto `Estudiante`: {nombre: \"Carlos López\", matrícula: \"A12345\", promedio: 8.5}\n- Objeto `Curso`: {nombre: \"Matemáticas\", código: \"MAT101\", créditos: 5}\n\n#### Vida Real\n- Objeto `LibroFísico`: {título: \"Cien años de soledad\", ubicación: \"Estante B2\", prestado: true}\n- Objeto `Persona`: {nombre: \"Ana\", edad: 30, profesión: \"Ingeniera\"}\n\n### Importancia de los Objetos\n- **Modelado preciso**: Representan entidades del mundo real\n- **Encapsulamiento**: Ocultan detalles de implementación\n- **Modularidad**: Facilitan el desarrollo en equipo\n- **Flexibilidad**: Permiten cambios sin afectar todo el sistema","title":"Objetos en POO - Teoría"},{"children":[],"contentMd":"### Atributos en POO\n\n#### Definición de Atributo\nUn **atributo** es una variable declarada dentro de una clase que almacena un dato o característica específica de los objetos de esa clase.\n\n#### Características de los Atributos\n- **Pertenecen** a la clase pero existen en cada objeto\n- **Definen** el estado del objeto\n- **Pueden ser** de cualquier tipo de dato válido\n- **Tienen** un nivel de acceso (público, privado, protegido)\n\n#### Tipos de Atributos\n\n##### 1. Atributos de Instancia\n**Definición**: Existen en cada objeto individualmente.\n\n**Características**:\n- Cada objeto tiene su **propia copia** del atributo\n- Los valores pueden ser **diferentes** en cada objeto\n- Ocupan memoria por **cada objeto** creado\n\n**Ejemplo**:\n```\nClase: Persona\nAtributos de instancia: nombre, edad, altura\n\nObjeto persona1: {nombre: \"Ana\", edad: 25, altura: 1.65}\nObjeto persona2: {nombre: \"Luis\", edad: 30, altura: 1.80}\n```\n\n##### 2. Atributos de Clase (Estáticos)\n**Definición**: Pertenecen a la clase en sí, no a objetos individuales.\n\n**Características**:\n- Existe **una sola copia** para toda la clase\n- Compartido por **todos los objetos** de la clase\n- Se accede mediante el **nombre de la clase**\n\n**Ejemplo**:\n```\nClase: Empleado\nAtributo de clase: contadorEmpleados (cuenta cuántos empleados se han creado)\n```\n\n### Propiedades en POO\n\n#### Definición de Propiedad\nLas **propiedades** son características que describen a un objeto. Técnicamente, son métodos especiales (getters y setters) que controlan el acceso a los atributos privados.\n\n#### Propósito de las Propiedades\n- **Controlar el acceso** a los atributos privados\n- **Validar datos** antes de asignarlos\n- **Proteger la integridad** de los datos del objeto\n- **Proporcionar una interfaz pública** para acceder a datos privados\n\n#### Componentes de una Propiedad\n\n##### 1. Getter (Método de Obtención)\n**Función**: Devuelve el valor del atributo.\n\n**Características**:\n- Se ejecuta cuando se **lee** la propiedad\n- Puede incluir **lógica adicional** (cálculos, formatos)\n- No recibe parámetros (generalmente)\n\n##### 2. Setter (Método de Asignación)\n**Función**: Asigna un nuevo valor al atributo.\n\n**Características**:\n- Se ejecuta cuando se **asigna** un valor a la propiedad\n- Recibe el **nuevo valor** como parámetro\n- Puede incluir **validaciones** y restricciones\n\n#### Ejemplo Conceptual de Propiedades\n```\nClase: CuentaBancaria\n\nAtributo privado: _saldo\n\nPropiedad pública: Saldo\n- Get: Devuelve el valor de _saldo\n- Set: Solo permite asignar si el valor es positivo\n\nPropiedad pública: Titular\n- Get: Devuelve el nombre del titular\n- Set: Valida que el nombre no esté vacío\n```\n\n### Diferencia entre Atributos y Propiedades\n\n| Aspecto | Atributos | Propiedades |\n|---------|-----------|-------------|\n| **Acceso** | Directo (depende del modificador) | Controlado mediante métodos |\n| **Validación** | No tiene validación incorporada | Puede incluir validaciones |\n| **Implementación** | Variables simples | Métodos get/set |\n| **Flexibilidad** | Menos flexible | Muy flexible |\n| **Encapsulamiento** | Puede violar el encapsulamiento | Preserva el encapsulamiento |\n\n### Buenas Prácticas\n- **Atributos privados**: Hacer los atributos privados para proteger los datos\n- **Propiedades públicas**: Usar propiedades para acceder a los atributos privados\n- **Validaciones**: Incluir validaciones en los setters\n- **Nomenclatura**: Usar nombres descriptivos para atributos y propiedades\n\n### Importancia en el Encapsulamiento\nLas propiedades son fundamentales para implementar el **encapsulamiento** porque:\n- **Ocultan** la implementación interna\n- **Controlan** cómo se accede a los datos\n- **Protegen** la integridad de los datos\n- **Permiten** cambiar la implementación sin afectar el código que usa la clase","title":"Atributos y Propiedades - Teoría"},{"children":[],"contentMd":"### Definición de Constructor\nUn **constructor** es un método especial dentro de una clase que se ejecuta automáticamente cuando se crea un nuevo objeto (instancia).\n\n### Características de los Constructores\n\n#### 1. Ejecución Automática\n- Se llama **inmediatamente** después de crear el objeto\n- No es necesario llamarlo **manualmente**\n- Se ejecuta **antes** que cualquier otro método del objeto\n\n#### 2. Inicialización\n**Función principal**: Dar valores iniciales a los atributos del objeto.\n\n**Qué inicializa**:\n- Atributos de instancia\n- Estados iniciales\n- Conexiones a recursos externos\n- Configuraciones necesarias\n\n#### 3. Mismo Nombre que la Clase\n- El constructor siempre tiene el **mismo nombre** que la clase\n- No tiene **tipo de retorno** (ni siquiera void)\n\n### Tipos de Constructores\n\n#### 1. Constructor por Defecto (Sin Parámetros)\n**Definición**: Constructor que no recibe parámetros.\n\n**Características**:\n- Inicializa atributos con **valores por defecto**\n- Si no se define ningún constructor, el lenguaje lo **crea automáticamente**\n- Útil cuando los valores iniciales son predecibles\n\n**Ejemplo conceptual**:\n```\nClase: Persona\n\nConstructor por defecto:\nPersona() {\n    nombre = \"Desconocido\"\n    edad = 0\n    dirección = \"No especificada\"\n}\n```\n\n#### 2. Constructor con Parámetros\n**Definición**: Constructor que recibe parámetros para inicializar el objeto.\n\n**Características**:\n- Permite crear objetos con **estados iniciales específicos**\n- Los parámetros se usan para **inicializar atributos**\n- Proporciona **flexibilidad** en la creación de objetos\n\n**Ejemplo conceptual**:\n```\nClase: Coche\n\nConstructor con parámetros:\nCoche(marca, color, año) {\n    this.marca = marca\n    this.color = color\n    this.año = año\n    this.velocidad = 0\n}\n```\n\n#### 3. Constructor de Copia\n**Definición**: Constructor que crea un nuevo objeto copiando los atributos de otro objeto existente.\n\n**Características**:\n- Recibe como parámetro **otro objeto de la misma clase**\n- Copia los valores de los atributos del objeto original\n- Útil para crear **copias independientes** de objetos\n\n**Ejemplo conceptual**:\n```\nClase: Libro\n\nConstructor de copia:\nLibro(Libro original) {\n    this.título = original.título\n    this.autor = original.autor\n    this.páginas = original.páginas\n    this.ISBN = original.ISBN\n}\n```\n\n### Sobrecarga de Constructores\n\n#### Definición\nUna clase puede tener **múltiples constructores** con diferentes listas de parámetros.\n\n#### Ventajas\n- **Flexibilidad** en la creación de objetos\n- Diferentes formas de **inicializar** el objeto\n- **Compatibilidad** con diferentes escenarios de uso\n\n#### Ejemplo Conceptual\n```\nClase: Producto\n\nConstructores:\nProducto() {  // Sin parámetros\n    nombre = \"Producto sin nombre\"\n    precio = 0.0\n    cantidad = 0\n}\n\nProducto(nombre) {  // Solo nombre\n    this.nombre = nombre\n    precio = 0.0\n    cantidad = 0\n}\n\nProducto(nombre, precio) {  // Nombre y precio\n    this.nombre = nombre\n    this.precio = precio\n    cantidad = 0\n}\n\nProducto(nombre, precio, cantidad) {  // Todos los parámetros\n    this.nombre = nombre\n    this.precio = precio\n    this.cantidad = cantidad\n}\n```\n\n### Uso de Constructores\n\n#### Creación de Objetos\n```\n// Usando constructor por defecto\nPersona p1 = new Persona();\n\n// Usando constructor con parámetros\nPersona p2 = new Persona(\"Juan\", 25);\n\n// Usando constructor de copia\nPersona p3 = new Persona(p2);\n```\n\n#### Inicialización de Atributos\nLos constructores pueden:\n- Asignar **valores directos** a atributos\n- Realizar **cálculos** para determinar valores iniciales\n- Validar **parámetros** antes de asignarlos\n- Inicializar **objetos internos**\n\n### Importancia de los Constructores\n\n#### 1. Garantía de Estado Válido\n- Asegura que los objetos empiecen en un **estado coherente**\n- Previene objetos con **datos inconsistentes**\n\n#### 2. Encapsulamiento\n- Controla **cómo se inicializan** los objetos\n- Oculta **detalles de implementación** de la inicialización\n\n#### 3. Flexibilidad\n- Diferentes formas de **crear objetos** según las necesidades\n- Adaptabilidad a **diferentes contextos** de uso\n\n#### 4. Mantenibilidad\n- Centraliza la **lógica de inicialización**\n- Facilita **cambios** en el proceso de creación\n\n### Buenas Prácticas con Constructores\n- **Validar parámetros** antes de asignarlos\n- **Inicializar todos los atributos** importantes\n- **Mantener constructores simples** y enfocados en inicialización\n- **Documentar** el propósito de cada constructor\n- **Usar sobrecarga** cuando tenga sentido para la clase","title":"Constructores - Teoría"},{"children":[],"contentMd":"### Definición de Clases en VB.NET\n```vb\nPublic Class Persona\n    ' Atributos (variables miembro)\n    Private _nombre As String\n    Private _edad As Integer\n    \n    ' Propiedades (getters/setters)\n    Public Property Nombre As String\n        Get\n            Return _nombre\n        End Get\n        Set(value As String)\n            _nombre = value\n        End Set\n    End Property\n    \n    Public Property Edad As Integer\n        Get\n            Return _edad\n        End Get\n        Set(value As Integer)\n            If value \u003e= 0 Then\n                _edad = value\n            End If\n        End Set\n    End Property\n    \n    ' Constructor\n    Public Sub New(nombre As String, edad As Integer)\n        Me.Nombre = nombre\n        Me.Edad = edad\n    End Sub\n    \n    ' Métodos\n    Public Function Presentarse() As String\n        Return $\"Hola, me llamo {Nombre} y tengo {Edad} años\"\n    End Function\nEnd Class\n```\n\n### Uso de Objetos en VB.NET\n```vb\n' Creación de objetos\nDim persona1 As New Persona(\"Juan\", 25)\nDim persona2 As New Persona(\"María\", 30)\n\n' Acceso a propiedades y métodos\npersona1.Nombre = \"Carlos\"\nDim presentacion As String = persona1.Presentarse()\nMessageBox.Show(presentacion)\n```\n\n### Constructores en VB.NET\n```vb\n' Constructor por defecto\nPublic Sub New()\n    _nombre = \"Desconocido\"\n    _edad = 0\nEnd Sub\n\n' Constructor con parámetros\nPublic Sub New(nombre As String)\n    Me.New(nombre, 0) ' Llama a otro constructor\nEnd Sub\n\n' Constructor completo\nPublic Sub New(nombre As String, edad As Integer)\n    Me.Nombre = nombre\n    Me.Edad = edad\nEnd Sub\n```","title":"Clases y Objetos en VB.NET - Práctica"},{"children":[],"contentMd":"### Sintaxis Básica de Java\n```java\n// Clase básica en Java\npublic class Persona {\n    // Atributos privados (encapsulamiento)\n    private String nombre;\n    private int edad;\n    \n    // Constructor\n    public Persona(String nombre, int edad) {\n        this.nombre = nombre;\n        this.edad = edad;\n    }\n    \n    // Getters y Setters\n    public String getNombre() {\n        return nombre;\n    }\n    \n    public void setNombre(String nombre) {\n        this.nombre = nombre;\n    }\n    \n    public int getEdad() {\n        return edad;\n    }\n    \n    public void setEdad(int edad) {\n        if (edad \u003e= 0) {\n            this.edad = edad;\n        }\n    }\n    \n    // Método\n    public String presentarse() {\n        return \"Hola, me llamo \" + nombre + \" y tengo \" + edad + \" años\";\n    }\n}\n\n// Uso de la clase\npublic class Main {\n    public static void main(String[] args) {\n        Persona persona = new Persona(\"Juan\", 25);\n        System.out.println(persona.presentarse());\n    }\n}\n```\n\n### Diferencias con VB.NET\n- **Sintaxis**: Más verbosa pero explícita\n- **Paquetes**: Sistema de namespaces más estructurado\n- **Plataforma**: Ejecuta en JVM (Java Virtual Machine)\n- **Memoria**: Gestión automática de memoria (Garbage Collector)","title":"Clases y Objetos en Java - Práctica"},{"children":[],"contentMd":"### Sintaxis de POO en PHP\n```php\n\u003c?php\n// Clase en PHP\nclass Persona {\n    // Atributos\n    private $nombre;\n    private $edad;\n    \n    // Constructor\n    public function __construct($nombre, $edad) {\n        $this-\u003enombre = $nombre;\n        $this-\u003eedad = $edad;\n    }\n    \n    // Getters y Setters\n    public function getNombre() {\n        return $this-\u003enombre;\n    }\n    \n    public function setNombre($nombre) {\n        $this-\u003enombre = $nombre;\n    }\n    \n    public function getEdad() {\n        return $this-\u003eedad;\n    }\n    \n    public function setEdad($edad) {\n        if ($edad \u003e= 0) {\n            $this-\u003eedad = $edad;\n        }\n    }\n    \n    // Método\n    public function presentarse() {\n        return \"Hola, me llamo \" . $this-\u003enombre . \" y tengo \" . $this-\u003eedad . \" años\";\n    }\n}\n\n// Uso de la clase\n$persona = new Persona(\"Maria\", 30);\necho $persona-\u003epresentarse();\n?\u003e\n```\n\n### PHP para Web\n```php\n\u003c?php\n// Ejemplo de uso en web\nif ($_SERVER['REQUEST_METHOD'] === 'POST') {\n    $nombre = $_POST['nombre'];\n    $edad = $_POST['edad'];\n    \n    $persona = new Persona($nombre, $edad);\n    $mensaje = $persona-\u003epresentarse();\n    \n    echo \"\u003ch1\u003e$mensaje\u003c/h1\u003e\";\n}\n?\u003e\n\n\u003c!-- Formulario HTML --\u003e\n\u003cform method=\"POST\"\u003e\n    \u003cinput type=\"text\" name=\"nombre\" placeholder=\"Nombre\"\u003e\n    \u003cinput type=\"number\" name=\"edad\" placeholder=\"Edad\"\u003e\n    \u003cbutton type=\"submit\"\u003eEnviar\u003c/button\u003e\n\u003c/form\u003e\n```","title":"Clases y Objetos en PHP - Práctica"}],"shortDescription":"Conceptos fundamentales sobre clases, objetos, atributos, métodos, constructores y su implementación en diferentes lenguajes.","title":"Clases y Objetos - Fundamentos Teóricos y Prácticos"},{"children":[{"children":[],"contentMd":"### Definición de Encapsulamiento\nEl **encapsulamiento** es el principio de ocultar los detalles internos de implementación de un objeto y controlar el acceso a sus datos.\n\n### Concepto Fundamental\n\"Ocultar la información\" - Mostrar solo lo necesario y proteger lo interno.\n\n### Elementos del Encapsulamiento\n\n#### 1. Atributos Privados\n**Propósito**: Prevenir el acceso directo desde fuera de la clase.\n\n**Ventajas**:\n- **Protección** contra modificaciones incorrectas\n- **Control** sobre cómo se modifican los datos\n- **Flexibilidad** para cambiar la implementación interna\n\n**Ejemplo**:\n```\nClase: CuentaBancaria\nAtributos privados: _saldo, _númeroCuenta, _titular\n```\n\n#### 2. Métodos Públicos\n**Propósito**: Proporcionar una interfaz controlada para interactuar con el objeto.\n\n**Tipos**:\n- **Getters**: Métodos para leer atributos privados\n- **Setters**: Métodos para modificar atributos privados con validación\n- **Métodos de operación**: Realizan acciones con el objeto\n\n**Ejemplo**:\n```\nClase: CuentaBancaria\nMétodos públicos: Depositar(monto), Retirar(monto), ConsultarSaldo()\n```\n\n### Niveles de Acceso\n\n#### 1. Público (Public)\n**Acceso**: Desde cualquier clase.\n\n**Uso**:\n- Métodos que forman la **interfaz pública** de la clase\n- Propiedades que se quieren **accesibles directamente**\n\n#### 2. Privado (Private)\n**Acceso**: Solo desde la misma clase.\n\n**Uso**:\n- Atributos que deben estar **protegidos**\n- Métodos **internos** de la clase\n- Implementación que se quiere **ocultar**\n\n#### 3. Protegido (Protected)\n**Acceso**: Desde la misma clase y clases hijas.\n\n**Uso**:\n- Atributos y métodos para **compartir con subclases**\n- Implementación que las clases hijas pueden **extender o modificar**\n\n### Beneficios del Encapsulamiento\n\n#### 1. Protección de Datos\n- **Validación** de datos antes de asignarlos\n- **Consistencia** del estado del objeto\n- **Prevención** de estados inválidos\n\n#### 2. Flexibilidad y Mantenibilidad\n- **Cambios internos** sin afectar el código externo\n- **Evolución** de la implementación transparente\n- **Refactorización** más segura\n\n#### 3. Modularidad\n- **Clases autocontenidas** y independientes\n- **Interfaces claras** y bien definidas\n- **Acoplamiento reducido** entre clases\n\n### Ejemplo Completo de Encapsulamiento\n\n#### Clase Sin Encapsulamiento (Mala Práctica)\n```\nClase: Persona\nAtributos públicos: nombre, edad\n\nProblemas:\n- Cualquiera puede modificar la edad con valores inválidos\n- No hay control sobre los datos\n- Puede haber inconsistencia\n```\n\n#### Clase Con Encapsulamiento (Buena Práctica)\n```\nClase: Persona\nAtributos privados: _nombre, _edad\n\nPropiedades públicas:\n- Nombre: get (lectura), set (con validación de no vacío)\n- Edad: get (lectura), set (con validación de rango 0-150)\n\nMétodos públicos:\n- CumplirAños(): incrementa la edad con validación\n```\n\n### Técnicas de Implementación\n\n#### 1. Propiedades con Validación\n```\npublic int Edad {\n    get { return _edad; }\n    set {\n        if (value \u003e= 0 \u0026\u0026 value \u003c= 150) {\n            _edad = value;\n        } else {\n            throw new ArgumentException(\"Edad no válida\");\n        }\n    }\n}\n```\n\n#### 2. Métodos de Acceso Controlado\n```\npublic void Depositar(decimal monto) {\n    if (monto \u003e 0) {\n        _saldo += monto;\n    } else {\n        throw new ArgumentException(\"Monto debe ser positivo\");\n    }\n}\n```\n\n### Importancia en el Diseño de Software\n\n#### 1. Diseño Robusto\n- Objetos que se **autoprotegen**\n- Comportamiento **predecible**\n- Menos **errores en tiempo de ejecución**\n\n#### 2. Trabajo en Equipo\n- **Interfaces claras** entre módulos\n- **Responsabilidades bien definidas**\n- **Independencia** entre componentes\n\n#### 3. Pruebas y Depuración\n- **Localización más fácil** de errores\n- **Comportamiento consistente**\n- **Pruebas unitarias** más efectivas\n\n### Principio Relacionado: \"Tell, Don't Ask\"\nEn lugar de preguntar por el estado de un objeto y luego actuar, se le debe **decir al objeto qué hacer** y que él maneje su estado interno.\n\n**Ejemplo**:\n- **Mal**: `if (cuenta.Saldo \u003e monto) cuenta.Retirar(monto)`\n- **Bien**: `cuenta.Retirar(monto)` (la cuenta valida internamente)\n\nEl encapsulamiento es fundamental para crear software **confiable, mantenible y escalable**.","title":"Encapsulamiento - Teoría"},{"children":[],"contentMd":"### Definición de Herencia\nLa **herencia** es un mecanismo que permite que una clase (clase hija o subclase) herede atributos y métodos de otra clase (clase padre o superclase).\n\n### Concepto Fundamental\n\"Es-un\" - La clase hija ES-UN tipo de la clase padre.\n\n### Terminología de Herencia\n\n#### 1. Clase Padre (Superclase)\n- Clase que **proporciona** atributos y métodos\n- Define **características generales**\n- También llamada **clase base**\n\n#### 2. Clase Hija (Subclase)\n- Clase que **recibe** atributos y métodos\n- **Extiende o especializa** la clase padre\n- También llamada **clase derivada**\n\n### Beneficios de la Herencia\n\n#### 1. Reutilización de Código\n- **Evita duplicación** de código común\n- **Comparte funcionalidad** entre clases relacionadas\n- **Reduce** el tamaño del código\n\n#### 2. Jerarquía Lógica\n- **Organiza** clases en estructuras con sentido\n- **Modela** relaciones del mundo real\n- **Facilita** el entendimiento del sistema\n\n#### 3. Extensibilidad\n- **Añade funcionalidad** sin modificar código existente\n- **Crea especializaciones** de clases generales\n- **Adapta** el comportamiento según necesidades\n\n### Tipos de Herencia\n\n#### 1. Herencia Simple\n**Definición**: Una clase hija hereda de una sola clase padre.\n\n**Características**:\n- **Más común** en lenguajes como Java y C#\n- **Estructura simple** y clara\n- **Evita ambigüedades**\n\n**Ejemplo**:\n```\nClase Padre: Vehículo\nClase Hija: Coche (hereda de Vehículo)\n```\n\n#### 2. Herencia Múltiple\n**Definición**: Una clase hija hereda de múltiples clases padre.\n\n**Características**:\n- **Permitida** en algunos lenguajes como C++\n- **Puede crear ambigüedades** (problema del diamante)\n- **Más poderosa** pero más compleja\n\n### Ejemplos Conceptuales de Herencia\n\n#### Sistema de Vehículos\n```\nClase Padre: Vehículo\n├── Atributos: marca, modelo, velocidad\n├── Métodos: acelerar(), frenar()\n└──\n    ├── Clase Hija: Coche\n    │   ├── Atributos adicionales: númeroPuertas\n    │   └── Métodos adicionales: abrirMaletero()\n    │\n    ├── Clase Hija: Motocicleta\n    │   ├── Atributos adicionales: cilindrada\n    │   └── Métodos adicionales: hacerCaballito()\n    │\n    └── Clase Hija: Camión\n        ├── Atributos adicionales: capacidadCarga\n        └── Métodos adicionales: cargarMercancía()\n```\n\n#### Sistema de Empleados\n```\nClase Padre: Empleado\n├── Atributos: nombre, salario, fechaContratación\n├── Métodos: trabajar(), descansar()\n└──\n    ├── Clase Hija: Gerente\n    │   ├── Atributos adicionales: departamento\n    │   └── Métodos adicionales: gestionarEquipo()\n    │\n    ├── Clase Hija: Desarrollador\n    │   ├── Atributos adicionales: lenguajeProgramación\n    │   └── Métodos adicionales: programar()\n    │\n    └── Clase Hija: Diseñador\n        ├── Atributos adicionales: herramientaDiseño\n        └── Métodos adicionales: diseñar()\n```\n\n### Modificadores de Acceso en Herencia\n\n#### 1. Público (Public)\n- **Accesible** desde cualquier clase\n- Las subclases **heredan** miembros públicos\n\n#### 2. Protegido (Protected)\n- **Accesible** desde la misma clase y subclases\n- Diseñado específicamente para **herencia**\n\n#### 3. Privado (Private)\n- **No accesible** desde subclases\n- Las subclases **NO heredan** miembros privados\n\n### Sobrescritura de Métodos (Overriding)\n\n#### Definición\nLa capacidad de una clase hija de **redefinir** un método heredado de la clase padre.\n\n#### Propósito\n- **Especializar** el comportamiento para la subclase\n- **Adaptar** funcionalidad general a casos específicos\n- **Mejorar** o modificar el comportamiento heredado\n\n#### Ejemplo Conceptual\n```\nClase Padre: Animal\nMétodo: hacerSonido() → \"El animal hace un sonido\"\n\nClase Hija: Perro\nMétodo sobrescrito: hacerSonido() → \"¡Guau guau!\"\n\nClase Hija: Gato\nMétodo sobrescrito: hacerSonido() → \"¡Miau miau!\"\n```\n\n### Relación \"ES-UN\" vs \"TIENE-UN\"\n\n#### Herencia (ES-UN)\n```\nUn Coche ES-UN Vehículo\nUn Perro ES-UN Animal\nUn Gerente ES-UN Empleado\n```\n\n#### Composición (TIENE-UN)\n```\nUn Coche TIENE-UN Motor\nUna Persona TIENE-UN Dirección\nUna Universidad TIENE-UN Estudiantes\n```\n\n### Buenas Prácticas en Herencia\n\n#### 1. Diseño Jerárquico Coherente\n- **Relaciones lógicas** y con sentido\n- **Evitar herencia forzada** o artificial\n- **Usar composición** cuando no hay relación \"ES-UN\" clara\n\n#### 2. Especialización Progresiva\n- **Clases padre generales** y abstractas\n- **Clases hijas específicas** y concretas\n- **Jerarquías no demasiado profundas** (máximo 3-4 niveles)\n\n#### 3. Uso Correcto de Modificadores\n- **Atributos privados** para encapsulación\n- **Métodos protegidos** para compartir con subclases\n- **Métodos públicos** para la interfaz externa\n\n### Limitaciones y Consideraciones\n\n#### 1. Acoplamiento Fuerte\n- Las subclases **dependen** de la implementación del padre\n- **Cambios en el padre** pueden afectar a todas las hijas\n\n#### 2. Complejidad\n- **Jerarquías profundas** pueden ser difíciles de entender\n- **Múltiples niveles** de herencia pueden crear confusión\n\n#### 3. Alternativas\n- **Composición**: A menudo preferible sobre herencia\n- **Interfaces**: Para definir contratos sin implementación\n\nLa herencia es una herramienta poderosa cuando se usa correctamente, pero debe aplicarse con criterio y solo cuando exista una relación \"ES-UN\" genuina entre las clases.","title":"Herencia - Teoría"},{"children":[],"contentMd":"### Definición de Polimorfismo\nEl **polimorfismo** es la capacidad de objetos de diferentes clases de responder al mismo mensaje (método) de formas diferentes.\n\n### Concepto Fundamental\n\"Muchas formas\" - El mismo interfaz, diferentes implementaciones.\n\n### Tipos de Polimorfismo\n\n#### 1. Polimorfismo de Subtipo (Herencia)\n**Definición**: Objetos de diferentes subclases responden de forma diferente al mismo método definido en la superclase.\n\n**Características**:\n- Basado en **herencia**\n- Usa **sobrescritura de métodos** (overriding)\n- **En tiempo de ejecución** se decide qué método ejecutar\n\n#### 2. Polimorfismo Paramétrico (Genéricos)\n**Definición**: La misma función o clase puede trabajar con diferentes tipos de datos.\n\n**Características**:\n- **Independiente** del tipo de datos\n- **Reutilización** de código para múltiples tipos\n- **Type safety** en tiempo de compilación\n\n#### 3. Polimorfismo Ad hoc (Sobrecarga)\n**Definición**: Múltiples métodos con el mismo nombre pero diferentes parámetros.\n\n**Características**:\n- **Mismo nombre**, **diferentes firmas**\n- Decidido en **tiempo de compilación**\n- **Facilita** el uso de la clase\n\n### Polimorfismo con Herencia\n\n#### Sobrescritura de Métodos (Overriding)\n**Definición**: Una subclase proporciona una implementación específica de un método que ya está definido en su superclase.\n\n**Requisitos**:\n- **Mismo nombre** que el método del padre\n- **Misma firma** (parámetros y tipo de retorno)\n- **Relación de herencia** entre las clases\n\n**Ejemplo Conceptual**:\n```\nClase Padre: Figura\nMétodo: calcularArea() → Implementación genérica\n\nClase Hija: Círculo\nMétodo: calcularArea() → π * radio²\n\nClase Hija: Rectángulo\nMétodo: calcularArea() → base * altura\n\nClase Hija: Triángulo\nMétodo: calcularArea() → (base * altura) / 2\n```\n\n#### Enlace Dinámico (Dynamic Binding)\n**Definición**: La decisión de qué método ejecutar se toma en tiempo de ejecución, no en tiempo de compilación.\n\n**Ventajas**:\n- **Flexibilidad** en el comportamiento\n- **Extensibilidad** sin modificar código existente\n- **Adaptabilidad** a diferentes situaciones\n\n### Ejemplos Detallados de Polimorfismo\n\n#### Sistema de Animales\n```\nClase Abstracta: Animal\nMétodo Abstracto: hacerSonido()\n\nClases Concretas:\n- Perro: hacerSonido() → \"¡Guau guau!\"\n- Gato: hacerSonido() → \"¡Miau miau!\"\n- Vaca: hacerSonido() → \"¡Muu muu!\"\n- Pájaro: hacerSonido() → \"¡Pío pío!\"\n\nUso Polimórfico:\nAnimal[] animales = {new Perro(), new Gato(), new Vaca(), new Pájaro()};\n\nforeach (Animal animal in animales) {\n    animal.hacerSonido();  // Cada uno hace su sonido específico\n}\n```\n\n#### Sistema de Formas Geométricas\n```\nClase Abstracta: Forma\nMétodo Abstracto: dibujar()\nMétodo Abstracto: calcularArea()\n\nClases Concretas:\n- Círculo: \n  - dibujar() → Dibuja un círculo\n  - calcularArea() → π * radio²\n- Rectángulo:\n  - dibujar() → Dibuja un rectángulo\n  - calcularArea() → base * altura\n- Triángulo:\n  - dibujar() → Dibuja un triángulo\n  - calcularArea() → (base * altura) / 2\n\nUso Polimórfico:\nForma[] formas = {new Círculo(5), new Rectángulo(4, 6), new Triángulo(3, 4)};\n\nforeach (Forma forma in formas) {\n    forma.dibujar();\n    double area = forma.calcularArea();\n    Console.WriteLine($\"Área: {area}\");\n}\n```\n\n### Beneficios del Polimorfismo\n\n#### 1. Flexibilidad\n- **Mismo código** funciona con diferentes tipos de objetos\n- **Fácil añadir** nuevos tipos sin modificar código existente\n- **Adaptable** a cambios en requisitos\n\n#### 2. Mantenibilidad\n- **Código más simple** y legible\n- **Menos condicionales** (if-else, switch)\n- **Centralización** de lógica común\n\n#### 3. Extensibilidad\n- **Nuevas funcionalidades** sin romber código existente\n- **Plug-and-play** de nuevos componentes\n- **Sistema abierto** para extensiones\n\n#### 4. Reutilización\n- **Código genérico** que funciona con múltiples tipos\n- **Reducción** de duplicación\n- **Abstracción** de detalles específicos\n\n### Polimorfismo en Acción: Principio de Sustitución de Liskov\n\n#### Definición\n\"Los objetos de una superclase deben ser reemplazables por objetos de una subclase sin alterar el correcto funcionamiento del programa.\"\n\n#### Implicaciones\n- Las subclases deben **cumplir el contrato** de la superclase\n- No deben **debilitar precondiciones** ni **fortalecer postcondiciones**\n- Deben **mantener el comportamiento** esperado\n\n#### Ejemplo de Violación\n```\nClase Padre: Rectángulo\n- Métodos: setAncho(), setAlto()\n\nClase Hija: Cuadrado\n- Sobrescribe setAncho() para cambiar ancho y alto\n- Sobrescribe setAlto() para cambiar alto y ancho\n\nProblema: Un Cuadrado no se comporta como un Rectángulo esperado\n```\n\n### Técnicas de Implementación\n\n#### 1. Clases Abstractas\n- Definen **interfaz común** sin implementación completa\n- **Obligan** a las subclases a implementar métodos abstractos\n- **No se pueden instanciar** directamente\n\n#### 2. Interfaces\n- Definen **contratos** que las clases deben cumplir\n- **Múltiple herencia** de interfaces\n- **Total abstracción** sin implementación\n\n#### 3. Métodos Virtuales\n- Permiten **sobrescritura** en subclases\n- **Implementación por defecto** en la clase base\n- **Flexibilidad** para especialización\n\n### Polimorfismo vs Condicionales\n\n#### Enfoque sin Polimorfismo\n```\nif (animal is Perro) {\n    Console.WriteLine(\"¡Guau guau!\");\n} else if (animal is Gato) {\n    Console.WriteLine(\"¡Miau miau!\");\n} else if (animal is Vaca) {\n    Console.WriteLine(\"¡Muu muu!\");\n}\n```\n\n#### Enfoque con Polimorfismo\n```\nanimal.hacerSonido();  // Cada animal sabe cómo hacer su sonido\n```\n\n### Ventajas del Enfoque Polimórfico\n- **Menos código** condicional\n- **Más fácil de mantener** y extender\n- **Más natural** y orientado a objetos\n- **Menos propenso a errores** al añadir nuevos tipos\n\nEl polimorfismo es uno de los pilares más poderosos de la POO, permitiendo crear sistemas flexibles, extensibles y mantenibles que se adaptan fácilmente a nuevos requisitos.","title":"Polimorfismo - Teoría"},{"children":[],"contentMd":"### Implementación de Herencia\n```vb\n' Clase padre (base class)\nPublic Class Vehiculo\n    Public Property Marca As String\n    Public Property Modelo As String\n    Public Property VelocidadActual As Double\n    \n    Public Sub New(marca As String, modelo As String)\n        Me.Marca = marca\n        Me.Modelo = modelo\n        Me.VelocidadActual = 0\n    End Sub\n    \n    Public Overridable Sub Acelerar(incremento As Double)\n        VelocidadActual += incremento\n    End Sub\n    \n    Public Overridable Sub Frenar(decremento As Double)\n        VelocidadActual -= decremento\n        If VelocidadActual \u003c 0 Then VelocidadActual = 0\n    End Sub\nEnd Class\n\n' Clase hija que hereda de Vehiculo\nPublic Class Coche\n    Inherits Vehiculo\n    \n    Public Property NumeroPuertas As Integer\n    \n    Public Sub New(marca As String, modelo As String, puertas As Integer)\n        MyBase.New(marca, modelo) ' Llama al constructor del padre\n        Me.NumeroPuertas = puertas\n    End Sub\n    \n    ' Método específico de Coche\n    Public Sub AbrirMaletero()\n        MessageBox.Show(\"Maletero abierto\")\n    End Sub\nEnd Class\n\n' Otra clase hija\nPublic Class Motocicleta\n    Inherits Vehiculo\n    \n    Public Property Cilindrada As Integer\n    \n    Public Sub New(marca As String, modelo As String, cilindrada As Integer)\n        MyBase.New(marca, modelo)\n        Me.Cilindrada = cilindrada\n    End Sub\n    \n    ' Sobrescribir método del padre\n    Public Overrides Sub Acelerar(incremento As Double)\n        ' Las motos aceleran más rápido\n        VelocidadActual += incremento * 1.5\n    End Sub\nEnd Class\n```\n\n### Uso de la Herencia\n```vb\n' Crear objetos de las clases hijas\nDim miCoche As New Coche(\"Toyota\", \"Corolla\", 4)\nDim miMoto As New Motocicleta(\"Honda\", \"CBR\", 600)\n\n' Usar métodos heredados\nmiCoche.Acelerar(50)\nmiMoto.Acelerar(50)\n\n' Usar métodos específicos\nmiCoche.AbrirMaletero()\n\n' Polimorfismo: tratar diferentes objetos como Vehiculo\nDim vehiculos As New List(Of Vehiculo)\nvehiculos.Add(miCoche)\nvehiculos.Add(miMoto)\n\nFor Each vehiculo As Vehiculo In vehiculos\n    vehiculo.Acelerar(10) ' Cada uno acelera de forma diferente\nNext\n```\n\n### Palabras Clave en Herencia VB.NET\n- **`Inherits`**: Para indicar herencia\n- **`Overridable`**: Permite que un método sea sobrescrito\n- **`Overrides`**: Sobrescribe un método del padre\n- **`MyBase`**: Referencia a la clase padre\n- **`NotInheritable`**: Clase que no puede ser heredada\n- **`MustInherit`**: Clase abstracta que debe ser heredada","title":"Herencia en VB.NET - Práctica"},{"children":[],"contentMd":"### Polimorfismo con Métodos Virtuales\n```vb\nPublic Class Figura\n    Public Overridable Function CalcularArea() As Double\n        Return 0\n    End Function\n    \n    Public Overridable Function CalcularPerimetro() As Double\n        Return 0\n    End Function\nEnd Class\n\nPublic Class Circulo\n    Inherits Figura\n    \n    Public Property Radio As Double\n    \n    Public Sub New(radio As Double)\n        Me.Radio = radio\n    End Sub\n    \n    Public Overrides Function CalcularArea() As Double\n        Return Math.PI * Radio * Radio\n    End Function\n    \n    Public Overrides Function CalcularPerimetro() As Double\n        Return 2 * Math.PI * Radio\n    End Function\nEnd Class\n\nPublic Class Rectangulo\n    Inherits Figura\n    \n    Public Property Ancho As Double\n    Public Property Alto As Double\n    \n    Public Sub New(ancho As Double, alto As Double)\n        Me.Ancho = ancho\n        Me.Alto = alto\n    End Sub\n    \n    Public Overrides Function CalcularArea() As Double\n        Return Ancho * Alto\n    End Function\n    \n    Public Overrides Function CalcularPerimetro() As Double\n        Return 2 * (Ancho + Alto)\n    End Function\nEnd Class\n```\n\n### Uso del Polimorfismo\n```vb\n' Crear lista de Figuras (polimorfismo)\nDim figuras As New List(Of Figura)\nfiguras.Add(New Circulo(5))\nfiguras.Add(New Rectangulo(4, 6))\nfiguras.Add(New Circulo(3))\n\n' Calcular áreas - cada figura lo hace diferente\nFor Each figura As Figura In figuras\n    Dim area As Double = figura.CalcularArea()\n    Dim perimetro As Double = figura.CalcularPerimetro()\n    Console.WriteLine($\"Área: {area:F2}, Perímetro: {perimetro:F2}\")\nNext\n```\n\n### Clases Abstractas\n```vb\n' Clase abstracta (no se puede instanciar directamente)\nPublic MustInherit Class Animal\n    Public Property Nombre As String\n    \n    ' Método abstracto (debe ser implementado por las clases hijas)\n    Public MustOverride Function HacerSonido() As String\n    \n    ' Método concreto (ya implementado)\n    Public Function Dormir() As String\n        Return $\"{Nombre} está durmiendo...\"\n    End Function\nEnd Class\n\nPublic Class Perro\n    Inherits Animal\n    \n    Public Overrides Function HacerSonido() As String\n        Return \"¡Guau guau!\"\n    End Function\nEnd Class\n\nPublic Class Gato\n    Inherits Animal\n    \n    Public Overrides Function HacerSonido() As String\n        Return \"¡Miau miau!\"\n    End Function\nEnd Class\n```\n\n### Interfaces en VB.NET\n```vb\n' Definición de interfaz\nPublic Interface ICalculadora\n    Function Sumar(a As Double, b As Double) As Double\n    Function Restar(a As Double, b As Double) As Double\n    Function Multiplicar(a As Double, b As Double) As Double\n    Function Dividir(a As Double, b As Double) As Double\nEnd Interface\n\n' Implementación de interfaz\nPublic Class CalculadoraBasica\n    Implements ICalculadora\n    \n    Public Function Sumar(a As Double, b As Double) As Double Implements ICalculadora.Sumar\n        Return a + b\n    End Function\n    \n    Public Function Restar(a As Double, b As Double) As Double Implements ICalculadora.Restar\n        Return a - b\n    End Function\n    \n    Public Function Multiplicar(a As Double, b As Double) As Double Implements ICalculadora.Multiplicar\n        Return a * b\n    End Function\n    \n    Public Function Dividir(a As Double, b As Double) As Double Implements ICalculadora.Dividir\n        If b = 0 Then\n            Throw New DivideByZeroException(\"No se puede dividir por cero\")\n        End If\n        Return a / b\n    End Function\nEnd Class\n```","title":"Polimorfismo en VB.NET - Práctica"},{"children":[],"contentMd":"### Herencia en Java\n```java\n// Clase padre\npublic class Vehiculo {\n    protected String marca;\n    protected String modelo;\n    protected double velocidadActual;\n    \n    public Vehiculo(String marca, String modelo) {\n        this.marca = marca;\n        this.modelo = modelo;\n        this.velocidadActual = 0;\n    }\n    \n    public void acelerar(double incremento) {\n        this.velocidadActual += incremento;\n    }\n    \n    public void frenar(double decremento) {\n        this.velocidadActual -= decremento;\n        if (this.velocidadActual \u003c 0) {\n            this.velocidadActual = 0;\n        }\n    }\n}\n\n// Clase hija\npublic class Coche extends Vehiculo {\n    private int numeroPuertas;\n    \n    public Coche(String marca, String modelo, int numeroPuertas) {\n        super(marca, modelo); // Llamada al constructor del padre\n        this.numeroPuertas = numeroPuertas;\n    }\n    \n    // Método específico\n    public void abrirMaletero() {\n        System.out.println(\"Maletero abierto\");\n    }\n    \n    // Sobrescribir método\n    @Override\n    public void acelerar(double incremento) {\n        // Los coches aceleran de forma diferente\n        this.velocidadActual += incremento * 0.9;\n    }\n}\n```\n\n### Polimorfismo en Java\n```java\npublic class Main {\n    public static void main(String[] args) {\n        // Polimorfismo\n        Vehiculo[] vehiculos = new Vehiculo[2];\n        vehiculos[0] = new Coche(\"Toyota\", \"Corolla\", 4);\n        vehiculos[1] = new Motocicleta(\"Honda\", \"CBR\", 600);\n        \n        for (Vehiculo v : vehiculos) {\n            v.acelerar(50); // Cada uno acelera diferente\n        }\n    }\n}\n```\n\n### Clases Abstractas en Java\n```java\npublic abstract class Animal {\n    protected String nombre;\n    \n    // Método abstracto\n    public abstract String hacerSonido();\n    \n    // Método concreto\n    public String dormir() {\n        return nombre + \" está durmiendo...\";\n    }\n}\n\npublic class Perro extends Animal {\n    @Override\n    public String hacerSonido() {\n        return \"¡Guau guau!\";\n    }\n}\n```","title":"Herencia y Polimorfismo en Java - Práctica"},{"children":[],"contentMd":"### Herencia en PHP\n```php\n\u003c?php\nclass Vehiculo {\n    protected $marca;\n    protected $modelo;\n    \n    public function __construct($marca, $modelo) {\n        $this-\u003emarca = $marca;\n        $this-\u003emodelo = $modelo;\n    }\n    \n    public function getInfo() {\n        return $this-\u003emarca . \" \" . $this-\u003emodelo;\n    }\n}\n\nclass Coche extends Vehiculo {\n    private $puertas;\n    \n    public function __construct($marca, $modelo, $puertas) {\n        parent::__construct($marca, $modelo);\n        $this-\u003epuertas = $puertas;\n    }\n    \n    public function getInfo() {\n        return parent::getInfo() . \" - \" . $this-\u003epuertas . \" puertas\";\n    }\n}\n\n$miCoche = new Coche(\"Toyota\", \"Corolla\", 4);\necho $miCoche-\u003egetInfo(); // Output: Toyota Corolla - 4 puertas\n?\u003e\n```","title":"Herencia en PHP - Práctica"}],"shortDescription":"Los cuatro pilares principales de la POO: encapsulamiento, herencia, polimorfismo y abstracción con implementación práctica.","title":"Pilares Fundamentales de la POO"},{"children":[{"children":[],"contentMd":"### ¿Qué es Visual Basic .NET?\n**Visual Basic .NET** es un lenguaje de programación orientado a objetos desarrollado por Microsoft, especialmente popular para desarrollar aplicaciones Windows rápidamente.\n\n### Windows Forms\n**Windows Forms** es un framework para crear aplicaciones de escritorio Windows con interfaces gráficas ricas.\n\n### Características de VB.NET\n- **Sintaxis sencilla**: Fácil de aprender y leer\n- **RAD (Rapid Application Development)**: Desarrollo rápido de aplicaciones\n- **Integración con .NET**: Acceso a todas las bibliotecas .NET\n- **Drag \u0026 Drop**: Creación visual de interfaces\n\n### Estructura de un Proyecto VB.NET\n```\nMiProyecto.vbproj\n├── Form1.vb (Formulario principal)\n├── Form1.Designer.vb (Código auto-generado)\n├── Module1.vb (Módulos opcionales)\n└── Classes/ (Carpeta para clases personalizadas)\n```\n\n### Primer Formulario en VB.NET\n```vb\nPublic Class Form1\n    Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click\n        MessageBox.Show(\"Hola Mundo desde VB.NET!\")\n    End Sub\nEnd Class\n```","title":"Introducción a Visual Basic y Windows Forms"},{"children":[],"contentMd":"### Diseño de la Calculadora con POO\nVamos a crear una calculadora que use herencia y polimorfismo en VB.NET con Windows Forms.\n\n### Arquitectura de Clases\n```vb\n' Clase base abstracta para operaciones\nPublic MustInherit Class Operacion\n    Public MustOverride ReadOnly Property Nombre As String\n    Public MustOverride Function Calcular(numeros As List(Of Double)) As Double\nEnd Class\n\n' Operación de Suma\nPublic Class SumaOperacion\n    Inherits Operacion\n    \n    Public Overrides ReadOnly Property Nombre As String\n        Get\n            Return \"Suma Total\"\n        End Get\n    End Property\n    \n    Public Overrides Function Calcular(numeros As List(Of Double)) As Double\n        If numeros Is Nothing OrElse numeros.Count = 0 Then\n            Return 0\n        End If\n        Return numeros.Sum()\n    End Function\nEnd Class\n\n' Operación de Promedio\nPublic Class PromedioOperacion\n    Inherits Operacion\n    \n    Public Overrides ReadOnly Property Nombre As String\n        Get\n            Return \"Promedio\"\n        End Get\n    End Property\n    \n    Public Overrides Function Calcular(numeros As List(Of Double)) As Double\n        If numeros Is Nothing OrElse numeros.Count = 0 Then\n            Return 0\n        End If\n        Return numeros.Average()\n    End Function\nEnd Class\n\n' Operación de Máximo\nPublic Class MaximoOperacion\n    Inherits Operacion\n    \n    Public Overrides ReadOnly Property Nombre As String\n        Get\n            Return \"Valor Máximo\"\n        End Get\n    End Property\n    \n    Public Overrides Function Calcular(numeros As List(Of Double)) As Double\n        If numeros Is Nothing OrElse numeros.Count = 0 Then\n            Return 0\n        End If\n        Return numeros.Max()\n    End Function\nEnd Class\n\n' Operación de Mínimo\nPublic Class MinimoOperacion\n    Inherits Operacion\n    \n    Public Overrides ReadOnly Property Nombre As String\n        Get\n            Return \"Valor Mínimo\"\n        End Get\n    End Property\n    \n    Public Overrides Function Calcular(numeros As List(Of Double)) As Double\n        If numeros Is Nothing OrElse numeros.Count = 0 Then\n            Return 0\n        End If\n        Return numeros.Min()\n    End Function\nEnd Class\n\n' Operación de Producto\nPublic Class ProductoOperacion\n    Inherits Operacion\n    \n    Public Overrides ReadOnly Property Nombre As String\n        Get\n            Return \"Producto Total\"\n        End Get\n    End Property\n    \n    Public Overrides Function Calcular(numeros As List(Of Double)) As Double\n        If numeros Is Nothing OrElse numeros.Count = 0 Then\n            Return 0\n        End If\n        Dim producto As Double = 1\n        For Each num As Double In numeros\n            producto *= num\n        Next\n        Return producto\n    End Function\nEnd Class\n```\n\n### Formulario Principal (Interfaz Gráfica)\n```vb\nPublic Class FormCalculadora\n    ' Controles del formulario (agregados desde el diseñador)\n    Private txtValor1, txtValor2, txtValor3, txtValor4, txtValor5 As TextBox\n    Private txtValor6, txtValor7, txtValor8, txtValor9, txtValor10 As TextBox\n    Private btnCalcular As Button\n    Private lblResultados As Label\n    \n    ' Lista de operaciones (polimorfismo)\n    Private operaciones As List(Of Operacion)\n    \n    Private Sub FormCalculadora_Load(sender As Object, e As EventArgs) Handles MyBase.Load\n        InicializarOperaciones()\n    End Sub\n    \n    Private Sub InicializarOperaciones()\n        operaciones = New List(Of Operacion) From {\n            New SumaOperacion(),\n            New PromedioOperacion(),\n            New MaximoOperacion(),\n            New MinimoOperacion(),\n            New ProductoOperacion()\n        }\n    End Sub\n    \n    Private Sub btnCalcular_Click(sender As Object, e As EventArgs) Handles btnCalcular.Click\n        Try\n            Dim numeros As List(Of Double) = ObtenerNumeros()\n            \n            If numeros.Count \u003c\u003e 10 Then\n                MessageBox.Show(\"Debe ingresar exactamente 10 valores numéricos válidos\", \"Error\", MessageBoxButtons.OK, MessageBoxIcon.Error)\n                Return\n            End If\n            \n            Dim resultados As New StringBuilder()\n            resultados.AppendLine(\"RESULTADOS:\")\n            resultados.AppendLine(\"================\")\n            \n            ' Polimorfismo: misma interfaz, diferentes comportamientos\n            For Each operacion As Operacion In operaciones\n                Dim resultado As Double = operacion.Calcular(numeros)\n                resultados.AppendLine($\"{operacion.Nombre}: {resultado:F2}\")\n            Next\n            \n            lblResultados.Text = resultados.ToString()\n            \n        Catch ex As Exception\n            MessageBox.Show($\"Error al calcular: {ex.Message}\", \"Error\", MessageBoxButtons.OK, MessageBoxIcon.Error)\n        End Try\n    End Sub\n    \n    Private Function ObtenerNumeros() As List(Of Double)\n        Dim numeros As New List(Of Double)()\n        Dim textBoxes As TextBox() = {txtValor1, txtValor2, txtValor3, txtValor4, txtValor5,\n                                     txtValor6, txtValor7, txtValor8, txtValor9, txtValor10}\n        \n        For Each txt As TextBox In textBoxes\n            If Double.TryParse(txt.Text, Nothing) Then\n                numeros.Add(CDbl(txt.Text))\n            End If\n        Next\n        \n        Return numeros\n    End Function\nEnd Class\n```\n\n### Diseño del Formulario en el Diseñador\n1. **Agregar 10 TextBox** (txtValor1 a txtValor10)\n2. **Agregar un Button** (btnCalcular) con texto \"Calcular Operaciones\"\n3. **Agregar un Label** (lblResultados) multilínea para mostrar resultados\n4. **Organizar** los controles en un layout ordenado\n\n### Características del Proyecto\n- **Herencia**: Todas las operaciones heredan de `Operacion`\n- **Polimorfismo**: Se tratan todas las operaciones como `Operacion`\n- **Encapsulamiento**: Cada operación encapsula su lógica interna\n- **Interfaz gráfica**: Windows Forms para interacción con el usuario\n\n### Ejemplo de Salida\n```\nRESULTADOS:\n================\nSuma Total: 598.00\nPromedio: 59.80\nValor Máximo: 432.00\nValor Mínimo: 1.00\nProducto Total: 1924896669696.00\n```","title":"Windows Forms con POO - Calculadora"}],"shortDescription":"Implementación completa de POO con interfaces gráficas usando Visual Basic y Windows Forms.","title":"POO en Visual Basic con Windows Forms"},{"children":[{"children":[],"contentMd":"### C# vs VB.NET\nMismos conceptos de .NET, diferente sintaxis:\n\n```csharp\n// Clase en C#\npublic class Persona\n{\n    private string _nombre;\n    private int _edad;\n    \n    public Persona(string nombre, int edad)\n    {\n        _nombre = nombre;\n        _edad = edad;\n    }\n    \n    public string Nombre\n    {\n        get { return _nombre; }\n        set { _nombre = value; }\n    }\n    \n    public int Edad\n    {\n        get { return _edad; }\n        set \n        { \n            if (value \u003e= 0)\n                _edad = value;\n        }\n    }\n    \n    public string Presentarse()\n    {\n        return $\"Hola, me llamo {Nombre} y tengo {Edad} años\";\n    }\n}\n```\n\n### .NET MAUI con POO\n```csharp\n// En MainPage.xaml.cs\npublic partial class MainPage : ContentPage\n{\n    private List\u003cOperacion\u003e _operaciones;\n    \n    public MainPage()\n    {\n        InitializeComponent();\n        InicializarOperaciones();\n    }\n    \n    private void InicializarOperaciones()\n    {\n        _operaciones = new List\u003cOperacion\u003e\n        {\n            new SumaOperacion(),\n            new PromedioOperacion(),\n            new MaximoOperacion(),\n            new MinimoOperacion(),\n            new ProductoOperacion()\n        };\n    }\n    \n    private void OnCalculateClicked(object sender, EventArgs e)\n    {\n        // Lógica similar a VB.NET pero en C#\n    }\n}\n```\n\n### Ventajas de .NET MAUI\n- **Un solo código** para múltiples plataformas\n- **Rendimiento nativo**\n- **Acceso a APIs nativas**\n- **Hot Reload** para desarrollo rápido","title":"POO en C# con .NET MAUI"}],"shortDescription":"Desarrollo de aplicaciones multiplataforma con .NET MAUI usando C# y principios de POO.","title":".NET MAUI con C# - Desarrollo Multiplataforma"},{"children":[{"children":[],"contentMd":"### Misma Lógica, Diferentes Sintaxis\n\n#### VB.NET (Windows Forms)\n```vb\nPublic MustInherit Class Operacion\n    Public MustOverride ReadOnly Property Nombre As String\n    Public MustOverride Function Calcular(numeros As List(Of Double)) As Double\nEnd Class\n```\n\n#### Java\n```java\npublic abstract class Operacion {\n    public abstract String getNombre();\n    public abstract double calcular(List\u003cDouble\u003e numeros);\n}\n```\n\n#### PHP\n```php\nabstract class Operacion {\n    abstract public function getNombre();\n    abstract public function calcular($numeros);\n}\n```\n\n#### C# (.NET MAUI)\n```csharp\npublic abstract class Operacion\n{\n    public abstract string Nombre { get; }\n    public abstract double Calcular(List\u003cdouble\u003e numeros);\n}\n```\n\n### Ventajas de Cada Lenguaje\n\n#### Visual Basic .NET\n- **Fácil aprendizaje** para principiantes\n- **Rápido desarrollo** con Windows Forms\n- **Excelente para aplicaciones Windows** empresariales\n\n#### Java\n- **Multiplataforma** real (Write Once, Run Anywhere)\n- **Gran ecosistema** y comunidad\n- **Ideal para aplicaciones empresariales** grandes\n\n#### PHP\n- **Especializado en web**\n- **Fácil despliegue** en servidores web\n- **Amplia adopción** en hosting compartido\n\n#### C# .NET MAUI\n- **Moderno y potente**\n- **Multiplataforma** (móvil y desktop)\n- **Integración con Microsoft** ecosystem\n\n### Elección del Lenguaje\n- **Aplicaciones Windows rápidas**: VB.NET\n- **Aplicaciones empresariales multiplataforma**: Java\n- **Aplicaciones web**: PHP\n- **Aplicaciones móviles/modernas**: C# .NET MAUI\n\n### Principios POO Universales\nIndependientemente del lenguaje, los principios de POO se mantienen:\n1. **Encapsulamiento**: Ocultar detalles internos\n2. **Herencia**: Reutilizar y extender funcionalidad\n3. **Polimorfismo**: Mismo interfaz, diferentes implementaciones\n4. **Abstracción**: Definir contratos y comportamientos esperados","title":"Comparativa entre Lenguajes"},{"children":[],"contentMd":"### Proyecto Final: Calculadora POO en VB.NET\n\n#### Estructura Completa del Proyecto\n```vb\n' 1. Clase Base Abstracta\nPublic MustInherit Class Operacion\n    Public MustOverride ReadOnly Property Nombre As String\n    Public MustOverride Function Calcular(numeros As List(Of Double)) As Double\nEnd Class\n\n' 2. Operaciones Concretas\nPublic Class SumaOperacion\n    Inherits Operacion\n    \n    Public Overrides ReadOnly Property Nombre As String\n        Get\n            Return \"Suma Total\"\n        End Get\n    End Property\n    \n    Public Overrides Function Calcular(numeros As List(Of Double)) As Double\n        If numeros Is Nothing OrElse numeros.Count = 0 Then Return 0\n        Return numeros.Sum()\n    End Function\nEnd Class\n\nPublic Class PromedioOperacion\n    Inherits Operacion\n    \n    Public Overrides ReadOnly Property Nombre As String\n        Get\n            Return \"Promedio\"\n        End Get\n    End Property\n    \n    Public Overrides Function Calcular(numeros As List(Of Double)) As Double\n        If numeros Is Nothing OrElse numeros.Count = 0 Then Return 0\n        Return numeros.Average()\n    End Function\nEnd Class\n\n' ... (MaximoOperacion, MinimoOperacion, ProductoOperacion)\n\n' 3. Formulario Principal\nPublic Class FormCalculadora\n    Private operaciones As List(Of Operacion)\n    \n    Private Sub FormCalculadora_Load(sender As Object, e As EventArgs) Handles MyBase.Load\n        InicializarOperaciones()\n    End Sub\n    \n    Private Sub InicializarOperaciones()\n        operaciones = New List(Of Operacion) From {\n            New SumaOperacion(),\n            New PromedioOperacion(),\n            New MaximoOperacion(),\n            New MinimoOperacion(),\n            New ProductoOperacion()\n        }\n    End Sub\n    \n    Private Sub btnCalcular_Click(sender As Object, e As EventArgs) Handles btnCalcular.Click\n        Try\n            Dim numeros As List(Of Double) = ObtenerNumeros()\n            \n            If numeros.Count \u003c\u003e 10 Then\n                MessageBox.Show(\"Se requieren 10 valores numéricos\")\n                Return\n            End If\n            \n            MostrarResultados(numeros)\n            \n        Catch ex As Exception\n            MessageBox.Show($\"Error: {ex.Message}\")\n        End Try\n    End Sub\n    \n    Private Function ObtenerNumeros() As List(Of Double)\n        Dim numeros As New List(Of Double)\n        Dim controles As Control() = {txt1, txt2, txt3, txt4, txt5, txt6, txt7, txt8, txt9, txt10}\n        \n        For Each ctrl As Control In controles\n            If TypeOf ctrl Is TextBox Then\n                Dim txt As TextBox = DirectCast(ctrl, TextBox)\n                If Double.TryParse(txt.Text, Nothing) Then\n                    numeros.Add(CDbl(txt.Text))\n                End If\n            End If\n        Next\n        \n        Return numeros\n    End Function\n    \n    Private Sub MostrarResultados(numeros As List(Of Double))\n        Dim sb As New StringBuilder()\n        sb.AppendLine(\"=== RESULTADOS ===\")\n        \n        ' Polimorfismo en acción\n        For Each op As Operacion In operaciones\n            Dim resultado As Double = op.Calcular(numeros)\n            sb.AppendLine($\"{op.Nombre}: {resultado:F2}\")\n        Next\n        \n        txtResultados.Text = sb.ToString()\n    End Sub\nEnd Class\n```\n\n### Características Destacadas\n\n#### 1. Herencia Demostrada\n- Todas las operaciones heredan de `Operacion`\n- Comparten la misma interfaz pero diferente implementación\n\n#### 2. Polimorfismo Aplicado\n- Se trata a todas las operaciones como `Operacion`\n- El mismo método `Calcular()` produce resultados diferentes\n\n#### 3. Encapsulamiento\n- Cada operación encapsula su lógica interna\n- El formulario solo necesita conocer la interfaz común\n\n#### 4. Windows Forms\n- Interfaz gráfica intuitiva\n- Validación de entrada\n- Manejo de errores\n- Presentación formateada de resultados\n\n### Ejecución del Proyecto\n1. **Abrir Visual Studio** y crear nuevo proyecto \"Windows Forms App (.NET Framework)\"\n2. **Agregar las clases** de operaciones\n3. **Diseñar el formulario** con 10 TextBox y un botón\n4. **Conectar los eventos** con la lógica de negocio\n5. **Probar** con diferentes conjuntos de datos\n\n### Resultado Esperado\n```\n=== RESULTADOS ===\nSuma Total: 55.00\nPromedio: 5.50\nValor Máximo: 10.00\nValor Mínimo: 1.00\nProducto Total: 3628800.00\n```\n\n### Competencias Desarrolladas\n- **Diseño de clases** con principios POO\n- **Implementación de herencia** y polimorfismo\n- **Creación de interfaces gráficas** con Windows Forms\n- **Manejo de excepciones** y validación\n- **Aplicación práctica** de conceptos teóricos","title":"Implementación Completa en VB.NET - Proyecto Final"}],"shortDescription":"Implementación de la misma calculadora POO en Visual Basic, Java, PHP y .NET MAUI con comparativa entre lenguajes.","title":"Proyecto Integrador Multiplataforma"}],"name":"Programación Orientada a Objetos - Teoría y Práctica Multiplataforma","schemaVersion":2,"version":"2.0"}