Programando en C# 18

En programando en C# 18 lo que vamos a aprender es clases abstractas y polimorfismo.
Las clases abstractas son aquellas que guardan y usan cosas genéricas de un objeto. Para luego heredarle a las demás clases, que son más especificas, pero del mismo tipo de objeto, todo lo general que ellos manejan.
Por ejemplo, si tengo la clase "camioneta" y la clase "ferrari", la clase general que manejaría los datos de los dos es la clase "auto".
En el caso del polimorfismo, se convinan los vectores de clase para guardar los datos de los elementos especificos en un array de la clase abstracta. Para ser más especifico, tengo un array de cuatro posiciones y guardo los datos de cuatro autos distintos, camioneta, fiat uno, duna y ferrari. En cada posición, al ser inicializado el vector, es un vector hecho a partir de una clase abstracta.

Por otro lado, la clase abstracta se caracteriza por tener métodos o argumentos abstractos, o sea, que aquellas clases a la cual le son heredados todos los métodos, pueden sobreescribir o reescribir ese método como se les plazca. Un detalle; las clases que heredan no pueden ser terminadas sin usar y reescribir los métodos abstractos. Otro detalle es que del mismo modo también se pueden hacer métodos virtuales y reescribirlos del mismo modo, la diferencia es que en el método abstracto no se lo desarrolla en la clase abstracta, mientras en el método virtual se lo puede desarrollar en la clase padre y reescribir en la clase hijo.

En el siguiente ejemplo voy a mostrar la base de como desarrollar una simple herencia con clase abstracta, y luego lo doy completo colocando un vector de clases y generando un polimorfismo. Para este ejemplo, en la interfaz visual necesitaremos dos radiobuton, dos textbox y dos botones, además de un label (Al label se le borra el texto para que quede mejor en la interfaz virtual).

La clase abstracta:

<?
    abstract class CuentaAbstracta //Notese que pongo "abstract" antes de iniciar la clase.
    {
        protected int a1, a2, r1; // Está en "protected" por lo tanto las clases hijas verán las variables.

        public CuentaAbstracta(int b1, int b2) //Constructor para darle valor a las variables.
        {
            a1 = b1;
            a2 = b2;
        }
        public abstract void Cuenta(); //Este es un método abstracto. 

        public abstract int R1 // Esta es una propiedad abstracta que solo devuelve un valor.
        {
            get;
        }       
    }
>

Esta es una de las clases que hijas:

<?
    class Resta : CuentaAbstracta //Dos puntos y ponemos en herencia la clase abstracta.
    {
        public Resta(int A1, int A2) //En la clase abstracta han notado que hay un constructor, pues este código poniéndolo en forma de constructor de la clase y luego poniéndo : base() se transmiten lo que pusimos en dicho constructor.
            : base(A1, A2) { }

        public override void Cuenta() //Override quiere decir sobreescribir, y esta es uno de los dos métodos que lo teníamos abstractos
        {
            r1 = a1 - a2;
        }
        public override int R1 //Esta es la propiedad abstracta que vimos al final de la clase abstracta.
        {
            get
            {
                return r1;
            }
        }
    }
>


Este es el segundo método:

<?
    class Suma:CuentaAbstracta //Dos puntos y la clase padre.
    {
        public Suma(int A1,int A2)//Constructor que manda los datos al contructor de la clase abstracta.
            :base(A1,A2){}

        public override void Cuenta() //Sobreescribe el método abstracto.
        {
            r1 = a1 + a2;
        }
        public override int R1 //Sobreescribe la propiedad abstracta.
        {
            get
            {
                return r1;
            }
        }
    }
>

Y este es el formulario:

