Cursos Empresas Blog Live Conf Precios

Sobrescritura de métodos en clases derivadas en Java

Clase 4 de 40 • Curso Avanzado de Java SE

Contenido del curso

Introducción al Curso

1
Java SE Avanzado: Programación Modular y Persistencia con JDBC
03:17 min

Clases avanzadas

2
Clases Abstractas y Polimorfismo en Java: Avances y Aplicaciones
08:30 min
3
Reducción de Código con Clases Abstractas en Java
09:20 min
4
Sobrescritura de métodos en clases derivadas en Java
Viendo ahora
5
Polimorfismo y Abstracción en Clases Java
13:48 min

JavaDocs

6
Generación de Documentación Java con Javadocs
10:39 min
7
Documentación en Java: Uso de Etiquetas y Comentarios HTML
11:42 min
8
Documentación de librería Report en Java SE
00:17 min
9
Documentación de Clases Heredadas en Java
06:34 min
10
Generación de Documentación JavaDoc en HTML
07:55 min

Clases Anidadas

11
Clases Anidadas en Java: Conceptos y Aplicaciones Prácticas
17:27 min
12
Clase Song como clase interna en Album en Java
00:16 min
13
Implementación de Clases Anidadas en Java: Ejemplo Práctico con Page y Book
05:57 min
14
Simulación de Lectura con Clases Anidadas en Java
14:59 min
15
Uso de Enumerations en Programación
00:24 min

Interfaces Avanzadas

16
Interfaces Avanzadas en Java: Métodos Default y Private
10:14 min
17
Creación de Interfaces DAO en Java para Gestión de Bases de Datos
08:00 min
18
Encapsulación y Abstracción en Diseño de APIs
00:27 min
19
Diferencias entre Clases Abstractas e Interfaces en Programación
03:35 min
20
Herencia y métodos en interfaces de Java 8 y 9
00:24 min

Colecciones Avanzadas

21
Implementaciones y uso de Map en Java
01:42 min

Excepciones

22
Manejo de Excepciones en Java: Errores Checked y Unchecked
07:15 min
23
Manejo de Excepciones en Java: Try-Catch y Try-With-Resources
11:31 min

JDBC

24
Conexión a Bases de Datos con JDBC en Java
07:19 min
25
Uso de PreparedStatement para consultas con filtros en JDBC
00:20 min
26
Configuración de phpMyAdmin y XAMPP para Bases de Datos
01:05 min
27
Conexión a MySQL usando Java JDBC: Configuración y Prácticas
14:17 min
28
Conexión y Lectura de Datos con JDBC en Java
15:41 min
29
Persistencia de Datos en Aplicaciones de Películas
13:37 min
30
Inserción y Visualización de Películas Vistas en Base de Datos SQL
13:37 min
31
Generación de Reportes Diarios con Fechas en Java
02:44 min

Lambdas

32
Modificación de tablas y manejo de fechas en MySQL
03:00 min
33
Interfaces Funcionales en Java: Conceptos y Ejemplos Prácticos
05:25 min
34
Programación Funcional: Paradigmas y Lambdas en Java
07:28 min
35
Lambdas en Java: Sintaxis y Aplicaciones Prácticas
13:31 min
36
Elementos clickeables en interfaz gráfica
00:13 min
37
Declaración de Lambdas y Recursividad en Java
15:08 min
38
Streams y Filters en Java para Optimizar Colecciones
12:09 min
39
Uso de Lambdas y Predicados en Streams Java
10:02 min

Fin del Curso

40
Programación Avanzada en Java: Clases e Interfaces
01:30 min

Escuelas

Desarrollo Web
English Academy
Marketing Digital
Inteligencia Artificial y Data Science
Ciberseguridad
Liderazgo y Habilidades Blandas
Diseño de Producto y UX
Contenido Audiovisual
Desarrollo Móvil
Diseño Gráfico y Arte Digital
Programación
Negocios
Blockchain y Web3
Recursos Humanos
Finanzas e Inversiones
Startups
Cloud Computing y DevOps

