Principios de la Programación Orientada a Objetos (POO)

Y 7 flashcards y 14 preguntas más en el documento.

Texto del documento

Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 1 UT3. Principios de la programación orientada a objetos Programación Curso académico 2025/2026 - Edición Online - Rev.2025071101 DAM-DAW Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

2 Índice Ficha de la Unidad de Trabajo......................................................................................3 Índice de la unidad de trabajo.......................................................................................3 Tema 1: Introducción a la programación orientada a objetos........................................4 Ejemplo simple para ilustrar los principios: ...................................................................6 Tema 2: Clases y objetos predefinidos .........................................................................6 Tema 3: Métodos y propiedades.................................................................................11 Tema 4: Llamadas a métodos estáticos y uso de parámetros.....................................16 Tema 5: Modificadores de acceso y encapsulamiento................................................21 Tema 6: Herencia en la Programación Orientada a Objetos .......................................24 ¿Qué has aprendido?

.................................................................................................30 Fuentes de información ..............................................................................................31 Glosario ......................................................................................................................32 Actividades de evaluación ..........................................................................................34 Actividad 1: Creación de una jerarquía de clases .......................................................34 Actividad 2: Desarrollo de una aplicación que simule un sistema de inventario ..........36 Tabla de relación entre contenidos y criterios de evaluación (CE) ..............................38 Rúbrica de evaluación ................................................................................................40 Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

3 Ficha de la Unidad de Trabajo Unidad de Trabajo (UT) 3: Principios de la programación orientada a objetos Horas estimadas: 25 horas RAs trabajados:RA2 CEs trabajados:RA2CEa, RA2CEb, RA2CEc, RA2CEd, RA2CEe, RA2CEf, RA2CEg, RA2CEh, RA2CEi. Índice de la unidad de trabajo 1. Introducción a la programación orientada a objetos. 1.1. Evolución desde la programación estructurada. 1.2. Ventajas del paradigma orientado a objetos. 1.3. Principios fundamentales de la POO. 2. Clases y objetos predefinidos. 2.1. Concepto de clase y objeto. 2.2. Relación entre clases y objetos. 2.3. Uso de clases predefinidas del lenguaje. 3. Métodos y propiedades. 3.1. Atributos y encapsulamiento. 3.2.

Métodos: definición y uso. 4. Constructores. 4.1. Qué es un constructor. 4.2. Reglas de los constructores en Java. 4.3. Sobrecarga de constructores. 5. Llamadas a métodos. 5.1. Métodos simples. 5.2 Métodos con retorno. 6. Uso de parámetros y paso de argumentos. 6.1. Paso por valor. 6.2. Paso de objetos. 6.3. Parámetros variables. 7. Uso de librerías de objetos. 7.1. Qué son las librerías. 7.2. Importación de librerías estándar. 7.3. Uso de clases contenidas en librerías. 8. Compilación y prueba desde un entorno IDE. 8.1. Preparación del entorno de desarrollo. 8.2. Creación de proyectos con clases. 8.3. Prueba y depuración de clases y métodos.

Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 4 Tema 1: Introducción a la programación orientada a objetos. 1.1. Evolución desde la programación estructurada La programación orientada a objetos (POO) surge como una evolución natural del paradigma estructurado, que se basa en la división de un programa en funciones o procedimientos, con un flujo de ejecución claramente definido.

Este modelo funcionó bien para programas pequeños o de tamaño moderado, pero a medida que los sistemas informáticos se volvieron más complejos, se hizo evidente que la programación estructurada presentaba serias limitaciones para la escalabilidad, el mantenimiento y la reutilización del código. La programación estructurada tiende a mezclar los datos con el código que los manipula, lo que genera una alta dependencia entre ambos. Este acoplamiento puede dificultar la modificación del software, ya que un pequeño cambio en la estructura de los datos puede requerir modificaciones en múltiples puntos del programa.

En contraste, la POO propone una organización del software centrada en objetos que combinan estado (datos) y comportamiento (métodos). Esto permite encapsular el funcionamiento interno de los elementos, mejorando su reutilización y facilitando el mantenimiento. 1.2. Ventajas del paradigma orientado a objetos Entre las ventajas más destacadas del uso de la POO se encuentran: Modularidad: cada clase puede desarrollarse de forma independiente y reutilizarse en diferentes contextos. Encapsulamiento: los detalles internos de cada clase están protegidos del exterior, evitando efectos colaterales indeseados y facilitando la depuración.

Reutilización: gracias al uso de herencia y composición, se pueden crear nuevas clases a partir de otras existentes, aprovechando el código ya desarrollado. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 5 Mantenibilidad: el código orientado a objetos es más fácil de mantener y ampliar, ya que cada clase tiene una responsabilidad clara y acotada. Escalabilidad: este paradigma se adapta muy bien a sistemas grandes y complejos. Naturalidad del modelo: Facilita la representación de elementos del mundo real dentro del programa, mejorando la comprensión del sistema.

Estas ventajas son especialmente valiosas en entornos profesionales donde se requiere desarrollar aplicaciones robustas, seguras y con posibilidad de evolución constante. 1.3. Principios fundamentales de la POO La programación orientada a objetos se basa en una serie de principios que definen su estructura y funcionamiento: Abstracción: consiste en identificar las características esenciales de un objeto del mundo real y omitir los detalles irrelevantes. Por ejemplo, una clase Libro puede tener como atributos el título, el autor y el ISBN, ignorando otras características como el tipo de papel o el color de la portada si no son relevantes para el programa.

Encapsulamiento: Consiste en ocultar los detalles internos de implementación de un objeto, de forma que sólo se puede acceder a su estado mediante métodos públicos controlados. Esto favorece el uso seguro de los objetos y previene errores derivados de accesos indebidos. Herencia: permite crear nuevas clases basadas en otras ya existentes, reutilizando atributos y comportamientos comunes. Una clase Empleado puede ser la superclase de Gerente o Operario, que heredarán sus características y podrán añadir las propias. Polimorfismo: Significa que un mismo método puede comportarse de manera diferente según el objeto que lo invoque.

