Абстрактный статический метод — как?

Как обычно реализуют эту ситуацию?

Обычное решение состоит в том, чтобы сделать рассматриваемый метод методом экземпляра.

getNumberOfLegs(), очевидно, должен быть статическим методом (при условии, что в идеальном мире у нас нет покалеченных цыплят и собак, поэтому getNumberOfLegs не зависит от экземпляра).

Это категорически не очевидно! Мы не программируем идеальный мир, и в реальном мире четвероногие животные иногда имеют одну, две или три (или пять) ног.

Если вашей программе нужны определения животных, а не экземпляры животных, создайте класс для этого.

class AnimalDefinition {
    public string getScientificName();
    public string getCommonName();
    public int    getNumberOfLegs();
    public bool   getIsAmphibious();
    // etc.
}

Затем инициализируйте набор из них в начале вашей программы — в идеале из базы данных или файла конфигурации, куда вы можете добавить определения животных без написания или компиляции еще одной строки кода. (И вы можете обойтись гораздо меньшим количеством типов.)

Ваш псевдокод очень похож на Java, поэтому я предполагаю, что вы используете именно Java.

«Абстрактный метод требует реализации для каждого экземпляра. Статические методы относятся ко всему классу. Статический метод в абстрактном классе принадлежит к абстрактному классу, а не к потенциальным реализациям. Поэтому не имеет смысла разрешать абстрактные статические методы. статические методы не могут быть переопределены, так что опять же, абстрактные статические методы были бы аномалией».

Из http://forums.sun.com/thread.jspa?threadID=597378

Также посмотрите Почему я не могу определить статический метод в интерфейсе Java?

Это действительно хороший момент, и иногда abstract static действительно не хватает. Однако, поскольку в настоящее время память не является проблемой, вы, безусловно, можете реализовать метод getNumberLegs() в качестве метода экземпляра.

Говорить о том, что статическая абстракция бессмысленна, неверно. PHP допускает абстрактные статические методы (см. это), и ваш сценарий показывает, что в некоторых ситуациях это может быть полезно.

Также неверно утверждать, что static методы нельзя переопределить; Методы final нельзя переопределить. В таких языках, как Java и C#, static идет с final. Вот почему многие предполагают, что static означает «не переопределяемый».

Говоря о С# (прочитав ваши комментарии, я предполагаю, что вы «говорите» на С#), вы можете рассмотреть возможность использования дженериков и атрибутов (или дженериков и аннотаций в Java):

public class Animal
{
   public static int GetNumberOfLegs<T>() where T : Animal
   {
     //Get T's custom attribute "NumberOfLegs" and return its value 
   }

   //EDIT: Added runtime-version of GetNumberOfLegs.
   public static int GetNumberOfLegs(Type t)
   {
     //Get t's custom attribute "NumberOfLegs" and return its value 

   }
}

[NumberOfLegs(4)]
public class Cat { ... };

Это позволит вам получить количество ветвей каждого типа без его создания. Только не забудьте указать атрибут [NumberOfLegs(x)]. Вы также должны знать тип во время компиляции (для универсальной версии метода).

РЕДАКТИРОВАТЬ: я добавил исполняемую версию метода GetNumberOfLegs(), которому вы можете передать объект Type (должен быть Class для Java). В этом случае вам нужно будет выполнить проверку типа во время выполнения, то есть проверить, наследуется ли тип, представленный объектом Type-/Class, от Animal, а затем получить значение, переданное в атрибуте/аннотации.

Использование:

int numberOfLegs1 = Animal.GetNumberOfLegs<Cat>(); 
int numberOfLegs2 = Animal.GetNumberOfLegs(typeof(Cat)); //runtime version

Как обычно поступают в такой ситуации?

В терминах Java я бы просто объявил конструктор в абстрактном классе, который принимает фиксированный аргумент. Затем каждый подкласс должен вызывать его, иначе он не будет компилироваться.

abstract class Animal {
    private int numberOfLegs;

    public Animal(int numberOfLegs) {
        this.numberOfLegs = numberOfLegs;
    }

    public int getNumberOfLegs() {
        return numberOfLegs;
    }
}

class Chicken extends Animal {
    public Chicken() {
        super(2);
    }
}

class Dog extends Animal {
    public Dog() {
        super(4);
    }
}

