Ejercicio. Clases Abstractas

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");
	}	

}

clase Figura

public abstract class Figura {

public abstract void dibulate ();
}

Clase Triangulo

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

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
		
	}
}

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(){

	}
}

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...
		*/
	}
}

Tendria que declarar Figura como una clase abstracta, declarar dibujante() como un método abstracto y luego hacerle override al mismo metodo en la clase Triangulo la cual hereda de Figura.

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

public class Triangulo extends Figura{
    public void dibujar() {
        // Aqui va el codigo que necesitamos que haga en Dibuja
    }
}

public abstract class Figura {

public abstract void dibujate();

}

public class Triangulo extends Figura {

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

}

<code>
public abstract class Figura {
    public abstract void dibujate();
}
public class Triangulo extends Figura{

    @Override
    public void dibujate() {
        for(int i=1;i<5;i++){
            switch(i){
                case 1: System.out.println("      * ");
                break;
                case 2: System.out.println("    **"+"**");
                break;
                case 3: System.out.println("  ****"+"****");
                break;
                case 4: System.out.println("******"+"******");
                break;
            }
        }
    }
    
}
public class Main {
    
    public static void main(String[] agrs){
        Triangulo triangulo = new Triangulo();
        triangulo.dibujate();
    }
}

Las clases hijas deberian extender de la clase figura y cada una debera sobre escribir su metodo abstracto dibujate

Se debe crear la clase padre Figura con un método abstracto dibujate() y la clase hija triangulo debe heredar de Figura e implementar el método abstracto dibujate

public abstract class Figura{
	public abstract void Dibujate();
}
public abstract class Triangulo extends Figura{
	public void Dibujate(){
	//codigo para dibujar los triangulos
	}
}

Que el método dibujate() sea abstracto y que Triangulo extienda de Figura

Tendria que implementar el metodo astracto en la clase dibujo