<?
    public partial class Form1 : Form
    {
        Suma sum; // Inicio las instancias de las dos clases.
        Resta res;
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e) //En este botón tomo los dos valores de los textbox.
        {
            int a1 = Convert.ToInt32(textBox1.Text);
            int a2 = Convert.ToInt32(textBox2.Text);

            if (radioButton1.Checked) //Si el radiobutton1 está marcado inicia la cuenta terminando de instanciar la clase
            {
                sum = new Suma(a1, a2);
                sum.Cuenta();//Genero el método Cuenta en la clase Suma.
                label3.Text = Convert.ToString(sum.R1); //Escribo en el label el resultado.
            }
            else //Como son dos radiobutton, si uno no está marcado, quiere decir que es el otro. 
            {
                res = new Resta(a1, a2); //Inicio la resta con finalizar la instancia y coloco los resultados en el constructor.
                res.Cuenta(); //Hago la Cuenta en la clase Resta.
                label3.Text = Convert.ToString(res.R1); // Coloco el resultado en el label.
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Application.Exit();
        }

    }
>


Ahora el ejemplo con el polimorfismo:
NOTA: Acá, para aquellos que saben y me observan, ya corrijo mucho de los errores de sintaxis o mejor dicho de modo de hacer las cosas. Como que lo hago como corresponde a mucho de esto.

La clase abstracta:

<?
    abstract class Abstracta //Clase abstracta.
    {
        protected int res; //Variable de resultado en protected, para que la vean el resto de las clases hijas.

        public abstract void Calcular(int N1, int N2); //Método abstracto de calculo.

        public int Resultado //Propiedad no abstracta de devolución de datos.
        {
            get
            {
                return res;
            }
        }
    }
>


La clase Resta:

<?
    class Resta: Abstracta //La resta hereda de Abstracta, o sea que es hija de la clase padre "Abstracta"
    {
        public override void Calcular(int N1, int N2) //Método en override que sobreescribe el calculo.
        {
            res = N1 - N2;
        }
    }
>

La clase Suma:

<?
    class Suma : Abstracta //La suma hereda de Abstracta, o sea que es hija de la clase padre "Abstracta"
    {
        public override void Calcular(int N1, int N2) //Método en override que sobreescribe el calculo.
        {
            res = N1 + N2;
        }
    }
>

El formulario:

<?
    public partial class Form1 : Form
    {
        Abstracta[] Abs;//Inicio la instancia de vector de clases abstracta.
        public Form1()
        {
            InitializeComponent();
            Abs = new Abstracta[2]; //A dicho vector lo dejo con dos posiciones, una para suma y otra para resta.
        }

        private void button2_Click(object sender, EventArgs e)
        {
            Close(); //Boton que cierra. (primer botón)
        }

        private void button1_Click(object sender, EventArgs e) //Botón que genera el calculo.
        {
            Suma Sum = new Suma();
            Resta Res = new Resta(); //Se instancian las dos clases.

            int N1 = Convert.ToInt32(textBox1.Text);
            int N2 = Convert.ToInt32(textBox2.Text); //Las variables toman los valores de dos textbox.

            if (radioButton1.Checked) //Si el radiobuton1 está marcado...
            {
                Sum.Calcular(N1, N2);//Hace el cálculo con las dos variables.
                Abs[0] = Sum;//Guarda en la primera posición la suma.
            }
            else if(radioButton2.Checked) //Si no está marcado, y está marcado radiobutton2...
            {
                Res.Calcular(N1, N2); //Hace el cálculo con las dos variables
                Abs[1] = Res;//Guarda en la segunda posición toda la clase resta.
            }           
        }

        private void button3_Click(object sender, EventArgs e)//Tercer botón para ver el resultado.
        {
            if (radioButton1.Checked && Abs[0] != null) //Si el radiobutton1 (suma) está marcado y la posición 0 del vector es distinto a nulo (sin valores)...
            {
                label1.Text = Abs[0].Resultado.ToString(); //Me muestra en el label el resultado guardado en la posición primera.
            }
            else if (radioButton2.Checked && Abs[1] != null)//Si el radiobutton2 (resta) está marcado y la posición 1 del vector es distinto a nulo (sin valores)...
            {
                label1.Text = Abs[1].Resultado.ToString();//Me muestra en el label el resultado guardado en la posición primera.
            }
        }
    }
>


NOTA: Cualquier duda, no duden en mandarme mensajes en T!, es un tema que no suele ser facil de entender. En este caso lo hice simple, pero hay programas donde pueden tener 500 líneas de código y no es fácil producir estas clases de cosas.