imagina que eu tenho o seguinte código: ``` public class Retangulo { public virtual void CalcularArea(int _base, int _altura) { Console.WriteLine("A

Muito obrigado pela explicação, Claudio, me ajudou muito!

sobreposição de métodos | C# parte 3: entendendo herança e interface

imagina que eu tenho o seguinte código:

public class Retangulo
    {
        public virtual void CalcularArea(int _base, int _altura)
        {
            Console.WriteLine("A área do retangulo é: " + (_base * _altura));
        }
    }

public class Triangulo : Retangulo
    {
        public override void CalcularArea(int _base, int _altura)
        {
            Console.WriteLine("A área do triangulo é: " + (_base * _altura)/2);


            static void Main(string[] args)
        {
            Retangulo retangulo = new Retangulo();

            retangulo.CalcularArea(10, 35);

            Triangulo triangulo = new Triangulo();

            triangulo.CalcularArea(10, 35);

            Console.ReadLine();
        }

imagine que eu queira criar agora uma outra classe, com outra figura geométrica qualquer , e no momento, eu não deva mais receber os parâmetros base e altura, mas outros parametros quaisquer, como raio, diâmetro, e por ai vai, eu poderia mudar esses parametros do método sobrescrito ? ou melhor, adicionar novos? por exemplo :

public override void CalcularArea(int _base, int _altura_ , int parametroqualquer ) `

aqui eu coloqueri um parâmetro a mais que não possui na classe base.

Para usar override, não é possível alterar a "assinatura" do método. Assim, não é possível acrescentar um parâmetro no método na classe derivada. Uma solução, que eu não gosto, é usar array como parâmetro:

public virtual void CalcularArea(double[] parametros)

Deste modo as classes derivadas poderiam usar array também. Mas, tem o inconveniente de verificar se a quantidade de elementos foi passada adequadamente em cada implementação do método na classe derivada. Listas e outros arranjos múltiplos de dados poderiam ser usados também.

Outra solução: Os parâmetros poderiam ser propriedades das classes e o método CalcularArea poderia usar as propriedades e não parâmetros. Isto já contornaria a questão. Eu iria mais além um pouco e criaria uma classe base (FiguraGeometrica) abstrata para ficar um modelo que me parece melhor.

class Program
    {
        static void Main(string[] args)
        {
            Retangulo retangulo = new Retangulo(10,35);

            retangulo.CalcularArea();

            Triangulo triangulo = new Triangulo(10,35);

            triangulo.CalcularArea();

            FiguraComTresParametros fig = new FiguraComTresParametros(5, 5, 35);

            fig.CalcularArea();

            Console.ReadLine();
        }
    }
    public abstract class FiguraGeometrica
    {
        public abstract void CalcularArea();
    }

    public class Retangulo : FiguraGeometrica
    {
        public double Lado1 { get; set; }
        public double Lado2 { get; set; }
        public Retangulo(double lado1, double lado2) 
        {
            Lado1 = lado1;
            Lado2 = lado2;
        }
        public override void CalcularArea()
        {
            Console.WriteLine("A área do retangulo é: " + (Lado1 * Lado2));
        }
    }

    public class Triangulo : FiguraGeometrica
    {
        public double Base { get; set; }
        public double Altura { get; set; }
        public Triangulo(double baseT, double altura)
        {
            Base = baseT;
            Altura = altura;
        }

        public override void CalcularArea()
        {
            Console.WriteLine("A área do triangulo é: " + (Base * Altura) / 2);
        }

    }

    public class FiguraComTresParametros : FiguraGeometrica
    {
        public double Prop1 { get; set; }
        public double Prop2 { get; set; }
        public double Prop3 { get; set; }
        public FiguraComTresParametros(double prop1, double prop2, double prop3)
        {
            Prop1 = prop1;
            Prop2 = prop2;
            Prop3 = prop3;
        }

        public override void CalcularArea()
        {
            // um exemplo com três propriedades
            Console.WriteLine("A área da figura é : " + (Prop1 + Prop2) * Prop3);
        }
    }

Chegou a hora de transformar