Permite definir interfaces genéricas y comportamientos concretos según la clase que los implemente. Esto facilita la flexibilidad del código y la implementación de soluciones genéricas. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

6 Ejemplo simple para ilustrar los principios: // Abstracción y Encapsulamiento public class Coche { private String marca; private int velocidad; public Coche(String marca) { this.marca = marca; this.velocidad = 0; } public void acelerar() { velocidad += 10; } public int getVelocidad() { return velocidad; } } Tema 2: Clases y objetos predefinidos En la Programación Orientada a Objetos (POO), los dos componentes más fundamentales son las clases y los objetos. Estos conceptos son la base sobre la cual se construye toda la estructura del software orientado a objetos.

Las clases actúan como plantillas o planos, mientras que los objetos son las instancias reales de esas clases, cada uno con sus propios valores y comportamientos. 2.1 Definición de una clase y objeto Una clase es una estructura que define el comportamiento y las propiedades comunes de los objetos que serán instanciados a partir de ella. En términos sencillos, la clase es como una receta para crear objetos. Cada objeto creado a partir de una clase puede tener valores diferentes en sus atributos, pero todos los objetos comparten la misma estructura definida en la clase.

Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 7 Una clase puede contener: 1. Atributos o propiedades: Representan los datos o características del objeto. 2. Métodos: Son las funciones que definen el comportamiento del objeto. 3. Constructores: Son métodos especiales utilizados para inicializar un objeto cuando se crea una instancia de la clase. Un objeto es una instancia concreta de una clase. Si Coche es la clase, entonces miCoche es un objeto específico con atributos propios (por ejemplo, color rojo y velocidad 60 km/h) que puede ejecutar acciones (como acelerar o frenar).

Por lo tanto, debemos saber que: Una clase es una plantilla o definición abstracta que agrupa atributos (propiedades) y métodos (comportamientos) comunes a un conjunto de entidades. Un objeto es una instancia concreta de una clase, con valores específicos para sus atributos y la capacidad de ejecutar sus métodos.

