Key Object-Oriented Concepts and how to use them in Visual C#

3:06:00 am OOPs 0 Comments

// (1): (virtual)
//      In Visual C#, members that can be overriden must be declared
//          as virtual.
// (2): (Sphere: Circle)
//      Sphere class inherits all of methods and properties defined //          in Circle.
// (3): (override)
//      Sphere overrides the methods for Area, because
//          sphere use a different formula for this calculation.
//      A virtual method can be overridden in a derived class.
// (4): (new)
//      Sphere shadows the Center method because
//          sphere have an additional coordinate (z)
//          and you wouldn't want users to accidentally set
//          xy-coordinates without setting a z-coordinate.
// (5): (base)
//      Notice that Sphere uses the base keyword to call
//          the base class's Center method within the shadowed 
//          method.

// Interface for all shapes.
public interface IFigure
{
    float Top
    {
        get;
        set;
    }
    float Left
    {
        get;
        set;
    }

    float Area();
    float Perimeter();
}
// To use the inteface, implement it in a class
public abstract class Shape : IFigure
{
    // Constructor
 public Shape()
 {
 }

    public abstract float Top
    {
        get;
        set;
    }
    public abstract float Left
    {
        get;
        set;
    }

    public abstract float Area();
    public abstract float Perimeter();
}
public class Circle : Shape
{
    float fxCenter, fyCenter, fRadius;
    // Constructor
    public Circle()
    {
        // Intialize internal variables.
        fxCenter = 0;
        fyCenter = 0;
        fRadius = 0;
    }

    public override float Top
    {
        get
        {
            return fxCenter - fRadius;
        }
        set
        {
            fxCenter = value + fRadius;
        }
    }
    public override float Left
    {
        get
        {
            return fyCenter - fRadius;
        }
        set
        {
            fyCenter = value + fRadius;
        }
    }
    public float Radius
    {
        get
        {
            return fRadius;
        }
        set
        {
            fRadius = value;
        }
    }

    public override float Area()
    {
        return (float)(System.Math.PI * Math.Pow((double)fRadius, 
                       2));
    }

    public override float Perimeter()
    {
        return 2 * fRadius * (float)System.Math.PI;
    }

    public virtual void Center(float X, float Y)    // (1)
    {
        fxCenter = X;
        fyCenter = Y;
    }
}
public class Sphere : Circle                        // (2)
{
    float fCenter;

    // Constructor
    public Sphere()
    {
        // Initialize internal variable.
        fCenter = 0;
    }
    public float Front
    {
        get
        {
            return fCenter - base.Radius;
        }
        set
        {
            fCenter = value + base.Radius;
        }
    }

    public override float Area()                    // (3)
    {
        return (float)(4 * Math.PI * Math.Pow((double)base.Radius, 
                       2));
    }

    public void Center(float X, float Y, float Z)
    {
        base.Center(X, Y);                          // (5)
        fCenter = Z;
    }

    public new void Center(float X, float Y)        // (4)
    {
        this.Center(X, Y, 0);
    }

    public float Volume()
    {
        return (float)((4 / 3) * System.Math.PI * 
                       Math.Pow((double)base.Radius, 3));
    }
}
public partial class _Default : System.Web.UI.Page 
{
    // Displays the shape info on the Web form.
    // Because the Shape abstract class in this example implements 
    //     the IFigure interface,
    //     all derived classes from Shape can be used as the 
    //     arguments of the type IFigure.
    private void ShowShapeInfo(IFigure Shape)
    {
        // Since Shape argument is IFigure, we know it has these 
               members.
        Response.Write(String.Format("Shape Top : {0} <br>", 
                       Shape.Top));
        Response.Write(String.Format("Shape Left: {0} <br>", 
                       Shape.Left));
        Response.Write(String.Format("Shape Area: {0} <br>", 
                       Shape.Area()));
        Response.Write(String.Format("Shape Primeter: {0} <br>", 
                       Shape.Perimeter()));
    }

    protected void Page_Load(object sender, EventArgs e)
    {
        // Create a circle
        Circle MyCircle = new Circle();
        MyCircle.Radius = 2;
        MyCircle.Center(10, 2);
        // Create a sphere
        Sphere MySphere = new Sphere();
        MySphere.Radius = 10;
        MySphere.Center(10, 20, 25);
        // Show info about each shape.
        ShowShapeInfo(MyCircle);
        ShowShapeInfo(MySphere);
    }
}