C sharp - metodo virtual y de reemplazo en una clase derivada

   
Vista:

metodo virtual y de reemplazo en una clase derivada

Publicado por Miguel Gavilán (1 intervención) el 30/07/2015 11:07:24
Hola buenas a todos y muchas gracias de antemano por vuestras respuestas. Estoy estudiando algunas cosas sobre herencias en C# y quisiera saber cual es la diferencia entre usar un método virtual en la clase base y reescribirlo en la clase derivada con un método de reemplazo (override) y usar un método virtual en la clase derivada que oculte el método original. Aquí pongo un ejemplo:

Como ejemplo pongo una clase base que tiene dos puntos Y, X y una clase derivada que incrementa a tres puntos con Z y lo que quiero es imprimir sus valores.

Opción 1: Método virtual en clase base y de reemplazo en la clase derivada.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class P2d
    {
        public int x, y;
        public virtual void Print() //   <--------------- método virtual
        {
            Console.WriteLine("({0}, {1})", x,y);
        }
    }
    class P3d:P2d
    {
        public int z;
        public override void Print()  // <------------------ método de reemplazo
        {
            Console.WriteLine("({0}, {1}, {2})", x, y,z);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            P2d p2 = new P2d();
            P3d p3 = new P3d();
 
            p2.x = 100;
            p2.y = 200;
            p3.x = 150;
            p3.y = 250;
            p3.z = 350;
            p2.Print();
            p3.Print();
            Console.ReadKey();
 
        }
    }


Y la opción 2 es utilizando el método virtual que oculte el método original:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class P2d
    {
        public int x, y;
        public void Print()  //    <----------------Método normalmente construido
        {
            Console.WriteLine("({0}, {1})", x,y);
        }
    }
    class P3d:P2d
    {
        public int z;
        new public void Print()  // <-------------------- Método virtual 
        {
            Console.WriteLine("({0}, {1}, {2})", x, y,z);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            P2d p2 = new P2d();
            P3d p3 = new P3d();
 
            p2.x = 100;
            p2.y = 200;
            p3.x = 150;
            p3.y = 250;
            p3.z = 350;
            p2.Print();
            p3.Print();
            Console.ReadKey();
 
        }
    }

El resultado ya se que es el mismo, pero me gustaría saber cual es al diferencia entre uno y otro, cual es mejor usar y otras posibles connotaciones que pudiera tener.

Muchas gracias.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder