Hola compañero,
veo un poco de confusión en tu código.
Los bucle for no hacen nada porque estan vacíos. Además no son necesarios para esos métodos, donde tan solo se nos pide comprobar que el dato recibido es mayor que 0 y menor que 30 antes de pasárselo al atributo, lo cuál ha de hacerse con un if.
Y el método drawn para dibujar, se hace y se entiende más fácil usando bucles for.
Abajo posteo un código que he escrito ahora para este ejercicio, que creo que te ayudará a entender mejor como conseguir lo que se pide.
Disculpa que no haya respetado los nombres en inglés del ejercicio, pero a veces la mente se concentra mejor al escribir el código usando nombres en nuestro idioma materno y no en uno extranjero, por mucho dominio de ese idioma que podamos tener.
Te explico un poco lo que hace, aunque el código ya tiene varios comentarios y casi se explica por si solo.
- Defino la clase Rectángulo, con sus dos atributos.
- Escribo dos constructores:
Uno que no recibe parametros y creará el objeto rectángulo con su tamaño mínimo (1x1).
Otro, que si recibe parámetros, y permite indicar las dimensiones cuando vayamos a crear (instanciar) el objeto en el main().
- Getters de los atributos, ningún misterio.
- Setters de los atributos. Aquí se nos pide que comprobemos que los valores que recibamos, sean
mayor que cero y menor que 30.
Esto lo hacemos preguntando con un if.
Si se cumple la condición, pasamos esos valores a los atributos.
Si no se cumple, no hacemos nada, los atributos no se cambian con los nuevos valores. Si se quiere, se puede lanzar un mensaje indicando que los valores no son válidos por no cumplir las condiciones >0 y <30
- Método que calcula el area del rectángulo, sin misterios.
Basta con devolver el resultado de multiplicar el ancho x alto.
- Método que calcula el perímetro, sin misterios.
Basta con devolver la suma de los cuatro lados, o lo que es más rápido: sumar el ancho y el alto y multiplicarlo por 2.
- Método para dibujar el rectángulo con asteriscos. Esto si tiene un poquito de misterio, aunque no mucho.
Se puede hacer de dos formas: un rectángulo todo relleno de asteriscos o bien un rectángulo hueco, que solo tenga asteriscos en los bordes.
Esta segunda forma es un poco más liosa porque hay que usar algunos if para preguntar si estamos dibujando un borde (primera y última linea todas con *) o estamos dibujando las lineas intermedias (solo * al princpio y al final, en medio solo espacios en blanco)
Ahora no vale la pena liarse con eso y he optado por el método fácil, todo relleno de asteriscos.
Si miras el código de este método, verás que es sencillo.
Primero un par de mensajes en pantalla informando de lo que se va a dibujar.
Luego un bucle for que recorre el alto, es decir, las
filas (o lineas, como quieras llamarlas).
Anidado tenemos otros bucle for que recorre el ancho, es decir, las
columnas.
Antes del segundo bucle anidado, el que dibuja los asteriscos, hago una tabulación para que el rectángulo salga separado del borde de la pantalla. Es algo puramente estético, no es necesario realmente.
Después de este segundo bucle, si es necesario hacer un salto de línea, tal y como hacías en tu propio código.
Por último:
- La clase Rectángulo ya está definida.
Ahora creo un metodo main para poder instanciar un objeto Rectángulo, al que ya le paso unas dimensiones y directamente llamo a su método que lo dibujará en pantalla.
Y eso es todo.
Pregunta cualquier cosa que no entiendas. A lo mejor ves alguna cosa rara como que en los métodos, en los return devuelvo el resultado de operaciones sin antes haberlos guardado en una variable.
Esto es perfectamente válido y es de hecho lo habitual en estos casos.
Por ejemplo en tu código vemos este método con un fallo gordo:
public void getArea(){
int superfice;
superfice = heigth*width;
}
Primero, dices que es
void, esto significa que no va a devolver nada (void = vacio, nada..).
Entonces, este método es inútil, queremos que devuelva el resultado de calcular el Area, en este caso, ha de devolver un valor entero (int).
Por lo tanto, además ha de tener una sentencia return
public int getArea(){
int superfice;
superfice = heigth*width;
return superficie;
}
Ahora, ya funcionaría perfectamente y sería un código totalmente válido. Pero hay un detalle, estamos usando una variable llamada
superficie para almacenar el resultado y luego devolverlo.
Esto es innecesario, de hecho, una vez se ejecuta la sentencia
return, la variable superficie "se muere", desaparece, deja de existir.
Puesto que la variable tiene una vida tan efímera, apenas un par de ciclos de computación, no es necesaria crearla y podemos devolver directamente el resultado de la expresión "heigth*width" sin necesidad de almacenarla previamente.
public int getArea(){
return heigth*width;
}
Se supone que quien quiera llamar a este método en la parte del main(), ya se encargará él de guardar el computo en una variable o de sacarla por pantalla, o lo que sea...
Nuestro método simplemente ha de devolver un valor, y para ello basta con devolver el resultado de la multiplicación sin guardarlo en ningún sitio.
En fin, ya no me enrollo más. Aquí tienes mi código, cualquier duda, a preguntar por aquí.
Un saludo.
public class Rectangulo {
private int alto;
private int ancho;
/**
* Constructor sin parametros
*/
public Rectangulo()
{
alto = 1; //1 es el valor mínimo aceptable de los atributos
ancho = 1; //no puede ser 0 porque entonces no existe el rectángulo
}
/**
* Constructor que recibe parametros para definir ancho y alto
* @param alto Altura del rectangulo
* @param ancho Base o anchura del rectangulo
*/
public Rectangulo(int alto, int ancho)
{
this.alto = alto;
this.ancho = ancho;
}
public int getAncho() {return ancho;}
public int getAlto() {return alto;}
/*
Para establecer (setear) el ancho y el alto, hemos de comprobar que
los valores recibidos son mayor que 0 y menor que 30
*/
public void setAncho(int ancho)
{
if (ancho > 0 && ancho < 30)
this.ancho = ancho;
}
public void setAlto(int alto)
{
if (alto > 0 && alto < 30)
this.alto = alto;
}
/**
* Calcula el area del rectangulo (base x altura)
* @return Area del rectangulo.
*/
public int getArea()
{
return ancho*alto;
}
/**
* Calcula el perimetro del rectangulo (suma de sus 4 lados)
* @return Perimetro del rectangulo
*/
public int getPerimetro()
{
return 2 * (ancho + alto);
}
/**
* Dibuja en pantalla mediante asteriscos el objeto rectangulo
* segun los valores de sus atributos ancho y alto.
*/
public void dibujar()
{
System.out.println("\n\nRepresentación del rectángulo con los valores:");
System.out.println("Base: " + ancho + "\t" + "Altura: " + alto);
System.out.println("Area: " + getArea() + "\t" + "Perimetro: " + getPerimetro() + "\n");
for (int i = 1; i <= alto; i++)
{
System.out.print("\t");//Tabulamos un poquito para no dibujar justo en el borde de la pantalla.
for (int j = 1; j <= ancho; j++)
System.out.print("*");
System.out.println();//Ya se ha dibujado el ancho, hacemos un salto de línea para dibujar la siguiente fila.
}
}
public static void main(String args[])
{
Rectangulo miRectangulo = new Rectangulo(5,15);
miRectangulo.dibujar();
}
}
Mostrar Mensajes
RSS