Почему наследование не работает так, как я думаю, должно работать?

Короткий ответ заключается в том, что GetLeg не зависит от типа возвращаемого значения. Подробный ответ можно найти здесь: Ковариантность и контравариантность

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

Очевидно, вам понадобится гипс, если вы оперируете сломанную DogLeg.

Dog должен возвращать Leg, а не DogLeg в качестве возвращаемого типа. Фактическим классом может быть DogLeg, но смысл в том, чтобы отделить его от пользователя, чтобы пользователю Dog не нужно было знать о DogLegs, ему нужно знать только о Legs.

Изменять:

class Dog : Animal
{
  public override DogLeg GetLeg() {...}
}

to:

class Dog : Animal
{
  public override Leg GetLeg() {...}
}

Не делайте этого:

 if(a instanceof Dog){
       DogLeg dl = (DogLeg)a.GetLeg();

это противоречит цели программирования абстрактного типа.

Причина скрытия DogLeg заключается в том, что функция GetLeg в абстрактном классе возвращает абстрактную ногу. Если вы переопределяете GetLeg, вы должны вернуть Leg. В этом смысл наличия метода в абстрактном классе. Чтобы распространить этот метод на его дочерние элементы. Если вы хотите, чтобы пользователи Dog знали о DogLegs, создайте метод GetDogLeg и верните DogLeg.

Если бы вы МОГЛИ поступить так, как хочет задающий вопрос, то каждый пользователь Animal должен был бы знать обо ВСЕХ животных.

Вполне оправдано желание иметь сигнатуру переопределяющего метода с типом возвращаемого значения, являющимся подтипом возвращаемого типа в переопределенном методе (phew). В конце концов, они совместимы с типами времени выполнения.

Но C# еще не поддерживает ковариантные возвращаемые типы в переопределенных методах (в отличие от C++ [1998] и Java [2004]).

В обозримом будущем вам придется обходиться и обходиться, как заявил Эрик Липперт в его блог [19 июня 2008 г.]:

Такая дисперсия называется ковариацией возвращаемого типа.

у нас нет планов реализовать такую ​​вариативность в C#.

abstract class Animal
{
  public virtual Leg GetLeg ()
}

abstract class Leg { }

class Dog : Animal
{
  public override Leg GetLeg () { return new DogLeg(); }
}

class DogLeg : Leg { void Hump(); }

Сделайте это так, тогда вы сможете использовать абстракцию в своем клиенте:

Leg myleg = myDog.GetLeg();

Затем, если вам нужно, вы можете разыграть его:

if (myleg is DogLeg) { ((DogLeg)myLeg).Hump()); }

Полностью надуманный, но дело в том, что вы можете сделать это:

foreach (Animal a in animals)
{
   a.GetLeg().SomeMethodThatIsOnAllLegs();
}

При этом сохраняется возможность использовать специальный метод горба на Doglegs.

Вы можете использовать дженерики и интерфейсы для реализации этого на С#:

abstract class Leg { }

interface IAnimal { Leg GetLeg(); }

abstract class Animal<TLeg> : IAnimal where TLeg : Leg
 { public abstract TLeg GetLeg();
   Leg IAnimal.GetLeg() { return this.GetLeg(); }
 }

class Dog : Animal<Dog.DogLeg>
 { public class DogLeg : Leg { }
   public override DogLeg GetLeg() { return new DogLeg();}
 } 

GetLeg() должен возвращать Leg, чтобы быть переопределением. Однако ваш класс Dog по-прежнему может возвращать объекты DogLeg, поскольку они являются дочерними классами Leg. клиенты могут затем отливать и работать с ними как с изгибами.

public class ClientObj{
    public void doStuff(){
    Animal a=getAnimal();
    if(a is Dog){
       DogLeg dl = (DogLeg)a.GetLeg();
    }
  }
}

Концепция, вызывающая у вас проблемы, описана на странице http://en.wikipedia.org/wiki/Covariance_and_contravariance_(computer_science)

Не то, чтобы это было очень полезно, но может быть интересно отметить, что Java поддерживает ковариантные возвраты, и поэтому это будет работать именно так, как вы надеялись. За исключением, очевидно, того, что у Java нет свойств;)

Возможно, проще увидеть проблему на примере:

Animal dog = new Dog();
dog.SetLeg(new CatLeg());

Теперь это должно скомпилироваться, если вы скомпилировали Dog, но нам, вероятно, не нужен такой мутант.

Связанный с этим вопрос: должен ли Dog[] быть Animal[] или IList‹Dog> должен быть IList‹Animal>?

C# имеет явные реализации интерфейса для решения именно этой проблемы:

abstract class Leg { }
class DogLeg : Leg { }

interface IAnimal
{
    Leg GetLeg();
}

class Dog : IAnimal
{
    public override DogLeg GetLeg() { /* */ }

    Leg IAnimal.GetLeg() { return GetLeg(); }
}

Если у вас есть Dog через ссылку типа Dog, то вызов GetLeg() вернет DogLeg. Если у вас есть тот же объект, но ссылка имеет тип IAnimal, то он вернет Leg.

Да, я понимаю, что могу просто разыграть, но это означает, что клиент должен знать, что у собак есть DogLegs. Мне интересно, есть ли технические причины, по которым это невозможно, учитывая, что существует неявное преобразование.

@ Брайан Лихи Очевидно, что если вы работаете с ним только как с ногой, нет необходимости или причины использовать его. Но если есть какое-то специфическое поведение DogLeg или Dog, иногда есть причины, по которым бросок необходим.

Вы также можете вернуть интерфейс ILeg, который реализован как Leg, так и DogLeg.

Важно помнить, что вы можете использовать производный тип везде, где вы используете базовый тип (вы можете передать Dog любому методу/свойству/полю/переменной, которая ожидает Animal)

Возьмем эту функцию:

public void AddLeg(Animal a)
{
   a.Leg = new Leg();
}

Совершенно корректная функция, теперь давайте вызовем ее так:

AddLeg(new Dog());

Если свойство Dog.Leg не относится к типу Leg, функция AddLeg внезапно содержит ошибку и не может быть скомпилирована.

@Люк

Я думаю, что вы, возможно, неправильно понимаете наследование. Dog.GetLeg() вернет объект DogLeg.

public class Dog{
    public Leg GetLeg(){
         DogLeg dl = new DogLeg(super.GetLeg());
         //set dogleg specific properties
    }
}


    Animal a = getDog();
    Leg l = a.GetLeg();
    l.kick();

фактически вызываемый метод будет Dog.GetLeg(); и DogLeg.Kick() (я предполагаю, что существует метод Leg.kick()), поскольку объявленный тип возвращаемого значения DogLeg не является обязательным, потому что это то, что возвращается, даже если тип возвращаемого значения для Dog.GetLeg() Нога.

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

abstract class Animal<LegType> where LegType : Leg
{
    public abstract LegType GetLeg();
}

abstract class Leg { }

class Dog : Animal<DogLeg>
{
    public override DogLeg GetLeg()
    {
        return new DogLeg();
    }
}

class DogLeg : Leg { }