polyporphism.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace Poly
{
    class A { public void Test() { Console.Write("A:: "); } }
    class B : A {  }
    class C : B {  }
    
    class D { public void Test() { Console.Write("A:: "); } }
    class E : D { public void Test() { Console.Write("B:: "); } }
    class F : E { public void Test() { Console.Write("C:: "); } }
    
    class G { public void Test() { Console.Write("A:: "); } }
    class H : G { public new void Test() { Console.Write("B:: "); } }
    class I : H { public new void Test() { Console.Write("C:: "); } }
 
    class J { public virtual void Test() { Console.Write("A:: "); } }
    class K : J { public override void Test() { Console.Write("B:: "); } }
    class L : K { public override void Test() { Console.Write("C:: "); } }
 
    class M { public void Test() { Console.Write("A:: "); } }
    class N : M { public virtual void Test() { Console.Write("B:: "); } }
    class O : N { public override void Test() { Console.Write("C:: "); } }
 
    public class Program
    {
        public static void Main(string[] args)
        {
            //----------------------------------------------------------------------
            //----------------------------------------------------------------------
            A a = new A();
            B b = new B();
            C c = new C();

            Console.WriteLine("Polymorphism: A::Test() inherited by B and C");
            Console.Write("Test ABC: => ");
            a.Test(); //  --> "A::"
            b.Test(); //  --> "B::"
            c.Test(); //  --> "C::"
 
            Console.Write("\nTest BC:  => ");
            a = new B();
            b = new C();
            a.Test(); //  --> "A::"
            b.Test(); //  --> "A::"
 
 
            //----------------------------------------------------------------------
            //----------------------------------------------------------------------
            D d = new D();
            E e = new E();
            F f = new F();

            Console.WriteLine("\n\nPolymorphism: Test() in A, B, and C (imlicit hiding without 'new')");
            Console.Write("Test ABC: => ");
            d.Test(); //  --> "A::"
            e.Test(); //  --> "B::"
            f.Test(); //  --> "C::"
 
            d = new E();
            e = new F();
            Console.Write("\nTest BC:  => ");
            d.Test(); //  --> "A::"
            e.Test(); //  --> "B::"
 
 
            //----------------------------------------------------------------------
            //----------------------------------------------------------------------
            G g = new G();
            H h = new H();
            I i = new I();

            Console.WriteLine("\n\nPolymorphism: Test() in A, B, and C (explicit hiding with 'new')");
            Console.Write("Test ABC: => ");
            g.Test(); //  --> "A::"
            h.Test(); //  --> "B::"
            i.Test(); //  --> "C::"
 
            g = new H();
            h = new I();
            Console.Write("\nTest BC:  => ");
            g.Test(); //  --> "A::"
            h.Test(); //  --> "B::"
 
 
            //----------------------------------------------------------------------
            //----------------------------------------------------------------------
            J j = new J();
            K k = new K();
            L l = new L();

            Console.WriteLine("\n\nPolymorphism: Test() in A, B, and C ('virtual' and 'override')");
            Console.Write("Test ABC: => ");
            j.Test(); //  --> "A::"
            k.Test(); //  --> "B::"
            l.Test(); //  --> "C::"
 
            j = new K();
            k = new L();
            Console.Write("\nTest BC:  => ");
            j.Test(); //  --> "B::"
            k.Test(); //  --> "C::"
 
 
            //----------------------------------------------------------------------
            //----------------------------------------------------------------------
            M m = new M();
            N n = new N();
            O o = new O();

            Console.WriteLine("\n\nPolymorphism: Test() in A, B, and C (mixed hidden and overridden)");
            Console.Write("Test ABC: => ");
            m.Test(); //  --> "A::"
            n.Test(); //  --> "B::"
            o.Test(); //  --> "C::"
 
            m = new N();
            n = new O();
            Console.Write("\nTest BC:  => ");
            m.Test(); //  --> "A::"
            n.Test(); //  --> "C::"
        }
    }
}