public abstractclassFigura{ 	
	public abstract void dibujate();	
}
public classTrianguloextendsFigura{
	@Override
	public void dibujate(){ 
		// sobrescribiendo el método
	}
}```

public abstractclassFigura{

public abstract void dibujate();

}

public classTrianguloextendsFigura{

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

}

Para la clase Figura

public abstract class Figura { 

public abstract void dibujate();

}

Para la clase Triangulo

public class Triangulo extends Fugura {
	public void dibujate(){
	}
}

public abstract class Figura{

//el metodo como la clase deben ser abstractos

public abstract void dibujate();
}

public class Triangulo extends Figura{

/*Aquí heredamos de la clase padre figura y como tiene metodos abstractos se deben implementar obligatoriamente*/

@Override
public void dibujate() {
}
}

La clase ‘Triangulo’ tendría que heredar de ‘Figura’ y sobreescribir el método: ‘dibujate’.

Figura.java

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

Triangulo.java

public class Triangulo extends Figura{

	@Override
	public void Dibujate() {
		float base;
		float algura;
		/*Código para dibujar el triángulo*/
		//dibujarTriangulo();
	}

}

public abstract class Figure {    

    public abstract void dibujate();   
 
}

public class Triangulo extends Figure {

    @Override
    public void dibujate() {
        System.err.println("Dibujando un triangulo");
    }  

 }

//Clase abstracta existente
public abstract class Figura {
	public abstract void dibujate();
}

public class Triangulo extends Figura {
	@Override
	public void dibujate() {//Aqui se sobreescribe el método 
		//Se dibuja la forma indicada con Java 2D
	}
}

Acá dejo mi ejemplo, el diagrama UML es este:

Clase Figure

public abstract class Figure {

    public abstract void draw();
}

Clase Triangle

public class Triangle extends Figure {

    int height;
    int base;

    public Triangle(int height, int base) {
        this.height = height;
        this.base = base;
    }

    @Override
    public void draw() {
        System.out.println();
        for (int i=1; i<base; i += 2) {
            for (int k=0; k < (height - i / 2); k++) {
                System.out.print(" ");
            }
            for (int j=0; j<i; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

Método Main

public static void main(String[] args) {
    Triangle triangle = new Triangle(8,16);
    triangle.draw();
}

abstract class Figura{
abstract void dibujate();
}

class Triangulo extends Figura{

@Override
void dibujate(){
//add logic here!
}

}

Se escribe una clase abstracta Figura en la que el método dibuja también serà abstracto. Cada vez que una clase herede de Figura, reescribir el metodo dibuja.

Declarar la clase Figura y el método dibújate como abstracto, para que pueda ser implementado por las diferentes formas (figuras geométricas) que heredan de la clase Figura

Como ya hemos visto, una clase abstracta tiene ciertos comportamientos parecidos a una interfaz,
para resumir, se trata que los métodos que posee, deban ser implementados por una una clase concreta,
solo y solo si los métodos tienen un prefijo de abstract, de lo contrario no se deben implementar en la clase concreta.

Teniendo el siguiente problema del triangulo, me dispuso a graficarlo para un mejor entendimiento:

Primero debemos crear la clase abstracta con el prefijo abstract y el metodo dibujate, tambien con el prefijo abstract, por que sera obligado implementarlo: como observamos en la siguiente imagen

Segundo: Creamos la clase concreta Triangulo y heredamos a la clase abstracta, implementando al método dibujate() con la etiqueta @override, la cual significa que lo estamos sobre escribiendo Figura:

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

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

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

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

}

}

Clase padre (archivo Figura.java) :

public abstract class Figura{
	//Método abstracto obligatorio cuando una clase hijo (Triangulo.java) hereda de la clase padre (Figura.java)
	/*public: Para que los hijos puedan ver el método
	  abstract: identificar al método como abstracto
	  void: no devuelve nada
	*/
	public abstract void dibujate();
}

Clase hijo (archivo Triangulo.java):

//Clase Triangulo hereda de Figura con extends
public class Triangulo extends Figura{
	@Override
	public void dibujate(){
		//Comportamiento que yo quiera
	}
	
}

• Clase Padre Figura: Debe ser Abstracta y contener un método dibujate();
• Clase Hija Triangulo: Debe implementar el metodo abstracto de su clase padre además de tener sus setter y getter y su constructor.

😃

public abstract class Figura { //declaracion de la clase Abstracta
public abstract void dibujar(); //metodo abstracto
}

public class triangulo extends Figura { //tenemos acceso a la clase Figura mediante la clase Triangulo

@Override
public void dibujar() {//declaramos el metodo de la clase abstracta para darle un comportamiento independiente.
//detallamos lo que hara este metodo
System.out.println("Imprimiendo triangulo");
}	

}

Respuesta:

1. Heredar el metodo de la clase Figura con la palabra reservada extends
2. Después llamar el método dibujate() y añadirle a este, la palabra reservada @Override para poder modificarlo en base a la clase triangulo.
3. Así quedaría el código de esta clase:

public class Triangulo extends Figura {
	@Override
	public void dibujate(){
		//Código que cambia el metodo
	}
}

public interface Figura {
	public void dibujate();
}

public class Triangulo extends Figura {
	public void dibujate(){
		//Hacer Dibujo
	}//dibujate
}//class

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

public class Triangulo extends Figura
{
public void dibujate()
{
//Código para dibujar el triángulo
}
}

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

public class Triangulo extends Figura{

	@Overrive
	public void dibujate(){
		//Code inside the abstrac method
	}

}

La respuesta ya la dio la maestra en una de las clases anteriores. hacer el metodo dibujate() abstracto y sobrescribirlo enla clase Triangulo.

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

public class Triangulo extends Figura
{
public void dibujate(){
// redefines el metodo
}
}

public abstract class Figura{
public abstract void dibujate();
}
public class Triangulo extends Figura{
@Override
public void dibujate() {
int base, altura;
//dibujar triangulo
}
}

Una pregunta alguien sabe si se puede representar una clase abstracta de alguna forma en especifico con UML, o basta con representarla como una clase normal?

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

public class Triangulo extends Figura{
@Override
public void dibujante(){
//Método
}
}

public abstract void Figura {
//Define el método dibujate
abstract void dibujate();
}

public Triangulo extends Figura {
//Llama al metodo de figura
abstract void dibujate() {
//Operacion necesaria para Triangulo.
}

p**ublic abstract class Figura{
**
public abstract void dibujate();

}

public class TrianguloextendsFigura{

@Override
public void dibujate() {

}

}

1. Establecer los parámetros que recibirá el método “dibujate” de la clase abstracta figura, para que sean genéricos y no genere inconvenientes con algún tipo de figura que pueda surgir.

2. La clase triangulo con pase a sus atributos y otros métodos internos sobre escribe el método “dibujate” con base a sus características para poderse dibujar correctamente.

<public abstrac class Figura{
public abstract void dibujante (){
}

}

public class Triangulo extends Figura{

public void dibujante(){
Sytem.oot.println("mi dibujo");
}

}>

public abstract class Figura {
	public abstract void Dibujate();

}

public  class Triangulo {
	@Override
	public  void Dibujate(){
	// Implementacion
	}

}


<code>

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

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

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

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

Clase abstracta Figura

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

Clase Triangulo

public classTriangulo extends Figura{)

	@Override
	public void dibujate() {
		/* TODO codigo para dibujar un trángulo */
	}
}

// Clase Padre (Figura)
//**************************************
public abstract class Figura {
    public abstract void dibujate();
}
//**************************************
//Clase Hija (Triángulo)
//**************************************
public class Triangulo extends Figura{
    @Override
    public void dibujate() {  
    }   
}
//**************************************

La clase Triangulo tendría que heredar de la clase Figura , de manera que pueda sobrescribir el método abstracto dibujate()

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

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

package com.personal.figuras;

public class Triangulo implements Figura {

@Override
public void dibujate() {
	
}

}

Triangulo debe extender la clase Figura y hacer override del metodo dibujate().

Basta con extender la clase figura y sobre-escribir el método definido, dado que al ser una clase abstracta se te obliga a realizar el “override” del método.

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

public class Triangulo extends Figura { 
	public void dibujate() { 
		//Instrucciones 
}
 }

Extender la clase triangulo con la clase abstracta Figura y definir el método abstracto dibujate:

public class Triangulo extends Figura {
...
	public void dibujate() {
	...
	}
}

Declaramos como abstract Figura y a su vez dibujate lo declaramos como abstract para que sea obligatorio implementarse en las clases que heredan de Figura.

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

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

La clase Triangulo debe heredar la clase Figura,y aplicar el @Override para sobrescribir el método.

se deberia extender de la clase figura y sobreescribir el metodo para que su comportamiento sea para la figura triangulo.

![](

`publicabstractclassFigura {

public Figura() {
}

public abstract void dibujate();

}`

`publicclassTrianguloextendsFigura{

public Triangulo() {
}

@Override
public void dibujate(){
    System.out.println("Aqui dibujo un triangulo");
}

}`

`public class Main {

public static void main(String[] args) {
    Figura f1 = new Triangulo();
    //Llamando a la clase dibujate
    f1.dibujate();
}

}`

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

public class Triangulo extent figura{

public triangulo(){
}
public void dibujar(){
system.uot.println(“dijemos un triangulo”);
}

}

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

public class Triangulo extends Figura {

@Override
public void dibujate() {
	System.out.println("Instrucciones para dibujarse");
}	

}

el método debe ser abstract para que sea obligatoria su implementación en la clase triangulo, y en la clase triangulo define los pasaos para que el método funcione

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

public class Triangulo extends Figura {
    @Override
    public void dibujate(){
        //code draw here
    }
}

public abstract class Figura {

public abstract void dibujate();

}

public class Triangulo extends Figura {

@Override
public void dibujate() {
	/*Código que dibuaj el triángulo */
}

}

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

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

public abstract class Figura {

	public abstract void dibujate(){
   }
}

public class Triangulo extends Figura{
@Override
abstract void dibujate(){
/* Lógica para dibujar triángulo */
   }
}

public abstract class Figura{

	public abstract void dibujar();
}

public class Cilindro extends Figura{

	@Override
	public void dibujar() {
		/* ... */
	}
}

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

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

}

}

Lo que se tendría que hacer seria crear la clase abstracta Figura y después crea la clase abstracta Triangulo la cual extenderá de primera clase.

• Aqui el diagrama

• El codigo

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

public class Triangulo extends Figura {

  @Override
  public void dibujate() {
      // TODO Override dibujarte function
  }
}

public class Triangulo extends Figura{

	@Override
	public void dibujate(){

	}

}

public abstract class Figura{

	public abstract void dibujate();

}

Se vería algo así

package com.neexvy.figura;

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

}

package com.neexvy.figura;

public class Triangulo extends Figura{
	
	private float base;
	private float altura;
	
	public Triangulo(float base, float altura) {
		super();
		this.base = base;
		this.altura = altura;
	}

	public float getBase() {
		return base;
	}

	public void setBase(float base) {
		this.base = base;
	}

	public float getAltura() {
		return altura;
	}

	public void setAltura(float altura) {
		this.altura = altura;
	}

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

}

Crearía una clase abstracta Figura con el método dibujable() y la implementaría Triangulo.

En este caso unicamente debo hacer la clase figure abstract e implementarla en la clase triangulo

Triangulo tiene que heredar de la clase Figura y sobreescribir el método dibujate() (si fue declarado como abstracto en figura, claro).

public class Triangulo extends Figura{
 
@overrride
pubic void  dibujate(){

}

Debería hacer que dibujate() sea abstracto y por lo tanto la clase Figura también. Para implementar este método en la clase Triangulo debo extender de Figura y sobrescribir el método abstracto.

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

public class Triangulo extends Figura {
	@Override
	public void dibujate() {
		/*
		*  Lógica necesaria para dibujar la Figura
		*  Triangulo. 
		*/
	}
}

public abstract class Figura {
	public abstract void dibujate();
}
//Heradamos de la clase figura y al heredar es obligatorio implementar las clases abstractas de la clase que se herada.
public class Triangulo extends Figura {
	@Override
	public void dibujate() {
	}
}

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

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

<public abstract class Figura{//clase abstracta y su método dibujate
public abstract void dibujate();
}
public class Triangulo extends Figura{//clase hija que hereda de Figura, junto con su método abstracto
@Override
public void dibujate();
} >

Hola, esta es mi respuesta al ejercicio:

En código

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

public class Triangulo extends Figura {

@Override
	public void dibujate() {
		// Logica para dibujar el triangulo
}

En diagrama

Aunque tengo duda si el diagrama esta bien estructurado ¿le falta algún elemento a este diagrama o tiene algún error?

Muchas gracias de antemano

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

public class Triangulo extends Figura{
	@Override
	public void dibujate(){
		// Contenido de metodo para clase Triangulo
	}
}

Aquí mi solución

Figura.java

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

Triangulo.java

public class Triangulo implements Figura {
	
	@Override
	public void dibujate(){

	/*Código para dibujar un triángulo*/
		

		}
}

• Se crea la clase abstracta Figura. Y se añade el metodo abstracto “dibujate”:
  public abtract class Figura{
  public abstrac void dibujate();

  }

• Se crea la clase Triangulo que heredara de Figura, esto obligara a que la clase Triangulo tenga el metodo “dibujate”. Y alli estara toda la implementación:

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

• Se crea la clase abstracta Figura. Y se añade el metodo abstracto “dibujate”:
  public abtract class Figura{
  public abstrac void dibujate();

}

• Se crea la clase Triangulo que heredara de Figura, esto obligara a que la clase Triangulo tenga el metodo “dibujate”. Y alli estara toda la implementación:

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

public abstract class Figura{

public abstract void dibujate();

}

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

public abstract class Figura {
	public abstract void dibujate();
}
public class Triangulo extends Figura {
	
	@Override
	public void dibujate() {
		/*Aquí defino como quiero dibujar el triangulo */
	}
	
}

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

Heredar la clase Figura e implementar el método dibujate() de tal forma que realice la acción deseada

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

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

la clase triangulo debería extender a figura, aunq este también debería tener el método dibujate(), como abstracto , ya que cada tipo de triangulo debería dibujarse de una manera diferente, ej: un escaleno seria distinto de un isósceles, deberíamos tener clases hijas de triangulo, en las cuales SI implementar dibujate()

<code>
public abstract class Figura
{
public abstract void dibujate();
}



public abstract class Triangulo extends Figura{

public abstract void dibujate();
}



public class Escaleno extends Triangulo{

public void dibujate(){
// logica adecuada para el metodo
}
}

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

public class Triangulo extends Figura{
	@override
	public void dibujate(){
		System.out.println("A Dibujar el triangulo");
	}
}

Habría que extender la clase Triangulo de Figura.