Platzi y comunidad

Platzi Business
Live Classes
Lanzamientos
Executive Program
Trabaja con nosotros
Podcast

Recursos

Manual de Marca

Soporte

Preguntas Frecuentes
Contáctanos

Legal

Términos y Condiciones
Privacidad
Tyc promociones

Reconocimientos

Reconocimientos

Top 40 Mejores EdTech del mundo · 2024

Primera Startup Latina admitida en YC · 2014

Primera Startup EdTech · 2018

CEO Ganador Medalla por la Educación T4 & HP · 2024

CEO Mejor Emprendedor del año · 2024

De LATAM conpara el mundo

Youtube Instagram LinkedIn TikTok Facebook X (Twitter)Threads

Tengo un programa que dibuja figuras automáticamente.

He creado una clase abstracta llamada Figura, esta tiene un método llamado dibujate()

¿Qué tendría que hacer para que la clase Triangulo pueda sobreescribir este método y poner el código que haga que dibuje la forma indicada?

Analiza el problema, realiza tu diagrama y comparte tu respuesta en la sección de discuciones.

Sobrescritura de métodos en clases derivadas en Java

Rodolfo Sáenz

student•

WENANCE SA

student•

Giancarlo Elvis Yarlequé Juárez

student•

Vespaciano Forero Sanchez

student•

Laura Sofía Córdoba

student•

Irma Solis

student•

Esteban Ramon Padron Urdaneta

student•

Cristhian Gallo

student•

Noe de Jesus Muñoz Martinez

student•

Luis David López Berber

student•

Jairo Andres Teran Arcos

student•

Luis German Velasco Alquicira

student•

Andrea Raquel Garay Leguizamón

student•

Harrison Martinez

student•

Ivan Dario Quintero Rios

student•

Marcos Emilio Velásquez Hidalgo

student•

Guy Acevedo

student•

Fernando Alberto Morales Reyes

student•

Marlon Daniel Peña Velasquez

student•

Carlos Naveda

student•

Luna Alejandra Campo Mazo

student•

Pablo Villegas Palacio

student•

public abstract class Figura  {

	public abstract void dibujate();
}

public class Triangulo extends Figura {

	@Override
	public void dibujate() {
		/* Lógica para dibujar triángulo */
	}
}

