Полиморфизм без использования виртуального ключевого слова

Question

Очевидно, что использование виртуального и переопределения - это нормальная ситуация, но подсчитывает ли этот показатель telecoms'ish?

public class Pipe 
{ 
    // whole bunch of protected member variables such as bandwidth, latency, download limit 
    // etc, 

    public int GetCost() 
    { 
    // work out cost based on above 
    } 
} 

public class BigFatPipe : Pipe 
{ 
    public BigFatPipe() 
    { 
    // sets up the member variables one way 
    } 
} 

public class CheapestPossiblePipe: Pipe 
{ 
    public CheapestPossiblePipe() 
    { 
    // sets up the member variables another way 
    } 
} 

, то вы могли бы назвать

PrintPrice(new BigFatPipe()) 

PrintPrice(new CheapestPossiblePipe()) 

public void PrintPrice(Pipe pipe) 
{ 
    int a = pipe.GetCost(); 
    .... 
} 

Вы получите два разных ответа. Это не самый полезный пример, но он рассчитывает?

Answer 1

Этот post here содержит полезное обсуждение того, что именно представляет собой полиморфизм.

Я думаю, что в большинстве определений явно не указано, что объект должен иметь виртуальные функции, чтобы быть полиморфными - так что да, я думаю, что ваш пример имеет значение.

Answer 2

Перегрузка конструктора является признанным методом реализации статического полиморфизма. Хотя это не перегрузка конструктора, это близко. Так что да, я бы назвал это полиморфизмом.

Answer 3

Если бы я тебя, я хотел бы использовать folowing подход:

public interface IGetCost 
{ 
    int GetCost(); 
} 

public class Pipe : IGetCost 
{ 
    public int GetCost(){} 
} 

public class BigFatPipe : IGetCost 
{ 
    //aggregation 
    private readonly Pipe _pipe; 

    public BigFatPipe(Pipe pipe) 
    { 
     _pipe = pipe; 
    } 
    public int GetCost() { } 
} 

public class CheapestPossiblePipe : IGetCost 
{ 
    private readonly Pipe _pipe; 

    public CheapestPossiblePipe(Pipe pipe) 
    { 
     _pipe = pipe; 
    } 
    public int GetCost() { } 
} 

public static void PrintPrice(IGetCost obj) 
{ 
    int cost = obj.GetCost(); 
    Console.WriteLine(cost); 
} 

static void Main(string[] args) 
{ 
    IGetCost p; 

    p = new Pipe(); 
    PrintPrice(p); 

    p = new BigFatPipe(); 
    PrintPrice(p); 

    p = new CheapestPossiblePipe(); 
    PrintPrice(p); 
} 

Я также должен сказать, что вы две разные вещи - полиморфизма и перегрузки

полиморфизма

public class foo 
{ 
    public virtual void foo1{/*....*/} 
} 

public class fooA : foo 
{ 
    public override void foo1{/*....*/} 
} 

public class fooB : foo 
{ 
    public new void foo1{/*....*/} 
} 

public class fooC : foo 
{ 
    //new is the default modifier 
    public void foo1{/*....*/} 
} 

перегружать

public class foo{ 
    public int foo1{/*....*/} 
    public int foo1(int a){/*....*/} 
    public int foo1(string a){/*....*/} 
    public int foo1(int a, string b){/*....*/} 
} 

Answer 4

Этот шаблон действительно работает, но введение кучи классов путает пользователя бесполезно: они будут задаваться вопросом, что делают классы по-разному.

Несколько заводов методы будут делать ту же работу, и будет легче понять и поддерживать:

public class Pipe 
{ 
    // whole bunch of private member variables such as bandwidth, latency, download limit 
    // etc, 

    public int GetCost() 
    { 
    // work out cost based on above 
    } 

    public static Pipe MakeBigFatPipe() 
    { 
     var result = new Pipe(); 
     // sets up the member variables one way 
     return result; 
    } 

    public static Pipe MakeCheapestPossiblePipe() 
    { 
     var result = new Pipe(); 
     // sets up the member variables another way 
     return result; 
    } 
}