Sintaxis básica de una clase en Java: class Persona { // Atributos String nombre; int edad; // Constructor Persona(String nombre, int edad) { this.nombre = nombre; this.edad = edad; } // Método void saludar() { System.out.println("Hola, mi nombre es " + nombre + " y tengo " + edad + " años."); } } Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 8 En este ejemplo: La clase Persona tiene dos atributos (nombre y edad). El constructor se utiliza para inicializar estos atributos cuando se crea un nuevo objeto. El método saludar() imprime un saludo que incluye el nombre y la edad de la persona.

Creación de un objeto: public class Main { public static void main(String[] args) { // Crear un objeto de la clase Persona Persona persona1 = new Persona("Juan", 30); // Llamar al método de la clase persona1.saludar(); // Salida: Hola, mi nombre es Juan y tengo 30 años. } } En este ejemplo: Se crea un objeto persona1 de la clase Persona. Al crear el objeto, se pasan los parámetros "Juan" y 30 al constructor de la clase, inicializando los atributos de ese objeto. El método saludar() es llamado en el objeto persona1, y se ejecuta el comportamiento definido en la clase.

Cada vez que se crea un nuevo objeto de la clase Persona, se puede inicializar con valores diferentes para nombre y edad, pero todos los objetos de la misma clase tendrán la misma estructura de atributos y métodos. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

9 2.2 Relación entre clases y objetos Esta relación es fundamental para comprender el funcionamiento del lenguaje orientado a objetos: Elemento Descripción Clase Define la estructura de datos y las operaciones posibles Objeto Es una entidad creada a partir de una clase Atributos Variables que almacenan el estado del objeto Métodos Acciones que puede realizar el objeto Cada vez que se utiliza la palabra clave new, se está creando un objeto nuevo que ocupa su propio espacio en la memoria y mantiene su propio estado, independiente de otros objetos. La relación entre clases y objetos puede resumirse en: La clase define la estructura de los objetos (atributos y métodos).

Los objetos son instancias concretas de una clase, con sus propios valores para cada atributo. Varias instancias de una misma clase pueden existir al mismo tiempo, cada una con su estado independiente. El proceso de creación de un objeto se denomina instanciación, y se realiza en Java mediante el operador new. 2.3 Uso de clases predefinidas del lenguaje El lenguaje Java proporciona una amplia gama de clases predefinidas, organizadas en paquetes o librerías estándar. Estas clases ya han sido desarrolladas y probadas por Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

10 los responsables del lenguaje, por lo que son seguras, eficientes y recomendadas para tareas comunes.

Algunas de las clases más utilizadas son: Clase Uso principal Paquete String Manejo de cadenas de texto java.lang Scanner Entrada de datos por teclado java.util ArrayList Colecciones dinámicas de elementos java.util Math Operaciones matemáticas java.lang LocalDate Gestión de fechas actuales java.time jemplo con String: String mensaje = "Hola Mundo"; System.out.println("Longitud: " + mensaje.length()); System.out.println("En mayúsculas: " + mensaje.toUpperCase()); Ejemplo con Scanner: import java.util.Scanner; Scanner entrada = new Scanner(System.in); System.out.print("Introduce tu nombre: "); String nombre = entrada.nextLine(); System.out.println("Hola, " + nombre); Ejemplo con ArrayList: import java.util.ArrayList; ArrayList<String> frutas = new ArrayList<>(); frutas.add("Manzana"); frutas.add("Plátano"); Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

11 for (String fruta : frutas) { System.out.println(fruta); } Recordemos: Clase predefinida Tipo de datos que gestiona Ejemplo de método Paquete String Texto toUpperCase() java.lang Scanner Entrada desde teclado nextLine() java.util Math Números y funciones sqrt(), pow() java.lang ArrayList Listas dinámicas add(), get() java.util Tema 3: Métodos y propiedades En la programación orientada a objetos (POO), los métodos y las propiedades juegan un papel crucial en la definición del comportamiento y el estado de los objetos. Mientras que las propiedades definen los atributos o características de un objeto, los métodos definen las acciones que el objeto puede realizar.

Comprender cómo usar estos dos elementos de manera adecuada es esencial para el desarrollo de software eficiente, modular y fácil de mantener. 3.1 Métodos: Definición y uso Un método es una función o procedimiento que está asociado a una clase y define el comportamiento de los objetos creados a partir de ella. Los métodos son fundamentales porque permiten que los objetos realicen operaciones sobre sus atributos y interactúen con otros objetos. Los métodos tienen varias características importantes: 1. Visibilidad: Los métodos pueden ser públicos, privados o protegidos, lo que define desde qué parte del programa pueden ser accedidos.

Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 12 2. Parámetros: Los métodos pueden aceptar parámetros, que son valores o referencias que se pasan al método para que realice una operación. También pueden devolver un valor de tipo específico o no devolver nada (void). 3. Retorno: Los métodos pueden devolver un valor, o no devolver nada en caso de ser un método void.

Sintaxis básica de un método: class Persona { String nombre; // Método sin parámetros y sin retorno void saludar() { System.out.println("Hola, mi nombre es " + nombre); } // Método con parámetros void actualizarNombre(String nuevoNombre) { nombre = nuevoNombre; } // Método con retorno String obtenerNombre() { return nombre; } } En este ejemplo, tenemos tres métodos: 1. saludar(): No acepta parámetros y no devuelve nada (es un método void). 2. actualizarNombre(): Acepta un parámetro (nuevoNombre) y actualiza el atributo nombre del objeto. 3. obtenerNombre(): Devuelve el valor del atributo nombre.

Llamada a métodos: Para llamar a un método de un objeto, se usa la notación de punto, que permite acceder a los métodos y propiedades del objeto. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

13 Persona persona1 = new Persona(); persona1.nombre = "Juan"; // Llamada al método saludar persona1.saludar(); // Salida: Hola, mi nombre es Juan // Llamada al método actualizarNombre persona1.actualizarNombre("Carlos"); // Llamada al método obtenerNombre System.out.println(persona1.obtenerNombre()); // Salida: Carlos 3.2 Propiedades: Definición y acceso a los atributos Las propiedades son los atributos o características de un objeto. Definen el estado interno del objeto y pueden ser de diferentes tipos, como enteros, cadenas de texto, fechas, entre otros. Las propiedades son variables que se almacenan en un objeto y pueden ser modificadas o consultadas a través de los métodos de la clase.

Definición de propiedades: En una clase, las propiedades se definen de manera similar a las variables comunes. Sin embargo, las propiedades suelen ser privadas (para evitar el acceso directo desde fuera de la clase), y se accede a ellas mediante métodos getters y setters.

class Persona { private String nombre; // Propiedad privada private int edad; // Propiedad privada // Getter para obtener el nombre public String getNombre() { return nombre; } // Setter para modificar el nombre public void setNombre(String nombre) { this.nombre = nombre; } // Getter para obtener la edad public int getEdad() { return edad; } // Setter para modificar la edad public void setEdad(int edad) { if (edad > 0) { // Validación Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 14 this.edad = edad; } } } En este ejemplo: nombre y edad son propiedades privadas.

getNombre() y setNombre() son los métodos getter y setter para acceder y modificar el valor de nombre. getEdad() y setEdad() permiten acceder y modificar la propiedad edad. El setter de edad incluye una validación para asegurarse de que la edad sea positiva antes de modificarla. Uso de los métodos getter y setter: Los métodos getter y setter permiten controlar el acceso y la modificación de las propiedades de un objeto. Aunque es posible acceder directamente a los atributos de un objeto (si son públicos), se recomienda usar getters y setters para preservar la integridad de los datos.

Persona persona1 = new Persona(); // Usando los setters para modificar las propiedades persona1.setNombre("Juan"); persona1.setEdad(30); // Usando los getters para acceder a las propiedades System.out.println(persona1.getNombre()); // Salida: Juan System.out.println(persona1.getEdad()); // Salida: 30 Ventajas de usar getters y setters: Encapsulamiento: Se controla el acceso a las propiedades y se puede agregar lógica adicional (como validaciones o transformaciones de datos). Mantenimiento: Si más tarde es necesario cambiar la implementación de las propiedades, los métodos getter y setter permiten que los cambios se realicen sin afectar el código que usa la clase.

Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 15 Conclusión En la programación orientada a objetos, tanto los métodos como las propiedades son esenciales para definir el comportamiento y el estado de los objetos. Los métodos permiten que los objetos realicen acciones y manipulen sus datos, mientras que las propiedades almacenan la información del estado del objeto. Es importante también controlar el acceso a las propiedades y métodos utilizando getters, setters y modificadores de acceso para garantizar que los datos sean manipulados de forma segura y eficiente.

Recurso multimedia sugerido: Diagrama UML: Un diagrama que muestre cómo se definen las clases, sus métodos y atributos, y cómo interactúan entre sí. Vídeo práctico: Ejemplo de creación de una clase con propiedades y métodos en un IDE, mostrando cómo acceder y modificar las propiedades mediante getters y setters. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 16 Tema 4: Llamadas a métodos estáticos y uso de parámetros En la programación orientada a objetos (POO), los métodos estáticos y los parámetros juegan un papel crucial.

Los métodos estáticos se pueden llamar sin necesidad de crear una instancia de la clase, lo que los hace útiles para operaciones que no dependen del estado de un objeto específico. Además, el uso de parámetros en los métodos permite pasar información dinámica que puede influir en el comportamiento de un objeto o de una clase. Este tema profundiza en cómo los métodos estáticos y los parámetros mejoran la flexibilidad y la reutilización de código. 4.1 Métodos estáticos: Definición y uso Un método estático es un método que pertenece a la clase y no a sus instancias (objetos). Esto significa que un método estático se puede llamar sin crear un objeto de esa clase.

Los métodos estáticos son ideales para operaciones que no dependen de los atributos de las instancias de la clase, sino que realizan funciones generales que pueden ser útiles independientemente de un objeto específico. Características de los métodos estáticos: 1. Acceso sin crear instancias: Se pueden llamar directamente a través del nombre de la clase. 2. No requieren acceso a instancias: No necesitan acceder a los atributos de un objeto, ya que no tienen acceso al contexto de las instancias. 3. Se utilizan para operaciones generales: Son ideales para operaciones utilitarias, como cálculos matemáticos, validaciones, y otros procesos independientes del estado de un objeto.

Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 17 Sintaxis básica de un método estático: class Calculadora { // Método estático para sumar dos números static int sumar(int a, int b) { return a + b; } // Método estático para restar dos números static int restar(int a, int b) { return a - b; } } En este ejemplo, los métodos sumar() y restar() son estáticos, lo que significa que se pueden invocar sin crear una instancia de la clase Calculadora.

Llamada a un método estático: public class Main { public static void main(String[] args) { // Llamada al método estático sin crear un objeto de la clase Calculadora int resultadoSuma = Calculadora.sumar(5, 3); System.out.println("Resultado de la suma: " + resultadoSuma); // Salida: 8 int resultadoResta = Calculadora.restar(5, 3); System.out.println("Resultado de la resta: " + resultadoResta); // Salida: 2 } } Ventajas de los métodos estáticos: Acceso sin instanciación: Permiten acceder a funcionalidades comunes sin necesidad de crear objetos. Uso de recursos eficiente: No requieren almacenar el estado de un objeto, lo que puede reducir el consumo de memoria.

Reutilización de código: Son útiles para agrupar funciones que deben ser accesibles sin depender de un objeto. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 18 4.2 Diferencias entre métodos estáticos y métodos de instancia Métodos de instancia: Requieren que se cree un objeto de la clase antes de ser invocados, ya que operan sobre los atributos de la instancia. Métodos estáticos: No requieren instanciar la clase. Son llamados utilizando el nombre de la clase, ya que operan solo sobre sus propios parámetros y no sobre los atributos del objeto.

Ejemplo comparativo: class Persona { String nombre; // Método de instancia void saludar() { System.out.println("Hola, soy " + nombre); } // Método estático static void saludarGeneral() { System.out.println("Hola a todos!"); } } public class Main { public static void main(String[] args) { // Llamada al método estático sin crear un objeto Persona.saludarGeneral(); // Salida: Hola a todos! // Crear un objeto para llamar al método de instancia Persona persona1 = new Persona(); persona1.nombre = "Juan"; persona1.saludar(); // Salida: Hola, soy Juan } } En este caso: saludarGeneral() es un método estático, y puede ser llamado sin necesidad de crear un objeto Persona.

saludar() es un método de instancia, y requiere la creación de un objeto para poder ser llamado. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 19 4.3 Uso de parámetros en los métodos Los parámetros permiten que los métodos reciban información externa para realizar su tarea. Al definir un método, podemos especificar los parámetros que necesitamos para que el método realice su tarea de manera personalizada y flexible.

Sintaxis de los métodos con parámetros: class Calculadora { // Método que toma dos parámetros y retorna la suma static int sumar(int a, int b) { return a + b; } // Método que toma tres parámetros y retorna el promedio static double calcularPromedio(int a, int b, int c) { return (a + b + c) / 3.0; } } En este ejemplo, los métodos sumar() y calcularPromedio() aceptan parámetros para realizar sus operaciones.

Llamada a un método con parámetros: public class Main { public static void main(String[] args) { // Llamada al método con parámetros int suma = Calculadora.sumar(5, 3); System.out.println("Resultado de la suma: " + suma); // Salida: 8 double promedio = Calculadora.calcularPromedio(5, 8, 9); System.out.println("Promedio: " + promedio); // Salida: 7.33 } } En este caso, los parámetros proporcionan los valores con los que los métodos realizarán sus cálculos. Los métodos sumar() y calcularPromedio() toman esos parámetros para calcular el resultado. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

20 4.4 Parámetros por valor y por referencia En Java, los parámetros se pasan por valor, lo que significa que una copia del valor se pasa al método, y los cambios que se realicen sobre los parámetros dentro del método no afectarán al valor original fuera de este.

Parámetros por valor: class Ejemplo { void incrementar(int num) { num++; } } public class Main { public static void main(String[] args) { int numero = 5; Ejemplo ejemplo = new Ejemplo(); ejemplo.incrementar(numero); System.out.println("Número después de incrementar: " + numero); // Salida: 5 } } En este caso, aunque el valor de num se incrementa dentro del método, el valor original de numero en el método main() no cambia, ya que Java pasa los parámetros por valor.

Parámetros por referencia (para objetos): En el caso de los objetos, se pasa la referencia a la memoria donde está almacenado el objeto, lo que significa que cualquier cambio en los atributos del objeto dentro del método afectará al objeto original. class Persona { String nombre; } class Ejemplo { void cambiarNombre(Persona p) { p.nombre = "Carlos"; } } public class Main { public static void main(String[] args) { Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

21 Persona persona = new Persona(); persona.nombre = "Juan"; Ejemplo ejemplo = new Ejemplo(); ejemplo.cambiarNombre(persona); System.out.println("Nombre después de cambiar: " + persona.nombre); // Salida: Carlos } } En este caso, como persona es un objeto, la referencia al objeto se pasa al método cambiarNombre(), por lo que se puede modificar directamente el atributo nombre del objeto. Conclusión En la programación orientada a objetos, los métodos estáticos son útiles cuando se necesita realizar operaciones generales que no dependen del estado de un objeto.

Los parámetros permiten que los métodos trabajen con valores proporcionados en el momento de la invocación, lo que hace que el código sea más flexible y reutilizable. Además, es importante comprender la diferencia entre pasar parámetros por valor (para tipos primitivos) y por referencia (para objetos) para evitar confusiones y errores en el manejo de los datos. Recurso multimedia sugerido: Vídeo tutorial: Ejemplo de creación y uso de métodos estáticos y métodos con parámetros en un IDE.

Tema 5: Modificadores de acceso y encapsulamiento En la Programación Orientada a Objetos (POO), los modificadores de acceso y el encapsulamiento son dos conceptos fundamentales para controlar cómo los datos de un objeto son accesados y modificados, garantizando la seguridad, la integridad y la modularidad del código. Estos conceptos permiten ocultar detalles internos de la implementación de una clase y proporcionar un acceso controlado a los datos mediante métodos getters y setters. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

22 5.1 Modificadores de acceso: Definición y tipos Los modificadores de acceso son palabras clave que se utilizan para definir la visibilidad de las clases, atributos y métodos dentro de una clase. Los modificadores determinan desde qué lugares del código se puede acceder a las propiedades y métodos de un objeto. En Java, existen cuatro modificadores de acceso: 1. public: Permite el acceso desde cualquier parte del programa. Las clases, atributos o métodos declarados como public son accesibles desde cualquier otra clase. 2. private: Restringe el acceso a la clase en la que se declara. Los atributos y métodos declarados como private solo pueden ser accedidos desde dentro de la misma clase. 3.

protected: Permite el acceso desde dentro de la misma clase, las subclases (incluso si están en otro paquete) y las clases del mismo paquete. 4. default (sin modificador): Si no se especifica un modificador de acceso, se utiliza el modificador default, que hace que el atributo o método sea accesible solo desde clases dentro del mismo paquete.

Ejemplo de uso de modificadores de acceso: class Persona { public String nombre; // Atributo público, accesible desde cualquier parte private int edad; // Atributo privado, solo accesible dentro de la clase protected String direccion; // Atributo protegido, accesible en la misma clase y subclases // Método público public void saludar() { System.out.println("Hola, mi nombre es " + nombre); } // Método privado, solo accesible dentro de la clase private void cumplirAños() { edad++; } Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

23 // Método protegido, accesible en la clase y subclases protected void cambiarDireccion(String nuevaDireccion) { direccion = nuevaDireccion; } } En este ejemplo: nombre es accesible desde cualquier lugar debido a que es public. edad es accesible solo dentro de la clase Persona porque es private. direccion es accesible dentro de la misma clase y en clases que heredan de Persona (es protected) 5.2 Modificadores de acceso en herencia Cuando se trabaja con herencia, los modificadores de acceso también juegan un papel importante. Un método o propiedad private no es accesible en una subclase, pero los modificadores protected y public permiten un mayor acceso.

Ejemplo con herencia: class Animal { protected String nombre; // Atributo protegido protected void hacerSonido() { // Método protegido System.out.println("El animal hace un sonido"); } } class Perro extends Animal { void ladrar() { System.out.println("¡Guau!"); hacerSonido(); // Accediendo al método protegido de la clase base } } public class Main { public static void main(String[] args) { Perro perro = new Perro(); perro.nombre = "Rex"; // Accediendo al atributo protegido perro.ladrar(); // Llamando al método protegido de la clase base } } Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

24 En este ejemplo: El atributo nombre y el método hacerSonido() son protected, lo que permite que la clase Perro, que extiende a Animal, acceda a estos miembros. La subclase Perro puede acceder a los miembros protected de Animal sin ningún problema. Conclusión El encapsulamiento y los modificadores de acceso son fundamentales en la programación orientada a objetos, ya que permiten controlar el acceso a los atributos y métodos de una clase, promoviendo la seguridad, la modularidad y la flexibilidad en el código. A través del uso adecuado de getters y setters, se puede gestionar el acceso a los datos de manera controlada, asegurando la integridad y consistencia de los objetos.

Recurso multimedia sugerido: Infografía: Diferencia entre los modificadores de acceso public, private, protected y default, con ejemplos visuales. Tema 6: Herencia en la Programación Orientada a Objetos La herencia es uno de los pilares fundamentales de la Programación Orientada a Objetos (POO). Permite que una clase hija herede atributos y métodos de una clase padre, lo que facilita la reutilización de código y la creación de jerarquías de clases. Gracias a la herencia, podemos extender el comportamiento de las clases existentes sin tener que duplicar el código, lo que hace que el software sea más modular y fácil de mantener. 6.1 ¿Qué es la herencia?

La herencia es un mecanismo mediante el cual una clase puede heredar propiedades y comportamientos (métodos) de otra clase. En otras palabras, una clase hija puede extender o modificar las características de una clase padre. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 25 Clase padre: También llamada clase base o superclase, es la clase de la que se heredan los atributos y métodos. Clase hija: También conocida como clase derivada o subclase, es la clase que hereda los atributos y métodos de la clase padre. Ventajas de la herencia: 1.

Reutilización de código: Permite reutilizar métodos y atributos comunes sin tener que duplicar el código. 2. Extensibilidad: La herencia permite extender el comportamiento de una clase sin modificar la clase original. 3. Mantenibilidad: Facilita el mantenimiento del código, ya que las modificaciones realizadas en la clase padre afectan a todas las clases hijas.

Sintaxis básica de la herencia: class Animal { // Atributos comunes a todas las clases String nombre; // Método común a todas las clases void hacerSonido() { System.out.println("El animal hace un sonido"); } } class Perro extends Animal { // Método específico para la clase Perro void ladrar() { System.out.println("¡Guau!"); } } En este ejemplo: Perro hereda el atributo nombre y el método hacerSonido() de la clase Animal. Además, Perro tiene su propio método específico ladrar(). Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

26 6.2 Cómo funciona la herencia Cuando una clase hija hereda de una clase padre, obtiene todas las propiedades y métodos públicos y protegidos de la clase padre. Sin embargo, la clase hija puede modificar o sobrescribir esos métodos si es necesario, lo que le permite personalizar el comportamiento heredado. Esta característica se conoce como sobreescritura o overriding. Sobrescritura de métodos: La sobrescritura de métodos permite que una clase hija proporcione una implementación específica para un método que ya está definido en su clase padre. Para sobrescribir un método, la firma del método en la clase hija debe ser igual a la de la clase padre.

Sintaxis para sobrescribir un método: class Animal { void hacerSonido() { System.out.println("El animal hace un sonido"); } } class Perro extends Animal { // Sobrescribir el método hacerSonido() @Override void hacerSonido() { System.out.println("El perro ladra"); } } En este ejemplo, el método hacerSonido() de Perro sobrescribe el método hacerSonido() de Animal, proporcionando un comportamiento específico para los perros.

Uso de la herencia: public class Main { public static void main(String[] args) { Animal animal = new Animal(); animal.hacerSonido(); // Salida: El animal hace un sonido Perro perro = new Perro(); perro.hacerSonido(); // Salida: El perro ladra perro.ladrar(); // Salida: ¡Guau! } } Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 27 En este caso: El objeto animal de tipo Animal llama a la versión del método hacerSonido() definida en la clase Animal. El objeto perro de tipo Perro llama a la versión sobrescrita de hacerSonido() y también a su propio método ladrar().

6.3 Tipos de herencia Existen varios tipos de herencia en la programación orientada a objetos, dependiendo de la cantidad de clases implicadas y la relación entre ellas. Los más comunes son: 1. Herencia simple: Una clase hija hereda de una sola clase padre. Ejemplo: class Animal { } class Perro extends Animal { } 2. Herencia múltiple (no soportada directamente en Java): Una clase hija hereda de más de una clase padre. Aunque Java no permite la herencia múltiple de clases, se puede lograr mediante interfaces.

Ejemplo en Java (con interfaces): interface Volador { void volar(); } interface Nadador { void nadar(); } class Pato implements Volador, Nadador { public void volar() { System.out.println("El pato vuela"); } public void nadar() { System.out.println("El pato nada"); } } 3. Herencia multinivel: Una clase hija hereda de una clase padre, que a su vez hereda de otra clase. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 28 Ejemplo: class Animal { } class Mamifero extends Animal { } class Perro extends Mamifero { } Herencia jerárquica: Varios hijos heredan de una misma clase padre.

Ejemplo: class Animal { } class Perro extends Animal { } class Gato extends Animal { } 6.4 La palabra clave super En Java, la palabra clave super se utiliza para referirse a la clase padre de la clase actual. Se puede utilizar para acceder a métodos y constructores de la clase padre.

Uso de super para acceder a métodos de la clase padre: class Animal { void hacerSonido() { System.out.println("El animal hace un sonido"); } } class Perro extends Animal { void hacerSonido() { super.hacerSonido(); // Llama al método de la clase padre System.out.println("El perro ladra"); } } En este caso, el método hacerSonido() de Perro llama primero al método hacerSonido() de Animal utilizando super.hacerSonido(), y luego agrega su propio comportamiento. Uso de super para llamar al constructor de la clase padre: CopiarEditar class Animal { Animal(String nombre) { Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

29 System.out.println("Animal creado: " + nombre); } } class Perro extends Animal { Perro(String nombre) { super(nombre); // Llama al constructor de la clase Animal System.out.println("Perro creado: " + nombre); } } En este caso, el constructor de Perro llama al constructor de la clase Animal usando super(nombre) para inicializar el atributo de la clase base. 6.5 Herencia y accesibilidad La herencia afecta la accesibilidad de los métodos y atributos de la clase padre. Los modificadores de acceso definen qué miembros de la clase padre son accesibles desde las clases hijas: 1. public: Los miembros públicos de la clase padre son accesibles desde cualquier clase, incluida la clase hija. 2.

protected: Los miembros protegidos son accesibles dentro de la misma clase, las subclases y las clases del mismo paquete. 3. private: Los miembros privados no son accesibles desde la clase hija. 4. default: Los miembros con acceso por defecto solo son accesibles dentro del mismo paquete. Conclusión La herencia es un concepto clave en la Programación Orientada a Objetos que permite crear jerarquías de clases y reutilizar código de manera eficiente. Gracias a la herencia, podemos extender y personalizar el comportamiento de las clases padres sin tener que duplicar código.

Además, el uso de super, junto con los modificadores de acceso, facilita el control y la extensión del comportamiento de las clases en un sistema orientado a objetos. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 30 ¿Qué has aprendido? La herencia es un principio fundamental de la Programación Orientada a Objetos (POO) que permite crear nuevas clases basadas en clases existentes. La clase hija hereda atributos y métodos de la clase padre, lo que facilita la reutilización del código y la creación de jerarquías de clases. Conceptos clave: Clase padre: Es la clase de la que heredan las clases hijas.

Clase hija: Extiende las propiedades y comportamientos de la clase padre. Sobrescritura de métodos: Permite que una clase hija modifique el comportamiento heredado de la clase padre. Palabra clave super: Permite acceder a los métodos y constructores de la clase padre desde la clase hija. Tipos de herencia: Existen varias formas de herencia como simple, múltiple (mediante interfaces), multinivel, y jerárquica. Reflexión: Al comprender la herencia, hemos aprendido a organizar y estructurar el código de forma eficiente, lo que facilita su mantenimiento y extensión. La herencia promueve la reutilización del código y permite crear aplicaciones más modulares y fáciles de escalar.

Saber cómo aplicar la herencia correctamente nos ayuda a escribir código más limpio y eficiente. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 31 Fuentes de información Horacio, M. (2021). Introducción a la programación orientada a objetos. Ediciones Académicas. García, L. y Martínez, J. (2020). Fundamentos de programación orientada a objetos. Editorial Técnica Universitaria. López, S. (2019). Conceptos clave de la programación orientada a objetos. Editorial McGraw-Hill. Rodríguez, C. (2022). Herencia en programación orientada a objetos: Teoría y práctica. Editorial Pearson. Gobierno de España. (2021).

Lenguajes de programación y buenas prácticas. Ministerio de Educación y Formación Profesional. Recuperado de https://www.educacion.gob.es Manual de Java (2023). Herencia en Java: Principios y mejores prácticas. Oracle Corporation. Recuperado de https://docs.oracle.com/javase/tutorial/java/IandI/ Rodríguez, P., García, F. y Martínez, R. (2021). Diseño orientado a objetos con Java. Editorial Wiley. Pérez, J. (2020). Programación orientada a objetos: El poder de la herencia y el polimorfismo. Editorial Universitaria. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

32 Glosario Herencia Mecanismo que permite que una clase hija herede atributos y métodos de una clase padre, facilitando la reutilización de código y la creación de jerarquías de clases. Clase padre (superclase) Clase de la cual una o más clases hijas heredan sus atributos y métodos. Es la clase base que define comportamientos comunes. Clase hija (subclase) Clase que hereda atributos y métodos de una clase padre. Puede añadir nuevos comportamientos o sobrescribir los heredados. Sobrescritura de métodos (Overriding) Proceso en el cual una clase hija proporciona una implementación específica para un método que ya está definido en la clase padre.

Polimorfismo Capacidad de una clase hija de cambiar el comportamiento de un método heredado, permitiendo que se ejecute de diferentes maneras según el contexto. Modificadores de acceso Palabras clave que definen la visibilidad de los atributos y métodos dentro de una clase, como public, private, protected o default. Palabra clave super Se utiliza para hacer referencia a la clase padre en una clase hija, permitiendo acceder a métodos y constructores de la clase padre. Constructores Métodos especiales utilizados para inicializar los objetos de una clase. La clase hija puede invocar el constructor de la clase padre usando super().

Herencia múltiple Concepto donde una clase hereda de más de una clase, lo que no es directamente soportado en Java para clases, pero puede lograrse mediante interfaces. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 33 Encapsulamiento Técnica que consiste en ocultar los detalles internos de la implementación de una clase y exponer solo lo necesario a través de métodos públicos. Métodos estáticos Métodos que pertenecen a la clase y no a las instancias de la clase. Se pueden invocar sin crear un objeto de la clase.

Acceso por referencia En Java, los objetos se pasan a los métodos por referencia, lo que significa que cualquier cambio realizado en el objeto afectará al objeto original fuera del método. Acceso por valor Se refiere al paso de parámetros en los que se pasa una copia del valor, lo que significa que cualquier cambio en el parámetro dentro del método no afecta al valor original fuera de él. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 34 Actividades de evaluación Actividad 1: Creación de una jerarquía de clases Descripción: Diseña un sistema basado en herencia que represente una jerarquía de clases.

Por ejemplo, puedes crear una jerarquía de clases que simule diferentes tipos de animales (como Mamíferos, Aves, Reptiles) y sus comportamientos. Crea al menos tres niveles de herencia y usa métodos sobrescritos en las clases hijas para modificar el comportamiento heredado de la clase padre. Instrucciones: 1. Crea una clase base llamada Animal, con métodos comunes como hacerSonido(). 2. Crea al menos dos clases hijas que hereden de Animal (por ejemplo, Perro y Gato). 3. Asegúrate de sobrescribir al menos un método en cada clase hija. 4. Utiliza un ejemplo en tu código que muestre cómo los métodos de la clase padre son modificados en las clases hijas. 5.

Documenta el código de manera clara y concisa. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 35 Rúbrica de evaluación: Indicador de logro Excelente (10-9) Notable (8-7) Aprobado (6- 5) Insuficiente (<5) Organización y jerarquía de clases (RA1CEb) La jerarquía de clases es clara, bien estructurada y organizada con al menos tres niveles de herencia. La jerarquía es funcional y está estructurada, pero con un nivel de herencia mínimo. La jerarquía de clases es incompleta o mal estructurada, faltan niveles importantes. No se ha establecido una jerarquía de clases.

Sobrescritura de métodos y polimorfismo (RA1CEf) Los métodos están sobrescritos correctamente, demostrando un uso adecuado de la herencia y polimorfismo. Los métodos sobrescritos están bien definidos, aunque con algunos detalles faltantes en el comportamiento. El código tiene intentos de sobrescribir métodos, pero no son coherentes o funcionales. No se han sobrescrito métodos o el código tiene errores significativos. Documentación y claridad del código (RA2CEb) El código está perfectamente documentado, con comentarios claros y apropiados. El código tiene comentarios adecuados, pero algunos detalles faltan. El código tiene pocos comentarios o son poco claros.

El código no está documentado o los comentarios son confusos. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 36 Actividad 2: Desarrollo de una aplicación que simule un sistema de inventario Descripción: Crea una pequeña aplicación que simule el sistema de gestión de un inventario. La aplicación debe tener al menos dos clases principales que gestionen los productos y el almacén. Los productos deben ser objetos que incluyan atributos como nombre, cantidad y precio. El almacén debe ser una clase que gestione la adición, eliminación y búsqueda de productos Instrucciones: 1.

Crea una clase Producto con atributos como nombre, cantidad y precio. 2. Crea una clase Almacen que contenga una lista de productos y permita realizar las siguientes operaciones: o Añadir productos. o Eliminar productos. o Buscar un producto por nombre. 3. La aplicación debe permitir interactuar con el usuario a través de la consola (por ejemplo, ingresando opciones para añadir, eliminar o buscar productos). 4. Al menos una de las clases debe utilizar métodos estáticos. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev.

37 Rúbrica de evaluación: Indicador de logro Excelente (10-9) Notable (8-7) Aprobado (6-5) Insuficiente (<5) Implementación de la clase Producto y Almacen (RA2CEh) Las clases están perfectamente implementadas con atributos bien definidos y operaciones funcionales. Las clases están bien implementadas, pero faltan algunos detalles o validaciones. Las clases no están completas o funcionan de forma incorrecta. Las clases no se han implementado correctamente. Uso de métodos estáticos en la clase Almacen (RA2CEe) Se utilizan correctamente métodos estáticos en la clase Almacen, facilitando la gestión global de los productos.

Se usan métodos estáticos, pero con algunas limitaciones en su aplicabilidad. El uso de métodos estáticos es inapropiado o se utiliza de forma incorrecta. No se usan métodos estáticos o se usan de forma errónea. Interacción y usabilidad de la aplicación (RA1CEg) La aplicación es fácil de usar, permite al usuario interactuar claramente y realizar todas las operaciones correctamente. La aplicación funciona correctamente, pero tiene una interacción algo limitada o compleja. La aplicación es funcional, pero la interacción con el usuario es confusa o incompleta. La aplicación no permite una interacción adecuada con el usuario o presenta errores frecuentes.

Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 38 Tabla de relación entre contenidos y criterios de evaluación (CE) Bloque de contenido Criterios de Evaluación asociados 1. Introducción a la Programación Orientada a Objetos RA2CEa: Se han identificado los fundamentos de la programación orientada a objetos. RA2CEb: Se han escrito programas sencillos. 2. Clases y objetos RA2CEc: Se han instanciado objetos a partir de clases predefinidas. RA2CEd: Se han utilizado métodos y propiedades de los objetos. 3. Métodos y propiedades RA2CEe: Se han escrito llamadas a métodos estáticos.

RA2CEf: Se han utilizado parámetros en la llamada a métodos. 4. Llamadas a métodos estáticos y uso de parámetros RA2CEg: Se han incorporado y utilizado librerías de objetos. RA2CEh: Se ha utilizado el entorno integrado de desarrollo en la creación y compilación de programas simples. 5. Modificadores de acceso y encapsulamiento RA1CEa: Se han identificado los bloques que componen la estructura de un programa informático. RA1CEb: Se han creado proyectos de desarrollo de aplicaciones. 6. Herencia RA2CEa: Se han identificado los fundamentos de la programación orientada a objetos. RA2CEf: Se han utilizado parámetros en la llamada a métodos. 7.

Polimorfismo y sobrescritura de métodos RA2CEg: Se han incorporado y utilizado librerías de objetos. Nombre de la Unidad de Trabajo Nombre del Módulo Profesional Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 39 8. Interfaces y clases abstractas RA2CEh: Se ha utilizado el entorno integrado de desarrollo en la creación y compilación de programas simples. 9. Diseño y depuración de programas orientados a objetos RA1CEg: Se han utilizado estructuras de control para el flujo de ejecución en programas. 10. Integración de conceptos de la POO en aplicaciones reales RA2CEd: Se han utilizado métodos y propiedades de los objetos.

Nombre de la Unidad de Trabajo Nombre del Módulo Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 40 Rúbrica de evaluación Indicador de logro Excelente (10-9) Notable (8-7) Aprobado (6-5) Insuficiente (<5) 1. Implementación de la jerarquía de clases (RA2CEa) La jerarquía de clases es clara, estructurada y adecuada, mostrando al menos tres niveles de herencia y relaciones bien definidas. La jerarquía de clases está bien organizada, pero algunos niveles o relaciones no están claros. La jerarquía tiene uno o dos niveles de herencia, con relaciones algo confusas. No hay una jerarquía clara de clases o la relación de herencia no está definida. 2.

Sobrescritura de métodos (RA2CEf) Los métodos sobrescritos en las clases hijas son adecuados y funcionales, demostrando un uso eficaz de la herencia. Los métodos sobrescritos son correctos, pero con pequeñas incoherencias o falta de explicación. Los métodos sobrescritos son parciales o con errores que afectan al comportamiento. No se ha realizado sobrescritura de métodos o se ha hecho de forma incorrecta. 3. Uso de la palabra clave super y herencia (RA2CEd) El uso de super está perfectamente implementado para acceder a métodos y atributos de la clase padre. El uso de super es adecuado, pero no siempre es coherente con el propósito del código.

El uso de super es confuso o no se aplica correctamente en todos los casos. No se utiliza la palabra clave super o se usa incorrectamente. Nombre de la Unidad de Trabajo Nombre del Módulo Nombre del Ciclo Curso académico 2025/2026 – Edición Online – Rev. 41 4. Claridad y documentación del código (RA2CEh) El código está perfectamente documentado, con comentarios claros que explican cada parte del programa. El código tiene comentarios adecuados, aunque algunos detalles podrían estar más explicados. El código tiene pocos comentarios o son poco claros, dificultando la comprensión. El código no está documentado o los comentarios son inexistentes o confusos. 5.

Comprensión y aplicación de la herencia en un contexto práctico (RA2CEg) El análisis y la aplicación de la herencia son precisos, con una excelente comprensión de los beneficios de reutilización de código y extensión. El análisis y aplicación de la herencia son correctos, pero algunos aspectos no están completamente desarrollados. El análisis de la herencia es superficial o presenta errores conceptuales. No se demuestra una comprensión adecuada de la herencia ni su aplicación en ejemplos prácticos.