```` ``` ````

public abstract class Figura {
	public abstract void dibujate();
}

public class Triangulo extends Figura {

	@Override
	public void dibujate() {
		System.out.println("Voy a dibujar un Triangulo");
	}	

}

El diagrama seria algo así:

En el código quedaria algo así:

public abstract class Figura {
	abstract void dibujate();
}

public class Triangulo extends Figura {
	public float base;
	public float altura;
	public void dibujante() {
		//Se dibuja el triangulo
	}
}

clase Figura

public abstract class Figura {

public abstract void dibulate ();
}

Clase Triangulo

public class Triangulo extends Figura {
@Override
	public void dibujate() {
		
	}
}

Solo definir el método dibujate y declarar la clase Triangulo como extensión de Figura

public class Triangulo extends Figura {
@Override
public void dibujate() {
pintaTriangulo()
}

}

public abstract class Figura { public abstract void dibujar(); }

public class triangulo extends Figura {

@Override
public void dibujar() {

}

}

public abstract class Figura {
	
	protected abstract void dibujar();
	
}

public class Triangulo extends Figura{

	//Constructor
	public Triangulo() {}
	
	//Implementación método abstracto de la clase padre
	@Override
	public void dibujar() {
		
		System.out.println("Dibujando un Triangulo");
		
	}

}


public class Rectangulo extends Figura{

	public Rectangulo() {}
	
	//Implementación método abstracto de la clase padre
	@Override
	public void dibujar() {
		
		System.out.println("Dibujando un Rectangulo");
		
	}

}

public class Main {

	public static void main(String[] args) {
		
		
		Figura triang = new Triangulo();
		
		//Imprimir
		((Triangulo)triang).dibujar();
		
		Figura rectang = new Rectangulo();
		
		//Imprimir
		((Rectangulo)rectang).dibujar();
	

	}
	
}

Código:

public abstract class Figura {
	public abstract void dibujate();
}

public class Triangulo extends Figura {
	@Override
	public void dibujate() {
		// TODO Auto-generated method stub
		
	}
}

Excelente aporte Noe

Public abstract class Figura{
	public abstract void dibujate();
}

Public class Triangulo extends Figura{
	@Override
	public void dibujate(){
	// Proceso encargado de dibujar la figura
	}
}

Respuesta:

public abstract class Figura {
	public abstract void dibujate();
}
public class Triangulo extends Figura {
	@Override
	public void dibujate(){

	}
}

Diagrama

Luego de creada la clase Figura de forma abstracta con su medo dibujate() abstracto, se debe crear la clase Triangulo que heredara de la clase abstracta Figura, y tendrá que implementar y sobre escribir el método abstracto dibujate():

public abstract class Figura{ public abstract void dibujate(); }

public class Triangulo extends Figura{ public void dibujate() { //Codigo que dibuja la figura } }

La clase triangulo debe extender de figura y cambiar el método dibujate como abstracto. Luego se debe consumir para usar el metodo dibujate. public abstract class figura { public abstract void dibujate(); }

public class triangulo extends figura (){ public void dibujate(){ systema.out.println('triangulo'); } }

public class circulo extends figura (){ public void dibujate(){ systema.out.println('circulo'); } }

Es una mezcla entre interfaces y herencia, el codigo será propio de la clase de Triangulo.

public abstract class Figura(){
	
	public abstract void dibujate();
}

public class Triangulo extends Figura {
	
	@override
	public void dibujate(){
		//Lineas de codigo propias de Triangulo.
	}
}

public abstract class Figura(){
	public abstract void dibujate();
}

public class Triangulo extends Figura{
	
	@override
	public void dibujate(){
		/*
			Instrucciones...
		*/
	}
}

// 1. Definición de la clase abstracta

abstract class Figura {

// Método abstracto: no tiene cuerpo, obliga a las hijas a implementarlo

public abstract void dibujate();

}

// 2. Extensión y sobreescritura en la clase hija

class Triangulo extends Figura {

@Override

public void dibujate() {

// Aquí va el código específico para dibujar el triángulo

System.out.println("Dibujando un triángulo con tres líneas unidas...");

}

}

La clase Triángulo debe heredar (extender) de la clase Figura. Después de eso podemos implementar el método dibujate específico para la clase Triangulo.

Hola, tendríamos que hacer lo siguiente: 1) En la clase abstracta Figura, indicar que el método dibujate() también será abstracto, retirar la implementación de ahí.

2) En la clase Triangulo, debe heredar de la clase Figura y en la sección de métodos hacer un @Override e implementar el método dibujate() y codificarlo de acuerdo a lo necesario para la clase Triangulo.

Para que la clase Triangulo pueda sobreescribir el método dibujate() de la clase abstracta Figura, debes asegurarte de que el método en Triangulo tenga exactamente la misma firma. Tu implementación actual tiene un error tipográfico en el nombre del método (dibujante en lugar de dibujate). Aquí tienes un ejemplo corregido:

public abstract class Figura {
    abstract void dibujate();
}

public class Triangulo extends Figura {
    public float base;
    public float altura;

    @Override
    public void dibujate() {
        // Aquí se dibuja el triángulo usando base y altura
    }
}

Así, Triangulo sobreescribe correctamente el método dibujate().

Figura

┌──────────────┐

│«abstract» │

│Figura │

│--------------│

│+ dibujate() │«abstract»

└─────▲────────┘

│

│extends

┌─────┴────────┐

│Triangulo │

│--------------│

│+ dibujate() │ // implementación concreta

└──────────────┘