|
Curso de iniciación a la programación con C# |
PISTAS PARA EL EJERCICIO 1 (ENTREGA 8)
1. La clase Punto necesita los campos de sólo lectura X e Y, que serán las coordenadas del punto. Entonces, necesitarás un constructor para asignarles los valores necesarios.
2. ¿Qué le hace falta al constructor de la clase Punto? Los dos datos que se han de guardar en las variables privadas x e y, de modo que el constructor necesitará dos argumentos: uno para x y otro para y.
3. Si necesitas cuatro propiedades de sólo lectura de tipo Punto para los vértices, necesitarás también alguna variable privada del mismo tipo para almacenar estos datos.
4. Si la base del cuadrado es horizontal, ¿necesitas realmente una variable para cada vértice? Yo creo que te sobra con una para un vértice y otra para el lado.
5. Si tienes el lado, ¿necesitas realmente variables para las propiedades de sólo lectura Area y Perimetro?
6. ¿Cómo escribimos un constructor para construir el cuadrado a partir de los vértices 1 y 3? Sencillamente, con un constructor que acepte dos argumentos del tipo Punto, y a partir de los dos vértices puedes calcular el lado.
7. ¿Cómo escribimos un constructor para construir el cuadrado a partir del vértice 1 y el lado? Con otro constructor que acepte un argumento de tipo Punto y otro de tipo uint.
8. Para escribir un método que muestre los datos del cuadrado basta con escribir uno que acepte un argumento de la clase Cuadrado.
RESOLUCIÓN DEL EJERCICIO
Bien, aquí está. Este es todo el código del ejercicio, y está convenientemente comentado. Por supuesto, se podría haber escrito de muchas formas distintas, por lo que es más que probable que el que has hecho tú no sea exactamente igual. Si el tuyo también funciona, está perfecto. Si no, intenta terminarlo siguiendo con tu idea, y usa el ejercicio que te doy ya resuelto como guía en lugar de copiarlo tal cual.
using System;
namespace Geometria
{
/// <summary>
/// Clase Punto, con dos campos de sólo lectura para almacenar
/// las coordenadas del punto.
/// </summary>
class Punto
{
// Este es el constructor de la clase
public Punto(uint x, uint y)
{
this.X=x;
this.Y=y;
}
// Estos son los campos de sólo lectura de la clase
public readonly uint X;
public readonly uint Y;
}
/// <summary>
/// Clase Cuadrado. Cada cosa está comentada.
/// </summary>
class Cuadrado
{
/* Constructor: construye un cuadrado a partir del vértice1 y
* la longitud del lado */
public Cuadrado(Punto vert1, uint lado)
{
this.vertice1=vert1;
this.lado=lado;
}
/* Constructor: construye un cuadrado a partir de los vértices
* 1 y tres. Habría que comprobar si las componentes del vértice
* 3 son mayores o menores que las del vértice1. Sin embargo, como
* aún no hemo llegado a eso vamos a presuponer que las componentes
* del vértice 3 son siempre mayores que las del uno. De todas
* formas, por si acaso, para calcular el lado tomaremos el valor
* absoluto de la diferencia. */
public Cuadrado(Punto vert1, Punto vert3)
{
this.vertice1=vert1;
this.lado=(uint) Math.Abs(vert3.X-vert1.X);
}
// Variable local para almacenar el vértice1
protected Punto vertice1;
/* Variable local para el lado. Se podría construir con un campo,
* pero el enunciado decía que tenía que ser una propiedad. */
protected uint lado;
/* Propiedad Vertice1: devuelve el Punto almacenado en la variable
* protected vertice1 */
public Punto Vertice1
{
get
{
return this.vertice1;
}
}
/* Propiedad Vertice2: como no hay variable local para almacenar
* el punto, se crea y se retorna uno nuevo: la componente X es
* igual a la X del vértice1 más la longitud del lado. */
public Punto Vertice2
{
get
{
Punto p=new Punto(this.vertice1.X + this.lado,this.vertice1.Y);
return p;
}
}
/* Propiedad Vertice3: como no hay variable local para almacenar
* el punto, se crea y se retorna uno nuevo: la componente X es
* igual a la X del vértice1 más la longitud del lado, y ocurre
* lo mismo con la componente Y */
public Punto Vertice3
{
get
{
Punto p=new Punto(this.vertice1.X + this.lado,this.vertice1.Y+this.lado);
return p;
}
}
/* Propiedad Vertice4: como no hay variable local para almacenar
* el punto, se crea y se retorna uno nuevo: la componente X es
* igual a la X del vértice1, y la componente Y es igual a la
* Y del vértice1 más la longitud del lado */
public Punto Vertice4
{
get
{
Punto p=new Punto(this.vertice1.X,this.vertice1.Y+this.lado);
return p;
}
}
/* Propiedad de lectura/escritura Lado: en el bloque get se retorna
* el valor de la variable local lado, y en el bloque set se
* asigna el nuevo valor a la variable local lado. */
public uint Lado
{
get
{
return this.lado;
}
set
{
this.lado=value;
}
}
/* Propiedad de sólo lectura Perímetro: se retorna el perímetro,
* que es cuatro veces el lado */
public uint Perimetro
{
get
{
return this.lado*4;
}
}
/* Propiedad de sólo lectura Area: se retorna el área, que es el
* cuadrado del lado */
public uint Area
{
get
{
return (uint) Math.Pow(this.lado,2);
}
}
}
}
namespace PruebaGeometria
{
using Geometria;
class GeometriaApp
{
/* Método para mostrar las propiedades del cuadrado que se le
* pase como argumento. Como debe poderse llamar al método sin
* instanciar la clase GeometriaApp, tiene que ser static */
static void PropCuadrado(Cuadrado cuad)
{
Console.WriteLine("Coordenadas de los vértices del cuadrado:");
Console.WriteLine("Vértice 1: ({0},{1})",
cuad.Vertice1.X, cuad.Vertice1.Y);
Console.WriteLine("Vértice 2: ({0},{1})",
cuad.Vertice2.X, cuad.Vertice2.Y);
Console.WriteLine("Vértice 3: ({0},{1})",
cuad.Vertice3.X, cuad.Vertice3.Y);
Console.WriteLine("Vértice 4: ({0},{1})",
cuad.Vertice4.X, cuad.Vertice4.Y);
Console.WriteLine("Longitud del lado: {0}",
cuad.Lado);
Console.WriteLine("Perímetro: {0}",
cuad.Perimetro);
Console.WriteLine("Área: {0}",
cuad.Area);
Console.WriteLine("Pulsa INTRO para continuar");
string a=Console.ReadLine();
}
/* Método Main: punto de entrada a la aplicación. En este método
* se creará un cuadrado a partir de un vértice y el lado y otro
* a partir de los vértices 1 y 3, y se harán las llamadas
* pertinentes al método PropCuadrado para mostrar sus propiedades */
static void Main()
{
// Variables para construir los puntos
uint x, y;
// Variables para construir los cuadrados
Cuadrado cuadrado;
Punto p1, p2;
uint lado;
/* Pidiendo datos para construir el primer cuadrado. No se
* incluye código para evitar errores si se introducen
* cadenas en lugar de números porque aún no se ha explicado.
* Cuando se pruebe el programa hay que tener la precaución
* de poner siempre números. */
Console.WriteLine("Cuadrado a partir del lado y un vértice");
Console.Write("Escribe componente X del vértice: ");
x=UInt32.Parse(Console.ReadLine());
Console.Write("Escribe componente Y del vértice: ");
y=UInt32.Parse(Console.ReadLine());
Console.Write("Escribe la longitud del lado: ");
lado=UInt32.Parse(Console.ReadLine());
p1=new Punto(x,y); // Construyendo el vértice1
cuadrado=new Cuadrado(p1,lado); // Construyendo el cuadrado
Console.WriteLine("Construido el cuadrado. Pulsa INTRO para ver sus propiedades");
string a=Console.ReadLine();
PropCuadrado(cuadrado); // Llamada al método PropCuadrado
/* Pidiendo los datos para construir un cuadrado a partir
* de los vértices 1 y 3. */
Console.WriteLine("Cuadrado a partir de dos vértices");
Console.Write("Escribe componente X del vértice1: ");
x=UInt32.Parse(Console.ReadLine());
Console.Write("Escribe componente Y del vértice1: ");
y=UInt32.Parse(Console.ReadLine());
p1=new Punto(x,y); // Construyendo el vértice1
Console.Write("Escribe componente X del vértice3: ");
x=UInt32.Parse(Console.ReadLine());
Console.Write("Escribe componente Y del vértice3: ");
y=UInt32.Parse(Console.ReadLine());
p2=new Punto(x,y); // Construyendo el vértice3
cuadrado=new Cuadrado(p1,p2); // Construyendo el cuadrado
Console.WriteLine("Construido el cuadrado. Pulsa INTRO para ver sus propiedades");
a=Console.ReadLine();
PropCuadrado(cuadrado); // Llamada al método PropCuadrado
}
}
}
Bien, esto es todo. Sigue este vínculo si te lo quieres bajar.