EXES
Aproximación a C#. Programación orientada a objetos
Bases generales: introducción a la tecnología .NET y bases sintácticas de C#
Espacios de nombres, clases e indicadores. Sistema de tipos de C# (CTS de .NET Framework)
Operadores de C#
Nuestra primera aplicación en C#: "Hola mundo"
Métodos (sobrecarga, argumentos y métodos static)
Constructores, destructores y el recolector de basura
Campos y propiedades
Control de flujo condicional
Control de flujo iterativo: bucles, salto y recursividad
Arrays
Indizadores, sobrecarga de operadores y conversiones definidas
Estructuras; Herencia e Interfaces
Pistas y resolución de ejercicios
Créditos
La Compañía
 
Área de Programación y Desarrollo
  Curso de Iniciación a C#
www.exes.es
Tel: 902 360 417
 Exes   Contactar 
Resolución del Ejercicio 1 | Pistas ejercicio 1 (Propuesto en Entrega 8)

RESOLUCIÓN DEL EJERCICIO 1

 

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

        }

    }

}






··> Ver todos los cursos
··> Si necesitas más información, contáctanos aquí
 
 
 
Sello de Calidad   Sello de Calidad

 

  EXES - C/ Albasanz, 14 Bis, 1-C. 28037 Madrid - Tel: 902 360 417 Fax: 902 931 305 - exes@exes.es