Обновление: согласно вашему обновлению

EDIT: Вот как я могу это использовать. Предположим (теперь это смешно, но все же...), что количество ног каждого животного уникально, поэтому я мог бы иметь что-то вроде:

Animal getModelAnimal(int numberOfLegs) {
   if (numberOfLegs == Chicken.getNumberOfLegs()) return new Chicken();
   else if (numberOfLegs == Dog.getNumberOfLegs()) return new Dog();
}

Это действительно смешно, для этого требуется, чтобы все эти конкретные животные были заранее известны в абстрактном фабричном методе. Вам нужно будет обновлять метод абстрактной фабрики каждый раз, когда добавляется новый конкретный тип животного. В чем тогда смысл абстрактной фабрики? Вы уже все знаете заранее? Нет, просто позвольте методу абстрактной фабрики принять полное имя класса в качестве идентификатора или около того, чтобы он мог попытаться загрузить из пути к классам (все еще говоря в терминах Java).

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

Это интересный вопрос. На мой взгляд, "статические абстрактные" методы нужны редко, и всегда есть хорошие альтернативы.

Например, в приведенном вами варианте использования фабричный метод обращается к конкретным классам животных по имени; для каждого нового класса животных должен быть добавлен новый специальный код. Поэтому кажется, что «абстрактная» квалификация на самом деле не нужна. Достаточно соглашения о предоставлении статического метода getNumberLegs().

И вообще, объединение абстрактного и статического не имеет смысла (в Java), поскольку abstract подразумевает полиморфизм, а вызовы static вообще не полиморфны и работают с классами, известными в время компиляции.

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

Абстрактные методы имеют смысл, если вы вызываете их в помощь базовому классу. Обратите внимание, что в вашем примере вы вообще не используете полиморфизм. В примере должно быть что-то вроде:

  (Animal)Dog.getNumberOfLegs() //cast Dog to Animal first

В любом случае PHP реализует так называемое «позднее статическое связывание», которое, вероятно, вы ищете.

http://php.net/manual/en/language.oop5.late-static-bindings.php

В C++ аналогичная функциональность может быть достигнута с помощью шаблонов и полиморфизма времени компиляции.

abstract static имеют смысл только в языках, в которых переменные могут содержать фактические типы, а не только экземпляры. (Delphi — один из таких языков, C# — нет, и я не думаю, что вы сможете сделать это и на Java). Причина в том, что если вы точно знаете во время компиляции, какие классы вы используете (как в вашем примере), то нет причин для того, чтобы метод был abstract, вы могли бы просто иметь static методы в каждом классе с одинаковым именем вещи. Единственный способ, которым вы могли бы не знать, какие типы вы используете, - это если вы можете назначать типы переменной, так как тогда вы можете передавать их (точно так же, как экземпляры классов), и вдруг все действительно имеет смысл и полезно.

Я думаю, что большинство компиляторов/языков, которые поддерживают назначение типов (а также экземпляров типов) переменным, также могут поддерживать методы abstract static и virtual abstract с помощью магии компилятора, поэтому, если они действительно полезны в выбранном вами языке, их следует поддерживать.

еще один подход, который я вижу здесь, - это создать абстрактную фабрику: это С#, вам не нужно создавать экземпляр курицы, чтобы узнать количество ног. просто вызовите фабричный метод проверки

abstract class AnimalFactory
{
    public abstract Animal CreateAnimal();
    public abstract int GetLegs();

}
abstract class Animal
{

}
internal class Chicken : Animal
{

}
class CreateChicken : AnimalFactory
{
    public override Animal CreateAnimal()
    {
        return new Chicken();
    }
    public override int GetLegs()
    {
        return 2;
    }

}

На мгновение предположим, что "абстрактные статические методы" разрешены.

Затем, используя ваш код, я добавляю это:

Animal modelAnimal;
int numLegs;

modelAnimal = this.getModelAnimal(4); // Got a dog

numLegs = modelAnimal.getNumberOfLegs();

Я получаю сообщение об ошибке, так как modelAnimal, который является объектом Dog, попытается вызвать getNumberOfLegs в классе Animal, а не Класс Собака. Нет переопределения известных вам статических методов. Чтобы избежать этой ситуации, разработчики не включили абстрактные статические методы.